diff options
Diffstat (limited to 'ext/reflection/php_reflection.c')
| -rw-r--r-- | ext/reflection/php_reflection.c | 287 |
1 files changed, 144 insertions, 143 deletions
diff --git a/ext/reflection/php_reflection.c b/ext/reflection/php_reflection.c index 991f0da341..87ffeba666 100644 --- a/ext/reflection/php_reflection.c +++ b/ext/reflection/php_reflection.c @@ -46,12 +46,18 @@ #define reflection_update_property(object, name, value) do { \ zval member; \ - ZVAL_STRINGL(&member, name, sizeof(name)-1); \ + ZVAL_STR(&member, name); \ zend_std_write_property(object, &member, value, NULL); \ - if (Z_REFCOUNTED_P(value)) Z_DELREF_P(value); \ + Z_TRY_DELREF_P(value); \ zval_ptr_dtor(&member); \ } while (0) +#define reflection_update_property_name(object, value) \ + reflection_update_property(object, ZSTR_KNOWN(ZEND_STR_NAME), value) + +#define reflection_update_property_class(object, value) \ + reflection_update_property(object, ZSTR_KNOWN(ZEND_STR_CLASS), value) + /* Class entry pointers */ PHPAPI zend_class_entry *reflector_ptr; PHPAPI zend_class_entry *reflection_exception_ptr; @@ -157,41 +163,22 @@ static inline reflection_object *reflection_object_from_obj(zend_object *obj) { static zend_object_handlers reflection_object_handlers; -static zval *_default_load_entry(zval *object, char *name, size_t name_len) /* {{{ */ +static zval *_default_load_name(zval *object) /* {{{ */ { - zval *value; - - if ((value = zend_hash_str_find_ind(Z_OBJPROP_P(object), name, name_len)) == NULL) { - return NULL; - } - return value; + return zend_hash_find_ex_ind(Z_OBJPROP_P(object), ZSTR_KNOWN(ZEND_STR_NAME), 1); } /* }}} */ -static void _default_get_entry(zval *object, char *name, int name_len, zval *return_value) /* {{{ */ +static void _default_get_name(zval *object, zval *return_value) /* {{{ */ { zval *value; - if ((value = _default_load_entry(object, name, name_len)) == NULL) { + if ((value = _default_load_name(object)) == NULL) { RETURN_FALSE; } - ZVAL_DUP(return_value, value); -} -/* }}} */ - -#ifdef ilia_0 -static void _default_lookup_entry(zval *object, char *name, int name_len, zval **return_value) /* {{{ */ -{ - zval **value; - - if (zend_hash_find(Z_OBJPROP_P(object), name, name_len, (void **) &value) == FAILURE) { - *return_value = NULL; - } else { - *return_value = *value; - } + ZVAL_COPY(return_value, value); } /* }}} */ -#endif static zend_function *_copy_function(zend_function *fptr) /* {{{ */ { @@ -214,7 +201,7 @@ static void _fix_closure_prototype(zend_function *fptr) /* {{{ */ { /* Actually we are setting proxy function's prototype to null * as for it, the prototype is an object not a function - * which could cause serias problems, see #74949 */ + * which could cause serious problems, see #74949 */ fptr->common.prototype = NULL; } /* }}} */ @@ -283,10 +270,7 @@ static HashTable *reflection_get_gc(zval *obj, zval **gc_data, int *gc_data_coun static zend_object *reflection_objects_new(zend_class_entry *class_type) /* {{{ */ { - reflection_object *intern; - - intern = ecalloc(1, sizeof(reflection_object) + zend_object_properties_size(class_type)); - intern->zo.ce = class_type; + reflection_object *intern = zend_object_alloc(sizeof(reflection_object), class_type); zend_object_std_init(&intern->zo, class_type); object_properties_init(&intern->zo, class_type); @@ -556,11 +540,15 @@ static void _const_string(smart_str *str, char *name, zval *value, char *indent) if (Z_TYPE_P(value) == IS_ARRAY) { smart_str_append_printf(str, "%s Constant [ %s %s ] { Array }\n", indent, type, name); + } else if (Z_TYPE_P(value) == IS_STRING) { + smart_str_append_printf(str, "%s Constant [ %s %s ] { %s }\n", + indent, type, name, Z_STRVAL_P(value)); } else { - zend_string *value_str = zval_get_string(value); + zend_string *tmp_value_str; + zend_string *value_str = zval_get_tmp_string(value, &tmp_value_str); smart_str_append_printf(str, "%s Constant [ %s %s ] { %s }\n", indent, type, name, ZSTR_VAL(value_str)); - zend_string_release(value_str); + zend_tmp_string_release(tmp_value_str); } } /* }}} */ @@ -578,12 +566,13 @@ static void _class_const_string(smart_str *str, char *name, zend_class_constant smart_str_append_printf(str, "%sConstant [ %s %s %s ] { Array }\n", indent, visibility, type, name); } else { - zend_string *value_str = zval_get_string(&c->value); + zend_string *tmp_value_str; + zend_string *value_str = zval_get_tmp_string(&c->value, &tmp_value_str); smart_str_append_printf(str, "%sConstant [ %s %s %s ] { %s }\n", indent, visibility, type, name, ZSTR_VAL(value_str)); - zend_string_release(value_str); + zend_tmp_string_release(tmp_value_str); } } /* }}} */ @@ -649,7 +638,7 @@ static void _parameter_string(smart_str *str, zend_function *fptr, struct _zend_ zval zv; smart_str_appends(str, " = "); - ZVAL_DUP(&zv, RT_CONSTANT(&fptr->op_array, precv->op2)); + ZVAL_COPY(&zv, RT_CONSTANT(precv, precv->op2)); if (UNEXPECTED(zval_update_constant_ex(&zv, fptr->common.scope) == FAILURE)) { zval_ptr_dtor(&zv); return; @@ -670,9 +659,10 @@ static void _parameter_string(smart_str *str, zend_function *fptr, struct _zend_ } else if (Z_TYPE(zv) == IS_ARRAY) { smart_str_appends(str, "Array"); } else { - zend_string *zv_str = zval_get_string(&zv); + zend_string *tmp_zv_str; + zend_string *zv_str = zval_get_tmp_string(&zv, &tmp_zv_str); smart_str_append(str, zv_str); - zend_string_release(zv_str); + zend_tmp_string_release(tmp_zv_str); } zval_ptr_dtor(&zv); } @@ -741,7 +731,6 @@ static void _function_string(smart_str *str, zend_function *fptr, zend_class_ent smart_str param_indent = {0}; zend_function *overwrites; zend_string *lc_name; - size_t lc_name_len; /* TBD: Repair indenting of doc comment (or is this to be done in the parser?) * What's "wrong" is that any whitespace before the doc comment start is @@ -765,15 +754,13 @@ static void _function_string(smart_str *str, zend_function *fptr, zend_class_ent if (fptr->common.scope != scope) { smart_str_append_printf(str, ", inherits %s", ZSTR_VAL(fptr->common.scope->name)); } else if (fptr->common.scope->parent) { - lc_name_len = ZSTR_LEN(fptr->common.function_name); - lc_name = zend_string_alloc(lc_name_len, 0); - zend_str_tolower_copy(ZSTR_VAL(lc_name), ZSTR_VAL(fptr->common.function_name), lc_name_len); + lc_name = zend_string_tolower(fptr->common.function_name); if ((overwrites = zend_hash_find_ptr(&fptr->common.scope->parent->function_table, lc_name)) != NULL) { if (fptr->common.scope != overwrites->common.scope) { smart_str_append_printf(str, ", overwrites %s", ZSTR_VAL(overwrites->common.scope->name)); } } - efree(lc_name); + zend_string_release(lc_name); } } if (fptr->common.prototype && fptr->common.prototype->common.scope) { @@ -1127,7 +1114,7 @@ PHPAPI void zend_reflection_class_factory(zend_class_entry *ce, zval *object) intern->ptr = ce; intern->ref_type = REF_TYPE_OTHER; intern->ce = ce; - reflection_update_property(object, "name", &name); + reflection_update_property_name(object, &name); } /* }}} */ @@ -1143,7 +1130,7 @@ static void reflection_extension_factory(zval *object, const char *name_str) lcname = zend_string_alloc(name_len, 0); zend_str_tolower_copy(ZSTR_VAL(lcname), name_str, name_len); module = zend_hash_find_ptr(&module_registry, lcname); - zend_string_free(lcname); + zend_string_efree(lcname); if (!module) { return; } @@ -1154,7 +1141,7 @@ static void reflection_extension_factory(zval *object, const char *name_str) intern->ptr = module; intern->ref_type = REF_TYPE_OTHER; intern->ce = NULL; - reflection_update_property(object, "name", &name); + reflection_update_property_name(object, &name); } /* }}} */ @@ -1189,7 +1176,7 @@ static void reflection_parameter_factory(zend_function *fptr, zval *closure_obje Z_ADDREF_P(closure_object); ZVAL_COPY_VALUE(&intern->obj, closure_object); } - reflection_update_property(object, "name", &name); + reflection_update_property_name(object, &name); } /* }}} */ @@ -1231,7 +1218,7 @@ static void reflection_function_factory(zend_function *function, zval *closure_o Z_ADDREF_P(closure_object); ZVAL_COPY_VALUE(&intern->obj, closure_object); } - reflection_update_property(object, "name", &name); + reflection_update_property_name(object, &name); } /* }}} */ @@ -1254,8 +1241,8 @@ static void reflection_method_factory(zend_class_entry *ce, zend_function *metho Z_ADDREF_P(closure_object); ZVAL_COPY_VALUE(&intern->obj, closure_object); } - reflection_update_property(object, "name", &name); - reflection_update_property(object, "class", &classname); + reflection_update_property_name(object, &name); + reflection_update_property_class(object, &classname); } /* }}} */ @@ -1300,8 +1287,8 @@ static void reflection_property_factory(zend_class_entry *ce, zend_property_info intern->ref_type = REF_TYPE_PROPERTY; intern->ce = ce; intern->ignore_visibility = 0; - reflection_update_property(object, "name", &name); - reflection_update_property(object, "class", &classname); + reflection_update_property_name(object, &name); + reflection_update_property_class(object, &classname); } /* }}} */ @@ -1321,8 +1308,8 @@ static void reflection_class_constant_factory(zend_class_entry *ce, zend_string intern->ref_type = REF_TYPE_CLASS_CONSTANT; intern->ce = constant->ce; intern->ignore_visibility = 0; - reflection_update_property(object, "name", &name); - reflection_update_property(object, "class", &classname); + reflection_update_property_name(object, &name); + reflection_update_property_class(object, &classname); } /* }}} */ @@ -1366,9 +1353,7 @@ static void _reflection_export(INTERNAL_FUNCTION_PARAMETERS, zend_class_entry *c fci.params = params; fci.no_separation = 1; - fcc.initialized = 1; fcc.function_handler = ce_ptr->constructor; - fcc.calling_scope = ce_ptr; fcc.called_scope = Z_OBJCE(reflector); fcc.object = Z_OBJ(reflector); @@ -1577,7 +1562,7 @@ ZEND_METHOD(reflection_function, __construct) if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS(), "O", &closure, zend_ce_closure) == SUCCESS) { fptr = (zend_function*)zend_get_closure_method_def(closure); Z_ADDREF_P(closure); - } else { + } else { if (zend_parse_parameters_throw(ZEND_NUM_ARGS(), "s", &name_str, &name_len) == FAILURE) { return; } @@ -1601,7 +1586,7 @@ ZEND_METHOD(reflection_function, __construct) } ZVAL_STR_COPY(&name, fptr->common.function_name); - reflection_update_property(object, "name", &name); + reflection_update_property_name(object, &name); intern->ptr = fptr; intern->ref_type = REF_TYPE_FUNCTION; if (closure) { @@ -1637,7 +1622,7 @@ ZEND_METHOD(reflection_function, getName) if (zend_parse_parameters_none() == FAILURE) { return; } - _default_get_entry(getThis(), "name", sizeof("name")-1, return_value); + _default_get_name(getThis(), return_value); } /* }}} */ @@ -1846,11 +1831,11 @@ ZEND_METHOD(reflection_function, getStaticVariables) GET_REFLECTION_OBJECT_PTR(fptr); /* Return an empty array in case no static variables exist */ - array_init(return_value); if (fptr->type == ZEND_USER_FUNCTION && fptr->op_array.static_variables != NULL) { + array_init(return_value); if (GC_REFCOUNT(fptr->op_array.static_variables) > 1) { if (!(GC_FLAGS(fptr->op_array.static_variables) & IS_ARRAY_IMMUTABLE)) { - GC_REFCOUNT(fptr->op_array.static_variables)--; + GC_DELREF(fptr->op_array.static_variables); } fptr->op_array.static_variables = zend_array_dup(fptr->op_array.static_variables); } @@ -1860,6 +1845,8 @@ ZEND_METHOD(reflection_function, getStaticVariables) } } ZEND_HASH_FOREACH_END(); zend_hash_copy(Z_ARRVAL_P(return_value), fptr->op_array.static_variables, zval_add_ref); + } else { + ZVAL_EMPTY_ARRAY(return_value); } } /* }}} */ @@ -1891,9 +1878,7 @@ ZEND_METHOD(reflection_function, invoke) fci.params = params; fci.no_separation = 1; - fcc.initialized = 1; fcc.function_handler = fptr; - fcc.calling_scope = zend_get_executed_scope(); fcc.called_scope = NULL; fcc.object = NULL; @@ -1952,9 +1937,7 @@ ZEND_METHOD(reflection_function, invokeArgs) fci.params = params; fci.no_separation = 1; - fcc.initialized = 1; fcc.function_handler = fptr; - fcc.calling_scope = zend_get_executed_scope(); fcc.called_scope = NULL; fcc.object = NULL; @@ -2046,6 +2029,11 @@ ZEND_METHOD(reflection_function, getParameters) num_args++; } + if (!num_args) { + ZVAL_EMPTY_ARRAY(return_value); + return; + } + array_init(return_value); for (i = 0; i < num_args; i++) { zval parameter; @@ -2227,7 +2215,7 @@ ZEND_METHOD(reflection_generator, getFunction) if (ex->func->common.fn_flags & ZEND_ACC_CLOSURE) { zval closure; - ZVAL_OBJ(&closure, (zend_object *) ex->func->common.prototype); + ZVAL_OBJ(&closure, ZEND_CLOSURE_OBJECT(ex->func)); reflection_function_factory(ex->func, &closure, return_value); } else if (ex->func->op_array.scope) { reflection_method_factory(ex->func->op_array.scope, ex->func, NULL, return_value); @@ -2271,7 +2259,7 @@ ZEND_METHOD(reflection_generator, getExecutingGenerator) REFLECTION_CHECK_VALID_GENERATOR(ex) current = zend_generator_get_current(generator); - ++GC_REFCOUNT(¤t->std); + GC_ADDREF(¤t->std); ZVAL_OBJ(return_value, (zend_object *) current); } @@ -2464,7 +2452,7 @@ ZEND_METHOD(reflection_parameter, __construct) } else { ZVAL_NULL(&name); } - reflection_update_property(object, "name", &name); + reflection_update_property_name(object, &name); ref = (parameter_reference*) emalloc(sizeof(parameter_reference)); ref->arg_info = &arg_info[position]; @@ -2506,7 +2494,7 @@ ZEND_METHOD(reflection_parameter, getName) if (zend_parse_parameters_none() == FAILURE) { return; } - _default_get_entry(getThis(), "name", sizeof("name")-1, return_value); + _default_get_name(getThis(), return_value); } /* }}} */ @@ -2805,8 +2793,8 @@ ZEND_METHOD(reflection_parameter, getDefaultValue) return; } - ZVAL_DUP(return_value, RT_CONSTANT(¶m->fptr->op_array, precv->op2)); - if (Z_CONSTANT_P(return_value)) { + ZVAL_COPY(return_value, RT_CONSTANT(precv, precv->op2)); + if (Z_TYPE_P(return_value) == IS_CONSTANT_AST) { zval_update_constant_ex(return_value, param->fptr->common.scope); } } @@ -2829,8 +2817,13 @@ ZEND_METHOD(reflection_parameter, isDefaultValueConstant) } precv = _reflection_param_get_default_precv(INTERNAL_FUNCTION_PARAM_PASSTHRU, param); - if (precv && Z_TYPE_P(RT_CONSTANT(¶m->fptr->op_array, precv->op2)) == IS_CONSTANT) { - RETURN_TRUE; + if (precv && Z_TYPE_P(RT_CONSTANT(precv, precv->op2)) == IS_CONSTANT_AST) { + zend_ast *ast = Z_ASTVAL_P(RT_CONSTANT(precv, precv->op2)); + + if (ast->kind == ZEND_AST_CONSTANT + || ast->kind == ZEND_AST_CONSTANT_CLASS) { + RETURN_TRUE; + } } RETURN_FALSE; @@ -2854,8 +2847,14 @@ ZEND_METHOD(reflection_parameter, getDefaultValueConstantName) } precv = _reflection_param_get_default_precv(INTERNAL_FUNCTION_PARAM_PASSTHRU, param); - if (precv && Z_TYPE_P(RT_CONSTANT(¶m->fptr->op_array, precv->op2)) == IS_CONSTANT) { - RETURN_STR_COPY(Z_STR_P(RT_CONSTANT(¶m->fptr->op_array, precv->op2))); + if (precv && Z_TYPE_P(RT_CONSTANT(precv, precv->op2)) == IS_CONSTANT_AST) { + zend_ast *ast = Z_ASTVAL_P(RT_CONSTANT(precv, precv->op2)); + + if (ast->kind == ZEND_AST_CONSTANT) { + RETURN_STR_COPY(zend_ast_get_constant_name(ast)); + } else if (ast->kind == ZEND_AST_CONSTANT_CLASS) { + RETURN_STRINGL("__CLASS__", sizeof("__CLASS__")-1); + } } } /* }}} */ @@ -2912,17 +2911,9 @@ ZEND_METHOD(reflection_type, isBuiltin) static zend_string *reflection_type_name(type_reference *param) { if (ZEND_TYPE_IS_CLASS(param->arg_info->type)) { return zend_string_copy(ZEND_TYPE_NAME(param->arg_info->type)); - } - switch (ZEND_TYPE_CODE(param->arg_info->type)) { - /* keep this for BC, bool vs boolean, int vs integer */ - case _IS_BOOL: return zend_string_init("bool", sizeof("bool") - 1, 0); - case IS_LONG: return zend_string_init("int", sizeof("int") - 1, 0); - /* use zend API for other types */ - default: - { - char *name = zend_get_type_by_const(ZEND_TYPE_CODE(param->arg_info->type)); - return zend_string_init(name, strlen(name), 0); - } + } else { + char *name = zend_get_type_by_const(ZEND_TYPE_CODE(param->arg_info->type)); + return zend_string_init(name, strlen(name), 0); } } /* }}} */ @@ -2938,7 +2929,7 @@ ZEND_METHOD(reflection_type, __toString) return; } GET_REFLECTION_OBJECT_PTR(param); - + RETURN_STR(reflection_type_name(param)); } /* }}} */ @@ -2949,12 +2940,12 @@ ZEND_METHOD(reflection_named_type, getName) { reflection_object *intern; type_reference *param; - + if (zend_parse_parameters_none() == FAILURE) { return; } GET_REFLECTION_OBJECT_PTR(param); - + RETURN_STR(reflection_type_name(param)); } /* }}} */ @@ -3052,9 +3043,9 @@ ZEND_METHOD(reflection_method, __construct) efree(lcname); ZVAL_STR_COPY(&name, mptr->common.scope->name); - reflection_update_property(object, "class", &name); + reflection_update_property_class(object, &name); ZVAL_STR_COPY(&name, mptr->common.function_name); - reflection_update_property(object, "name", &name); + reflection_update_property_name(object, &name); intern->ptr = mptr; intern->ref_type = REF_TYPE_FUNCTION; intern->ce = ce; @@ -3203,9 +3194,7 @@ static void reflection_method_invoke(INTERNAL_FUNCTION_PARAMETERS, int variadic) fci.params = params; fci.no_separation = 1; - fcc.initialized = 1; fcc.function_handler = mptr; - fcc.calling_scope = obj_ce; fcc.called_scope = intern->ce; fcc.object = object ? Z_OBJ_P(object) : NULL; @@ -3340,7 +3329,7 @@ ZEND_METHOD(reflection_function, inNamespace) if (zend_parse_parameters_none() == FAILURE) { return; } - if ((name = _default_load_entry(getThis(), "name", sizeof("name")-1)) == NULL) { + if ((name = _default_load_name(getThis())) == NULL) { RETURN_FALSE; } if (Z_TYPE_P(name) == IS_STRING @@ -3363,7 +3352,7 @@ ZEND_METHOD(reflection_function, getNamespaceName) if (zend_parse_parameters_none() == FAILURE) { return; } - if ((name = _default_load_entry(getThis(), "name", sizeof("name")-1)) == NULL) { + if ((name = _default_load_name(getThis())) == NULL) { RETURN_FALSE; } if (Z_TYPE_P(name) == IS_STRING @@ -3386,7 +3375,7 @@ ZEND_METHOD(reflection_function, getShortName) if (zend_parse_parameters_none() == FAILURE) { return; } - if ((name = _default_load_entry(getThis(), "name", sizeof("name")-1)) == NULL) { + if ((name = _default_load_name(getThis())) == NULL) { RETURN_FALSE; } if (Z_TYPE_P(name) == IS_STRING @@ -3596,8 +3585,8 @@ ZEND_METHOD(reflection_class_constant, __construct) intern->ref_type = REF_TYPE_CLASS_CONSTANT; intern->ce = constant->ce; intern->ignore_visibility = 0; - reflection_update_property(object, "name", &name); - reflection_update_property(object, "class", &cname); + reflection_update_property_name(object, &name); + reflection_update_property_class(object, &cname); } /* }}} */ @@ -3614,7 +3603,7 @@ ZEND_METHOD(reflection_class_constant, __toString) return; } GET_REFLECTION_OBJECT_PTR(ref); - _default_get_entry(getThis(), "name", sizeof("name")-1, &name); + _default_get_name(getThis(), &name); _class_const_string(&str, Z_STRVAL(name), ref, ""); zval_ptr_dtor(&name); RETURN_STR(smart_str_extract(&str)); @@ -3628,7 +3617,7 @@ ZEND_METHOD(reflection_class_constant, getName) if (zend_parse_parameters_none() == FAILURE) { return; } - _default_get_entry(getThis(), "name", sizeof("name")-1, return_value); + _default_get_name(getThis(), return_value); } /* }}} */ @@ -3697,8 +3686,8 @@ ZEND_METHOD(reflection_class_constant, getValue) } GET_REFLECTION_OBJECT_PTR(ref); - ZVAL_DUP(return_value, &ref->value); - if (Z_CONSTANT_P(return_value)) { + ZVAL_COPY_OR_DUP(return_value, &ref->value); + if (Z_TYPE_P(return_value) == IS_CONSTANT_AST) { zval_update_constant_ex(return_value, ref->ce); } } @@ -3760,7 +3749,7 @@ static void reflection_class_object_ctor(INTERNAL_FUNCTION_PARAMETERS, int is_ob return; } } else { - if (zend_parse_parameters(ZEND_NUM_ARGS(), "z/", &argument) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &argument) == FAILURE) { return; } } @@ -3770,11 +3759,10 @@ static void reflection_class_object_ctor(INTERNAL_FUNCTION_PARAMETERS, int is_ob if (Z_TYPE_P(argument) == IS_OBJECT) { ZVAL_STR_COPY(&classname, Z_OBJCE_P(argument)->name); - reflection_update_property(object, "name", &classname); + reflection_update_property_name(object, &classname); intern->ptr = Z_OBJCE_P(argument); if (is_object) { - ZVAL_COPY_VALUE(&intern->obj, argument); - zval_add_ref(argument); + ZVAL_COPY(&intern->obj, argument); } } else { convert_to_string_ex(argument); @@ -3786,7 +3774,7 @@ static void reflection_class_object_ctor(INTERNAL_FUNCTION_PARAMETERS, int is_ob } ZVAL_STR_COPY(&classname, ce->name); - reflection_update_property(object, "name", &classname); + reflection_update_property_name(object, &classname); intern->ptr = ce; } @@ -3830,11 +3818,11 @@ static void add_class_vars(zend_class_entry *ce, int statics, zval *return_value /* copy: enforce read only access */ ZVAL_DEREF(prop); - ZVAL_DUP(&prop_copy, prop); + ZVAL_COPY_OR_DUP(&prop_copy, prop); /* this is necessary to make it able to work with default array * properties, returned to user */ - if (Z_CONSTANT(prop_copy)) { + if (Z_TYPE(prop_copy) == IS_CONSTANT_AST) { if (UNEXPECTED(zval_update_constant_ex(&prop_copy, NULL) != SUCCESS)) { return; } @@ -3975,7 +3963,7 @@ ZEND_METHOD(reflection_class, getName) if (zend_parse_parameters_none() == FAILURE) { return; } - _default_get_entry(getThis(), "name", sizeof("name")-1, return_value); + _default_get_name(getThis(), return_value); } /* }}} */ @@ -4336,7 +4324,6 @@ ZEND_METHOD(reflection_class, getProperty) } } str_name = ZSTR_VAL(name); - str_name_len = ZSTR_LEN(name); if ((tmp = strstr(ZSTR_VAL(name), "::")) != NULL) { classname_len = tmp - ZSTR_VAL(name); classname = zend_string_alloc(classname_len, 0); @@ -4486,7 +4473,7 @@ ZEND_METHOD(reflection_class, getConstants) zend_class_entry *ce; zend_string *key; zend_class_constant *c; - zval *val; + zval val; if (zend_parse_parameters_none() == FAILURE) { return; @@ -4498,8 +4485,8 @@ ZEND_METHOD(reflection_class, getConstants) zend_array_destroy(Z_ARRVAL_P(return_value)); return; } - val = zend_hash_add_new(Z_ARRVAL_P(return_value), key, &c->value); - Z_TRY_ADDREF_P(val); + ZVAL_COPY_OR_DUP(&val, &c->value); + zend_hash_add_new(Z_ARRVAL_P(return_value), key, &val); } ZEND_HASH_FOREACH_END(); } /* }}} */ @@ -4549,7 +4536,7 @@ ZEND_METHOD(reflection_class, getConstant) if ((c = zend_hash_find_ptr(&ce->constants_table, name)) == NULL) { RETURN_FALSE; } - ZVAL_DUP(return_value, &c->value); + ZVAL_COPY_OR_DUP(return_value, &c->value); } /* }}} */ @@ -4755,7 +4742,7 @@ ZEND_METHOD(reflection_class, newInstance) } for (i = 0; i < num_args; i++) { - if (Z_REFCOUNTED(params[i])) Z_ADDREF(params[i]); + Z_TRY_ADDREF(params[i]); } fci.size = sizeof(fci); @@ -4766,9 +4753,7 @@ ZEND_METHOD(reflection_class, newInstance) fci.params = params; fci.no_separation = 1; - fcc.initialized = 1; fcc.function_handler = constructor; - fcc.calling_scope = zend_get_executed_scope(); fcc.called_scope = Z_OBJCE_P(return_value); fcc.object = Z_OBJ_P(return_value); @@ -4868,9 +4853,7 @@ ZEND_METHOD(reflection_class, newInstanceArgs) fci.params = params; fci.no_separation = 1; - fcc.initialized = 1; fcc.function_handler = constructor; - fcc.calling_scope = zend_get_executed_scope(); fcc.called_scope = Z_OBJCE_P(return_value); fcc.object = Z_OBJ_P(return_value); @@ -4906,17 +4889,17 @@ ZEND_METHOD(reflection_class, getInterfaces) } GET_REFLECTION_OBJECT_PTR(ce); - /* Return an empty array if this class implements no interfaces */ - array_init(return_value); - if (ce->num_interfaces) { uint32_t i; + array_init(return_value); for (i=0; i < ce->num_interfaces; i++) { zval interface; zend_reflection_class_factory(ce->interfaces[i], &interface); zend_hash_update(Z_ARRVAL_P(return_value), ce->interfaces[i]->name, &interface); } + } else { + ZVAL_EMPTY_ARRAY(return_value); } } /* }}} */ @@ -4934,7 +4917,12 @@ ZEND_METHOD(reflection_class, getInterfaceNames) } GET_REFLECTION_OBJECT_PTR(ce); - /* Return an empty array if this class implements no interfaces */ + if (!ce->num_interfaces) { + /* Return an empty array if this class implements no interfaces */ + ZVAL_EMPTY_ARRAY(return_value); + return; + } + array_init(return_value); for (i=0; i < ce->num_interfaces; i++) { @@ -4956,6 +4944,11 @@ ZEND_METHOD(reflection_class, getTraits) } GET_REFLECTION_OBJECT_PTR(ce); + if (!ce->num_traits) { + ZVAL_EMPTY_ARRAY(return_value); + return; + } + array_init(return_value); for (i=0; i < ce->num_traits; i++) { @@ -4979,6 +4972,11 @@ ZEND_METHOD(reflection_class, getTraitNames) } GET_REFLECTION_OBJECT_PTR(ce); + if (!ce->num_traits) { + ZVAL_EMPTY_ARRAY(return_value); + return; + } + array_init(return_value); for (i=0; i < ce->num_traits; i++) { @@ -4987,7 +4985,7 @@ ZEND_METHOD(reflection_class, getTraitNames) } /* }}} */ -/* {{{ proto public arra ReflectionClass::getTraitaliases() +/* {{{ proto public array ReflectionClass::getTraitAliases() Returns an array of trait aliases */ ZEND_METHOD(reflection_class, getTraitAliases) { @@ -4999,10 +4997,11 @@ ZEND_METHOD(reflection_class, getTraitAliases) } GET_REFLECTION_OBJECT_PTR(ce); - array_init(return_value); if (ce->trait_aliases) { uint32_t i = 0; + + array_init(return_value); while (ce->trait_aliases[i]) { zend_string *mname; zend_trait_method_reference *cur_ref = ce->trait_aliases[i]->trait_method; @@ -5015,6 +5014,8 @@ ZEND_METHOD(reflection_class, getTraitAliases) } i++; } + } else { + ZVAL_EMPTY_ARRAY(return_value); } } /* }}} */ @@ -5207,7 +5208,7 @@ ZEND_METHOD(reflection_class, inNamespace) if (zend_parse_parameters_none() == FAILURE) { return; } - if ((name = _default_load_entry(getThis(), "name", sizeof("name")-1)) == NULL) { + if ((name = _default_load_name(getThis())) == NULL) { RETURN_FALSE; } if (Z_TYPE_P(name) == IS_STRING @@ -5230,7 +5231,7 @@ ZEND_METHOD(reflection_class, getNamespaceName) if (zend_parse_parameters_none() == FAILURE) { return; } - if ((name = _default_load_entry(getThis(), "name", sizeof("name")-1)) == NULL) { + if ((name = _default_load_name(getThis())) == NULL) { RETURN_FALSE; } if (Z_TYPE_P(name) == IS_STRING @@ -5253,7 +5254,7 @@ ZEND_METHOD(reflection_class, getShortName) if (zend_parse_parameters_none() == FAILURE) { return; } - if ((name = _default_load_entry(getThis(), "name", sizeof("name")-1)) == NULL) { + if ((name = _default_load_name(getThis())) == NULL) { RETURN_FALSE; } if (Z_TYPE_P(name) == IS_STRING @@ -5374,8 +5375,8 @@ ZEND_METHOD(reflection_property, __construct) ZVAL_STR_COPY(&cname, ce->name); ZVAL_STRINGL(&propname, name_str, name_len); } - reflection_update_property(object, "class", &cname); - reflection_update_property(object, "name", &propname); + reflection_update_property_class(object, &cname); + reflection_update_property_name(object, &propname); reference = (property_reference*) emalloc(sizeof(property_reference)); if (dynam_prop) { @@ -5418,7 +5419,7 @@ ZEND_METHOD(reflection_property, getName) if (zend_parse_parameters_none() == FAILURE) { return; } - _default_get_entry(getThis(), "name", sizeof("name")-1, return_value); + _default_get_name(getThis(), return_value); } /* }}} */ @@ -5505,7 +5506,7 @@ ZEND_METHOD(reflection_property, getValue) GET_REFLECTION_OBJECT_PTR(ref); if (!(ref->prop.flags & (ZEND_ACC_PUBLIC | ZEND_ACC_IMPLICIT_PUBLIC)) && intern->ignore_visibility == 0) { - name = _default_load_entry(getThis(), "name", sizeof("name")-1); + 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; @@ -5566,7 +5567,7 @@ ZEND_METHOD(reflection_property, setValue) GET_REFLECTION_OBJECT_PTR(ref); if (!(ref->prop.flags & ZEND_ACC_PUBLIC) && intern->ignore_visibility == 0) { - name = _default_load_entry(getThis(), "name", sizeof("name")-1); + 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; @@ -5723,7 +5724,7 @@ ZEND_METHOD(reflection_extension, __construct) } free_alloca(lcname, use_heap); ZVAL_STRING(&name, module->name); - reflection_update_property(object, "name", &name); + reflection_update_property_name(object, &name); intern->ptr = module; intern->ref_type = REF_TYPE_OTHER; intern->ce = NULL; @@ -5754,7 +5755,7 @@ ZEND_METHOD(reflection_extension, getName) if (zend_parse_parameters_none() == FAILURE) { return; } - _default_get_entry(getThis(), "name", sizeof("name")-1, return_value); + _default_get_name(getThis(), return_value); } /* }}} */ @@ -5812,7 +5813,7 @@ static int _addconstant(zval *el, int num_args, va_list args, zend_hash_key *has int number = va_arg(args, int); if (number == constant->module_number) { - ZVAL_DUP(&const_val, &constant->value); + ZVAL_COPY_OR_DUP(&const_val, &constant->value); zend_hash_update(Z_ARRVAL_P(retval), constant->name, &const_val); } return 0; @@ -5950,15 +5951,15 @@ ZEND_METHOD(reflection_extension, getDependencies) } GET_REFLECTION_OBJECT_PTR(module); - array_init(return_value); - dep = module->deps; if (!dep) { + ZVAL_EMPTY_ARRAY(return_value); return; } + array_init(return_value); while(dep->name) { zend_string *relation; char *rel_type; @@ -6085,7 +6086,7 @@ ZEND_METHOD(reflection_zend_extension, __construct) return; } ZVAL_STRING(&name, extension->name); - reflection_update_property(object, "name", &name); + reflection_update_property_name(object, &name); intern->ptr = extension; intern->ref_type = REF_TYPE_OTHER; intern->ce = NULL; @@ -6683,11 +6684,11 @@ static const zend_function_entry reflection_zend_extension_functions[] = { }; /* }}} */ -const zend_function_entry reflection_ext_functions[] = { /* {{{ */ +static const zend_function_entry reflection_ext_functions[] = { /* {{{ */ PHP_FE_END }; /* }}} */ -static zend_object_handlers *zend_std_obj_handlers; +static const zend_object_handlers *zend_std_obj_handlers; /* {{{ _reflection_write_property */ static void _reflection_write_property(zval *object, zval *member, zval *value, void **cache_slot) @@ -6754,7 +6755,7 @@ PHP_MINIT_FUNCTION(reflection) /* {{{ */ INIT_CLASS_ENTRY(_reflection_entry, "ReflectionType", reflection_type_functions); _reflection_entry.create_object = reflection_objects_new; reflection_type_ptr = zend_register_internal_class(&_reflection_entry); - + INIT_CLASS_ENTRY(_reflection_entry, "ReflectionNamedType", reflection_named_type_functions); _reflection_entry.create_object = reflection_objects_new; reflection_named_type_ptr = zend_register_internal_class_ex(&_reflection_entry, reflection_type_ptr); |