From 80c1e3f2afda36cc9e95f995fc418eb26e9307e3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?M=C3=A1t=C3=A9=20Kocsis?= Date: Sun, 12 Apr 2020 19:53:32 +0200 Subject: [PATCH] Generate method entries for ext/session and ext/reflection --- ext/reflection/php_reflection.c | 679 +++++++----------------- ext/reflection/php_reflection.stub.php | 17 +- ext/reflection/php_reflection_arginfo.h | 475 ++++++++++++++++- ext/session/session.c | 84 +-- ext/session/session.stub.php | 26 + ext/session/session_arginfo.h | 109 ++++ 6 files changed, 833 insertions(+), 557 deletions(-) diff --git a/ext/reflection/php_reflection.c b/ext/reflection/php_reflection.c index 058d2d59d22b3..6023ef0c0d8ce 100644 --- a/ext/reflection/php_reflection.c +++ b/ext/reflection/php_reflection.c @@ -1308,7 +1308,7 @@ static int get_parameter_default(zval *result, parameter_reference *param) { } /* {{{ Preventing __clone from being called */ -ZEND_METHOD(reflection, __clone) +ZEND_METHOD(ReflectionClass, __clone) { /* Should never be executable */ _DO_THROW("Cannot clone object using __clone()"); @@ -1317,7 +1317,7 @@ ZEND_METHOD(reflection, __clone) /* {{{ proto public static array Reflection::getModifierNames(int modifiers) Returns an array of modifier names */ -ZEND_METHOD(reflection, getModifierNames) +ZEND_METHOD(Reflection, getModifierNames) { zend_long modifiers; @@ -1355,7 +1355,7 @@ ZEND_METHOD(reflection, getModifierNames) /* {{{ proto public void ReflectionFunction::__construct(string name) Constructor. Throws an Exception in case the given function does not exist */ -ZEND_METHOD(reflection_function, __construct) +ZEND_METHOD(ReflectionFunction, __construct) { zval *object; zval *closure = NULL; @@ -1409,7 +1409,7 @@ ZEND_METHOD(reflection_function, __construct) /* {{{ proto public string ReflectionFunction::__toString() Returns a string representation */ -ZEND_METHOD(reflection_function, __toString) +ZEND_METHOD(ReflectionFunction, __toString) { reflection_object *intern; zend_function *fptr; @@ -1426,7 +1426,7 @@ ZEND_METHOD(reflection_function, __toString) /* {{{ proto public string ReflectionFunction::getName() Returns this function's name */ -ZEND_METHOD(reflection_function, getName) +ZEND_METHOD(ReflectionFunctionAbstract, getName) { reflection_object *intern; zend_function *fptr; @@ -1442,7 +1442,7 @@ ZEND_METHOD(reflection_function, getName) /* {{{ proto public bool ReflectionFunction::isClosure() Returns whether this is a closure */ -ZEND_METHOD(reflection_function, isClosure) +ZEND_METHOD(ReflectionFunctionAbstract, isClosure) { reflection_object *intern; zend_function *fptr; @@ -1457,7 +1457,7 @@ ZEND_METHOD(reflection_function, isClosure) /* {{{ proto public bool ReflectionFunction::getClosureThis() Returns this pointer bound to closure */ -ZEND_METHOD(reflection_function, getClosureThis) +ZEND_METHOD(ReflectionFunctionAbstract, getClosureThis) { reflection_object *intern; zval* closure_this; @@ -1478,7 +1478,7 @@ ZEND_METHOD(reflection_function, getClosureThis) /* {{{ proto public ReflectionClass ReflectionFunction::getClosureScopeClass() Returns the scope associated to the closure */ -ZEND_METHOD(reflection_function, getClosureScopeClass) +ZEND_METHOD(ReflectionFunctionAbstract, getClosureScopeClass) { reflection_object *intern; const zend_function *closure_func; @@ -1498,7 +1498,7 @@ ZEND_METHOD(reflection_function, getClosureScopeClass) /* {{{ proto public mixed ReflectionFunction::getClosure() Returns a dynamically created closure for the function */ -ZEND_METHOD(reflection_function, getClosure) +ZEND_METHOD(ReflectionFunction, getClosure) { reflection_object *intern; zend_function *fptr; @@ -1520,7 +1520,7 @@ ZEND_METHOD(reflection_function, getClosure) /* {{{ proto public bool ReflectionFunction::isInternal() Returns whether this is an internal function */ -ZEND_METHOD(reflection_function, isInternal) +ZEND_METHOD(ReflectionFunctionAbstract, isInternal) { reflection_object *intern; zend_function *fptr; @@ -1535,7 +1535,7 @@ ZEND_METHOD(reflection_function, isInternal) /* {{{ proto public bool ReflectionFunction::isUserDefined() Returns whether this is a user-defined function */ -ZEND_METHOD(reflection_function, isUserDefined) +ZEND_METHOD(ReflectionFunctionAbstract, isUserDefined) { reflection_object *intern; zend_function *fptr; @@ -1550,7 +1550,7 @@ ZEND_METHOD(reflection_function, isUserDefined) /* {{{ proto public bool ReflectionFunction::isDisabled() Returns whether this function has been disabled or not */ -ZEND_METHOD(reflection_function, isDisabled) +ZEND_METHOD(ReflectionFunction, isDisabled) { reflection_object *intern; zend_function *fptr; @@ -1567,7 +1567,7 @@ ZEND_METHOD(reflection_function, isDisabled) /* {{{ proto public string ReflectionFunction::getFileName() Returns the filename of the file this function was declared in */ -ZEND_METHOD(reflection_function, getFileName) +ZEND_METHOD(ReflectionFunctionAbstract, getFileName) { reflection_object *intern; zend_function *fptr; @@ -1585,7 +1585,7 @@ ZEND_METHOD(reflection_function, getFileName) /* {{{ proto public int ReflectionFunction::getStartLine() Returns the line this function's declaration starts at */ -ZEND_METHOD(reflection_function, getStartLine) +ZEND_METHOD(ReflectionFunctionAbstract, getStartLine) { reflection_object *intern; zend_function *fptr; @@ -1603,7 +1603,7 @@ ZEND_METHOD(reflection_function, getStartLine) /* {{{ proto public int ReflectionFunction::getEndLine() Returns the line this function's declaration ends at */ -ZEND_METHOD(reflection_function, getEndLine) +ZEND_METHOD(ReflectionFunctionAbstract, getEndLine) { reflection_object *intern; zend_function *fptr; @@ -1621,7 +1621,7 @@ ZEND_METHOD(reflection_function, getEndLine) /* {{{ proto public string ReflectionFunction::getDocComment() Returns the doc comment for this function */ -ZEND_METHOD(reflection_function, getDocComment) +ZEND_METHOD(ReflectionFunctionAbstract, getDocComment) { reflection_object *intern; zend_function *fptr; @@ -1639,7 +1639,7 @@ ZEND_METHOD(reflection_function, getDocComment) /* {{{ proto public array ReflectionFunction::getStaticVariables() Returns an associative array containing this function's static variables and their values */ -ZEND_METHOD(reflection_function, getStaticVariables) +ZEND_METHOD(ReflectionFunctionAbstract, getStaticVariables) { reflection_object *intern; zend_function *fptr; @@ -1675,7 +1675,7 @@ ZEND_METHOD(reflection_function, getStaticVariables) /* {{{ proto public mixed ReflectionFunction::invoke([mixed* args]) Invokes the function */ -ZEND_METHOD(reflection_function, invoke) +ZEND_METHOD(ReflectionFunction, invoke) { zval retval; zval *params = NULL; @@ -1727,7 +1727,7 @@ ZEND_METHOD(reflection_function, invoke) /* {{{ proto public mixed ReflectionFunction::invokeArgs(array args) Invokes the function and pass its arguments as array. */ -ZEND_METHOD(reflection_function, invokeArgs) +ZEND_METHOD(ReflectionFunction, invokeArgs) { zval retval; zval *params, *val; @@ -1795,7 +1795,7 @@ ZEND_METHOD(reflection_function, invokeArgs) /* {{{ proto public bool ReflectionFunction::returnsReference() Gets whether this function returns a reference */ -ZEND_METHOD(reflection_function, returnsReference) +ZEND_METHOD(ReflectionFunctionAbstract, returnsReference) { reflection_object *intern; zend_function *fptr; @@ -1812,7 +1812,7 @@ ZEND_METHOD(reflection_function, returnsReference) /* {{{ proto public bool ReflectionFunction::getNumberOfParameters() Gets the number of parameters */ -ZEND_METHOD(reflection_function, getNumberOfParameters) +ZEND_METHOD(ReflectionFunctionAbstract, getNumberOfParameters) { reflection_object *intern; zend_function *fptr; @@ -1835,7 +1835,7 @@ ZEND_METHOD(reflection_function, getNumberOfParameters) /* {{{ proto public bool ReflectionFunction::getNumberOfRequiredParameters() Gets the number of required parameters */ -ZEND_METHOD(reflection_function, getNumberOfRequiredParameters) +ZEND_METHOD(ReflectionFunctionAbstract, getNumberOfRequiredParameters) { reflection_object *intern; zend_function *fptr; @@ -1852,7 +1852,7 @@ ZEND_METHOD(reflection_function, getNumberOfRequiredParameters) /* {{{ proto public ReflectionParameter[] ReflectionFunction::getParameters() Returns an array of parameter objects for this function */ -ZEND_METHOD(reflection_function, getParameters) +ZEND_METHOD(ReflectionFunctionAbstract, getParameters) { reflection_object *intern; zend_function *fptr; @@ -1896,7 +1896,7 @@ ZEND_METHOD(reflection_function, getParameters) /* {{{ proto public ReflectionExtension|NULL ReflectionFunction::getExtension() Returns NULL or the extension the function belongs to */ -ZEND_METHOD(reflection_function, getExtension) +ZEND_METHOD(ReflectionFunctionAbstract, getExtension) { reflection_object *intern; zend_function *fptr; @@ -1923,7 +1923,7 @@ ZEND_METHOD(reflection_function, getExtension) /* {{{ proto public string|false ReflectionFunction::getExtensionName() Returns false or the name of the extension the function belongs to */ -ZEND_METHOD(reflection_function, getExtensionName) +ZEND_METHOD(ReflectionFunctionAbstract, getExtensionName) { reflection_object *intern; zend_function *fptr; @@ -1949,7 +1949,7 @@ ZEND_METHOD(reflection_function, getExtensionName) /* }}} */ /* {{{ proto public void ReflectionGenerator::__construct(object Generator) */ -ZEND_METHOD(reflection_generator, __construct) +ZEND_METHOD(ReflectionGenerator, __construct) { zval *generator, *object; reflection_object *intern; @@ -1982,7 +1982,7 @@ ZEND_METHOD(reflection_generator, __construct) } /* {{{ proto public array ReflectionGenerator::getTrace($options = DEBUG_BACKTRACE_PROVIDE_OBJECT) */ -ZEND_METHOD(reflection_generator, getTrace) +ZEND_METHOD(ReflectionGenerator, getTrace) { zend_long options = DEBUG_BACKTRACE_PROVIDE_OBJECT; zend_generator *generator = (zend_generator *) Z_OBJ(Z_REFLECTION_P(ZEND_THIS)->obj); @@ -2018,7 +2018,7 @@ ZEND_METHOD(reflection_generator, getTrace) /* }}} */ /* {{{ proto public int ReflectionGenerator::getExecutingLine() */ -ZEND_METHOD(reflection_generator, getExecutingLine) +ZEND_METHOD(ReflectionGenerator, getExecutingLine) { zend_generator *generator = (zend_generator *) Z_OBJ(Z_REFLECTION_P(ZEND_THIS)->obj); zend_execute_data *ex = generator->execute_data; @@ -2034,7 +2034,7 @@ ZEND_METHOD(reflection_generator, getExecutingLine) /* }}} */ /* {{{ proto public string ReflectionGenerator::getExecutingFile() */ -ZEND_METHOD(reflection_generator, getExecutingFile) +ZEND_METHOD(ReflectionGenerator, getExecutingFile) { zend_generator *generator = (zend_generator *) Z_OBJ(Z_REFLECTION_P(ZEND_THIS)->obj); zend_execute_data *ex = generator->execute_data; @@ -2050,7 +2050,7 @@ ZEND_METHOD(reflection_generator, getExecutingFile) /* }}} */ /* {{{ proto public ReflectionFunctionAbstract ReflectionGenerator::getFunction() */ -ZEND_METHOD(reflection_generator, getFunction) +ZEND_METHOD(ReflectionGenerator, getFunction) { zend_generator *generator = (zend_generator *) Z_OBJ(Z_REFLECTION_P(ZEND_THIS)->obj); zend_execute_data *ex = generator->execute_data; @@ -2074,7 +2074,7 @@ ZEND_METHOD(reflection_generator, getFunction) /* }}} */ /* {{{ proto public object ReflectionGenerator::getThis() */ -ZEND_METHOD(reflection_generator, getThis) +ZEND_METHOD(ReflectionGenerator, getThis) { zend_generator *generator = (zend_generator *) Z_OBJ(Z_REFLECTION_P(ZEND_THIS)->obj); zend_execute_data *ex = generator->execute_data; @@ -2095,7 +2095,7 @@ ZEND_METHOD(reflection_generator, getThis) /* }}} */ /* {{{ proto public Generator ReflectionGenerator::getExecutingGenerator() */ -ZEND_METHOD(reflection_generator, getExecutingGenerator) +ZEND_METHOD(ReflectionGenerator, getExecutingGenerator) { zend_generator *generator = (zend_generator *) Z_OBJ(Z_REFLECTION_P(ZEND_THIS)->obj); zend_execute_data *ex = generator->execute_data; @@ -2116,7 +2116,7 @@ ZEND_METHOD(reflection_generator, getExecutingGenerator) /* {{{ 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) +ZEND_METHOD(ReflectionParameter, __construct) { parameter_reference *ref; zval *reference, *parameter; @@ -2304,7 +2304,7 @@ ZEND_METHOD(reflection_parameter, __construct) /* {{{ proto public string ReflectionParameter::__toString() Returns a string representation */ -ZEND_METHOD(reflection_parameter, __toString) +ZEND_METHOD(ReflectionParameter, __toString) { reflection_object *intern; parameter_reference *param; @@ -2322,7 +2322,7 @@ ZEND_METHOD(reflection_parameter, __toString) /* {{{ proto public string ReflectionParameter::getName() Returns this parameters's name */ -ZEND_METHOD(reflection_parameter, getName) +ZEND_METHOD(ReflectionParameter, getName) { reflection_object *intern; parameter_reference *param; @@ -2342,7 +2342,7 @@ ZEND_METHOD(reflection_parameter, getName) /* {{{ proto public ReflectionFunction ReflectionParameter::getDeclaringFunction() Returns the ReflectionFunction for the function of this parameter */ -ZEND_METHOD(reflection_parameter, getDeclaringFunction) +ZEND_METHOD(ReflectionParameter, getDeclaringFunction) { reflection_object *intern; parameter_reference *param; @@ -2362,7 +2362,7 @@ ZEND_METHOD(reflection_parameter, getDeclaringFunction) /* {{{ proto public ReflectionClass|NULL ReflectionParameter::getDeclaringClass() Returns in which class this parameter is defined (not the type of the parameter) */ -ZEND_METHOD(reflection_parameter, getDeclaringClass) +ZEND_METHOD(ReflectionParameter, getDeclaringClass) { reflection_object *intern; parameter_reference *param; @@ -2380,7 +2380,7 @@ ZEND_METHOD(reflection_parameter, getDeclaringClass) /* {{{ proto public ReflectionClass|NULL ReflectionParameter::getClass() Returns this parameters's class hint or NULL if there is none */ -ZEND_METHOD(reflection_parameter, getClass) +ZEND_METHOD(ReflectionParameter, getClass) { reflection_object *intern; parameter_reference *param; @@ -2443,7 +2443,7 @@ ZEND_METHOD(reflection_parameter, getClass) /* {{{ proto public bool ReflectionParameter::hasType() Returns whether parameter has a type */ -ZEND_METHOD(reflection_parameter, hasType) +ZEND_METHOD(ReflectionParameter, hasType) { reflection_object *intern; parameter_reference *param; @@ -2459,7 +2459,7 @@ ZEND_METHOD(reflection_parameter, hasType) /* {{{ proto public ReflectionType ReflectionParameter::getType() Returns the type associated with the parameter */ -ZEND_METHOD(reflection_parameter, getType) +ZEND_METHOD(ReflectionParameter, getType) { reflection_object *intern; parameter_reference *param; @@ -2478,7 +2478,7 @@ ZEND_METHOD(reflection_parameter, getType) /* {{{ proto public bool ReflectionParameter::isArray() Returns whether parameter MUST be an array */ -ZEND_METHOD(reflection_parameter, isArray) +ZEND_METHOD(ReflectionParameter, isArray) { reflection_object *intern; parameter_reference *param; @@ -2496,7 +2496,7 @@ ZEND_METHOD(reflection_parameter, isArray) /* {{{ proto public bool ReflectionParameter::isCallable() Returns whether parameter MUST be callable */ -ZEND_METHOD(reflection_parameter, isCallable) +ZEND_METHOD(ReflectionParameter, isCallable) { reflection_object *intern; parameter_reference *param; @@ -2514,7 +2514,7 @@ ZEND_METHOD(reflection_parameter, isCallable) /* {{{ proto public bool ReflectionParameter::allowsNull() Returns whether NULL is allowed as this parameters's value */ -ZEND_METHOD(reflection_parameter, allowsNull) +ZEND_METHOD(ReflectionParameter, allowsNull) { reflection_object *intern; parameter_reference *param; @@ -2531,7 +2531,7 @@ ZEND_METHOD(reflection_parameter, allowsNull) /* {{{ proto public bool ReflectionParameter::isPassedByReference() Returns whether this parameters is passed to by reference */ -ZEND_METHOD(reflection_parameter, isPassedByReference) +ZEND_METHOD(ReflectionParameter, isPassedByReference) { reflection_object *intern; parameter_reference *param; @@ -2547,7 +2547,7 @@ ZEND_METHOD(reflection_parameter, isPassedByReference) /* {{{ proto public bool ReflectionParameter::canBePassedByValue() Returns whether this parameter can be passed by value */ -ZEND_METHOD(reflection_parameter, canBePassedByValue) +ZEND_METHOD(ReflectionParameter, canBePassedByValue) { reflection_object *intern; parameter_reference *param; @@ -2564,7 +2564,7 @@ ZEND_METHOD(reflection_parameter, canBePassedByValue) /* {{{ proto public bool ReflectionParameter::getPosition() Returns whether this parameter is an optional parameter */ -ZEND_METHOD(reflection_parameter, getPosition) +ZEND_METHOD(ReflectionParameter, getPosition) { reflection_object *intern; parameter_reference *param; @@ -2580,7 +2580,7 @@ ZEND_METHOD(reflection_parameter, getPosition) /* {{{ proto public bool ReflectionParameter::isOptional() Returns whether this parameter is an optional parameter */ -ZEND_METHOD(reflection_parameter, isOptional) +ZEND_METHOD(ReflectionParameter, isOptional) { reflection_object *intern; parameter_reference *param; @@ -2596,7 +2596,7 @@ ZEND_METHOD(reflection_parameter, isOptional) /* {{{ proto public bool ReflectionParameter::isDefaultValueAvailable() Returns whether the default value of this parameter is available */ -ZEND_METHOD(reflection_parameter, isDefaultValueAvailable) +ZEND_METHOD(ReflectionParameter, isDefaultValueAvailable) { reflection_object *intern; parameter_reference *param; @@ -2618,7 +2618,7 @@ ZEND_METHOD(reflection_parameter, isDefaultValueAvailable) /* {{{ proto public bool ReflectionParameter::getDefaultValue() Returns the default value of this parameter or throws an exception */ -ZEND_METHOD(reflection_parameter, getDefaultValue) +ZEND_METHOD(ReflectionParameter, getDefaultValue) { reflection_object *intern; parameter_reference *param; @@ -2643,7 +2643,7 @@ ZEND_METHOD(reflection_parameter, getDefaultValue) /* {{{ proto public bool ReflectionParameter::isDefaultValueConstant() Returns whether the default value of this parameter is constant */ -ZEND_METHOD(reflection_parameter, isDefaultValueConstant) +ZEND_METHOD(ReflectionParameter, isDefaultValueConstant) { reflection_object *intern; parameter_reference *param; @@ -2673,7 +2673,7 @@ ZEND_METHOD(reflection_parameter, isDefaultValueConstant) /* {{{ proto public mixed ReflectionParameter::getDefaultValueConstantName() Returns the default value's constant name if default value is constant or null */ -ZEND_METHOD(reflection_parameter, getDefaultValueConstantName) +ZEND_METHOD(ReflectionParameter, getDefaultValueConstantName) { reflection_object *intern; parameter_reference *param; @@ -2709,7 +2709,7 @@ ZEND_METHOD(reflection_parameter, getDefaultValueConstantName) /* {{{ proto public bool ReflectionParameter::isVariadic() Returns whether this parameter is a variadic parameter */ -ZEND_METHOD(reflection_parameter, isVariadic) +ZEND_METHOD(ReflectionParameter, isVariadic) { reflection_object *intern; parameter_reference *param; @@ -2725,7 +2725,7 @@ ZEND_METHOD(reflection_parameter, isVariadic) /* {{{ proto public bool ReflectionType::allowsNull() Returns whether parameter MAY be null */ -ZEND_METHOD(reflection_type, allowsNull) +ZEND_METHOD(ReflectionType, allowsNull) { reflection_object *intern; type_reference *param; @@ -2746,7 +2746,7 @@ static zend_string *zend_type_to_string_without_null(zend_type type) { /* {{{ proto public string ReflectionType::__toString() Return the text of the type hint */ -ZEND_METHOD(reflection_type, __toString) +ZEND_METHOD(ReflectionType, __toString) { reflection_object *intern; type_reference *param; @@ -2762,7 +2762,7 @@ ZEND_METHOD(reflection_type, __toString) /* {{{ proto public string ReflectionNamedType::getName() Return the name of the type */ -ZEND_METHOD(reflection_named_type, getName) +ZEND_METHOD(ReflectionNamedType, getName) { reflection_object *intern; type_reference *param; @@ -2781,7 +2781,7 @@ ZEND_METHOD(reflection_named_type, getName) /* {{{ proto public bool ReflectionNamedType::isBuiltin() Returns whether type is a builtin type */ -ZEND_METHOD(reflection_named_type, isBuiltin) +ZEND_METHOD(ReflectionNamedType, isBuiltin) { reflection_object *intern; type_reference *param; @@ -2809,7 +2809,7 @@ static void append_type_mask(zval *return_value, uint32_t type_mask) { /* {{{ proto public string ReflectionUnionType::getTypes() Returns the types that are part of this union type */ -ZEND_METHOD(reflection_union_type, getTypes) +ZEND_METHOD(ReflectionUnionType, getTypes) { reflection_object *intern; type_reference *param; @@ -2870,7 +2870,7 @@ ZEND_METHOD(reflection_union_type, getTypes) /* {{{ proto public void ReflectionMethod::__construct(mixed class_or_method [, string name]) Constructor. Throws an Exception in case the given method does not exist */ -ZEND_METHOD(reflection_method, __construct) +ZEND_METHOD(ReflectionMethod, __construct) { zval *classname; zval *object, *orig_obj; @@ -2962,7 +2962,7 @@ ZEND_METHOD(reflection_method, __construct) /* {{{ proto public string ReflectionMethod::__toString() Returns a string representation */ -ZEND_METHOD(reflection_method, __toString) +ZEND_METHOD(ReflectionMethod, __toString) { reflection_object *intern; zend_function *mptr; @@ -2979,7 +2979,7 @@ ZEND_METHOD(reflection_method, __toString) /* {{{ proto public mixed ReflectionMethod::getClosure([mixed object]) Invokes the function */ -ZEND_METHOD(reflection_method, getClosure) +ZEND_METHOD(ReflectionMethod, getClosure) { reflection_object *intern; zval *obj; @@ -3135,7 +3135,7 @@ static void reflection_method_invoke(INTERNAL_FUNCTION_PARAMETERS, int variadic) /* {{{ proto public mixed ReflectionMethod::invoke(mixed object, [mixed* args]) Invokes the method. */ -ZEND_METHOD(reflection_method, invoke) +ZEND_METHOD(ReflectionMethod, invoke) { reflection_method_invoke(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1); } @@ -3143,7 +3143,7 @@ ZEND_METHOD(reflection_method, invoke) /* {{{ proto public mixed ReflectionMethod::invokeArgs(mixed object, array args) Invokes the function and pass its arguments as array. */ -ZEND_METHOD(reflection_method, invokeArgs) +ZEND_METHOD(ReflectionMethod, invokeArgs) { reflection_method_invoke(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0); } @@ -3151,7 +3151,7 @@ ZEND_METHOD(reflection_method, invokeArgs) /* {{{ proto public bool ReflectionMethod::isFinal() Returns whether this method is final */ -ZEND_METHOD(reflection_method, isFinal) +ZEND_METHOD(ReflectionMethod, isFinal) { _function_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_FINAL); } @@ -3159,7 +3159,7 @@ ZEND_METHOD(reflection_method, isFinal) /* {{{ proto public bool ReflectionMethod::isAbstract() Returns whether this method is abstract */ -ZEND_METHOD(reflection_method, isAbstract) +ZEND_METHOD(ReflectionMethod, isAbstract) { _function_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_ABSTRACT); } @@ -3167,7 +3167,7 @@ ZEND_METHOD(reflection_method, isAbstract) /* {{{ proto public bool ReflectionMethod::isPublic() Returns whether this method is public */ -ZEND_METHOD(reflection_method, isPublic) +ZEND_METHOD(ReflectionMethod, isPublic) { _function_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_PUBLIC); } @@ -3175,7 +3175,7 @@ ZEND_METHOD(reflection_method, isPublic) /* {{{ proto public bool ReflectionMethod::isPrivate() Returns whether this method is private */ -ZEND_METHOD(reflection_method, isPrivate) +ZEND_METHOD(ReflectionMethod, isPrivate) { _function_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_PRIVATE); } @@ -3183,7 +3183,7 @@ ZEND_METHOD(reflection_method, isPrivate) /* {{{ proto public bool ReflectionMethod::isProtected() Returns whether this method is protected */ -ZEND_METHOD(reflection_method, isProtected) +ZEND_METHOD(ReflectionMethod, isProtected) { _function_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_PROTECTED); } @@ -3191,7 +3191,7 @@ ZEND_METHOD(reflection_method, isProtected) /* {{{ proto public bool ReflectionMethod::isStatic() Returns whether this method is static */ -ZEND_METHOD(reflection_method, isStatic) +ZEND_METHOD(ReflectionMethod, isStatic) { _function_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_STATIC); } @@ -3199,7 +3199,7 @@ ZEND_METHOD(reflection_method, isStatic) /* {{{ proto public bool ReflectionFunction::isDeprecated() Returns whether this function is deprecated */ -ZEND_METHOD(reflection_function, isDeprecated) +ZEND_METHOD(ReflectionFunctionAbstract, isDeprecated) { _function_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_DEPRECATED); } @@ -3207,7 +3207,7 @@ ZEND_METHOD(reflection_function, isDeprecated) /* {{{ proto public bool ReflectionFunction::isGenerator() Returns whether this function is a generator */ -ZEND_METHOD(reflection_function, isGenerator) +ZEND_METHOD(ReflectionFunctionAbstract, isGenerator) { _function_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_GENERATOR); } @@ -3215,7 +3215,7 @@ ZEND_METHOD(reflection_function, isGenerator) /* {{{ proto public bool ReflectionFunction::isVariadic() Returns whether this function is variadic */ -ZEND_METHOD(reflection_function, isVariadic) +ZEND_METHOD(ReflectionFunctionAbstract, isVariadic) { _function_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_VARIADIC); } @@ -3223,7 +3223,7 @@ ZEND_METHOD(reflection_function, isVariadic) /* {{{ proto public bool ReflectionFunction::inNamespace() Returns whether this function is defined in namespace */ -ZEND_METHOD(reflection_function, inNamespace) +ZEND_METHOD(ReflectionFunctionAbstract, inNamespace) { reflection_object *intern; zend_function *fptr; @@ -3242,7 +3242,7 @@ ZEND_METHOD(reflection_function, inNamespace) /* {{{ proto public string ReflectionFunction::getNamespaceName() Returns the name of namespace where this function is defined */ -ZEND_METHOD(reflection_function, getNamespaceName) +ZEND_METHOD(ReflectionFunctionAbstract, getNamespaceName) { reflection_object *intern; zend_function *fptr; @@ -3264,7 +3264,7 @@ ZEND_METHOD(reflection_function, getNamespaceName) /* {{{ proto public string ReflectionFunction::getShortName() Returns the short name of the function (without namespace part) */ -ZEND_METHOD(reflection_function, getShortName) +ZEND_METHOD(ReflectionFunctionAbstract, getShortName) { reflection_object *intern; zend_function *fptr; @@ -3286,7 +3286,7 @@ ZEND_METHOD(reflection_function, getShortName) /* {{{ proto public bool ReflectionFunctionAbstract:hasReturnType() Return whether the function has a return type */ -ZEND_METHOD(reflection_function, hasReturnType) +ZEND_METHOD(ReflectionFunctionAbstract, hasReturnType) { reflection_object *intern; zend_function *fptr; @@ -3303,7 +3303,7 @@ ZEND_METHOD(reflection_function, hasReturnType) /* {{{ proto public string ReflectionFunctionAbstract::getReturnType() Returns the return type associated with the function */ -ZEND_METHOD(reflection_function, getReturnType) +ZEND_METHOD(ReflectionFunctionAbstract, getReturnType) { reflection_object *intern; zend_function *fptr; @@ -3324,7 +3324,7 @@ ZEND_METHOD(reflection_function, getReturnType) /* {{{ proto public bool ReflectionMethod::isConstructor() Returns whether this method is the constructor */ -ZEND_METHOD(reflection_method, isConstructor) +ZEND_METHOD(ReflectionMethod, isConstructor) { reflection_object *intern; zend_function *mptr; @@ -3342,7 +3342,7 @@ ZEND_METHOD(reflection_method, isConstructor) /* {{{ proto public bool ReflectionMethod::isDestructor() Returns whether this method is static */ -ZEND_METHOD(reflection_method, isDestructor) +ZEND_METHOD(ReflectionMethod, isDestructor) { reflection_object *intern; zend_function *mptr; @@ -3357,7 +3357,7 @@ ZEND_METHOD(reflection_method, isDestructor) /* {{{ proto public int ReflectionMethod::getModifiers() Returns a bitfield of the access modifiers for this method */ -ZEND_METHOD(reflection_method, getModifiers) +ZEND_METHOD(ReflectionMethod, getModifiers) { reflection_object *intern; zend_function *mptr; @@ -3375,7 +3375,7 @@ ZEND_METHOD(reflection_method, getModifiers) /* {{{ proto public ReflectionClass ReflectionMethod::getDeclaringClass() Get the declaring class */ -ZEND_METHOD(reflection_method, getDeclaringClass) +ZEND_METHOD(ReflectionMethod, getDeclaringClass) { reflection_object *intern; zend_function *mptr; @@ -3392,7 +3392,7 @@ ZEND_METHOD(reflection_method, getDeclaringClass) /* {{{ proto public ReflectionClass ReflectionMethod::getPrototype() Get the prototype */ -ZEND_METHOD(reflection_method, getPrototype) +ZEND_METHOD(ReflectionMethod, getPrototype) { reflection_object *intern; zend_function *mptr; @@ -3415,7 +3415,7 @@ ZEND_METHOD(reflection_method, getPrototype) /* {{{ proto public void ReflectionMethod::setAccessible(bool visible) Sets whether non-public methods can be invoked */ -ZEND_METHOD(reflection_method, setAccessible) +ZEND_METHOD(ReflectionMethod, setAccessible) { reflection_object *intern; zend_bool visible; @@ -3432,7 +3432,7 @@ ZEND_METHOD(reflection_method, setAccessible) /* {{{ proto public void ReflectionClassConstant::__construct(mixed class, string name) Constructor. Throws an Exception in case the given class constant does not exist */ -ZEND_METHOD(reflection_class_constant, __construct) +ZEND_METHOD(ReflectionClassConstant, __construct) { zval *classname, *object; zend_string *constname; @@ -3482,7 +3482,7 @@ ZEND_METHOD(reflection_class_constant, __construct) /* {{{ proto public string ReflectionClassConstant::__toString() Returns a string representation */ -ZEND_METHOD(reflection_class_constant, __toString) +ZEND_METHOD(ReflectionClassConstant, __toString) { reflection_object *intern; zend_class_constant *ref; @@ -3502,7 +3502,7 @@ ZEND_METHOD(reflection_class_constant, __toString) /* {{{ proto public string ReflectionClassConstant::getName() Returns the constant' name */ -ZEND_METHOD(reflection_class_constant, getName) +ZEND_METHOD(ReflectionClassConstant, getName) { if (zend_parse_parameters_none() == FAILURE) { RETURN_THROWS(); @@ -3526,7 +3526,7 @@ static void _class_constant_check_flag(INTERNAL_FUNCTION_PARAMETERS, int mask) / /* {{{ proto public bool ReflectionClassConstant::isPublic() Returns whether this constant is public */ -ZEND_METHOD(reflection_class_constant, isPublic) +ZEND_METHOD(ReflectionClassConstant, isPublic) { _class_constant_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_PUBLIC); } @@ -3534,7 +3534,7 @@ ZEND_METHOD(reflection_class_constant, isPublic) /* {{{ proto public bool ReflectionClassConstant::isPrivate() Returns whether this constant is private */ -ZEND_METHOD(reflection_class_constant, isPrivate) +ZEND_METHOD(ReflectionClassConstant, isPrivate) { _class_constant_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_PRIVATE); } @@ -3542,7 +3542,7 @@ ZEND_METHOD(reflection_class_constant, isPrivate) /* {{{ proto public bool ReflectionClassConstant::isProtected() Returns whether this constant is protected */ -ZEND_METHOD(reflection_class_constant, isProtected) +ZEND_METHOD(ReflectionClassConstant, isProtected) { _class_constant_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_PROTECTED); } @@ -3550,7 +3550,7 @@ ZEND_METHOD(reflection_class_constant, isProtected) /* {{{ proto public int ReflectionClassConstant::getModifiers() Returns a bitfield of the access modifiers for this constant */ -ZEND_METHOD(reflection_class_constant, getModifiers) +ZEND_METHOD(ReflectionClassConstant, getModifiers) { reflection_object *intern; zend_class_constant *ref; @@ -3566,7 +3566,7 @@ ZEND_METHOD(reflection_class_constant, getModifiers) /* {{{ proto public mixed ReflectionClassConstant::getValue() Returns this constant's value */ -ZEND_METHOD(reflection_class_constant, getValue) +ZEND_METHOD(ReflectionClassConstant, getValue) { reflection_object *intern; zend_class_constant *ref; @@ -3585,7 +3585,7 @@ ZEND_METHOD(reflection_class_constant, getValue) /* {{{ proto public ReflectionClass ReflectionClassConstant::getDeclaringClass() Get the declaring class */ -ZEND_METHOD(reflection_class_constant, getDeclaringClass) +ZEND_METHOD(ReflectionClassConstant, getDeclaringClass) { reflection_object *intern; zend_class_constant *ref; @@ -3601,7 +3601,7 @@ ZEND_METHOD(reflection_class_constant, getDeclaringClass) /* {{{ proto public string ReflectionClassConstant::getDocComment() Returns the doc comment for this constant */ -ZEND_METHOD(reflection_class_constant, getDocComment) +ZEND_METHOD(ReflectionClassConstant, getDocComment) { reflection_object *intern; zend_class_constant *ref; @@ -3665,7 +3665,7 @@ static void reflection_class_object_ctor(INTERNAL_FUNCTION_PARAMETERS, int is_ob /* {{{ proto public void ReflectionClass::__construct(mixed argument) throws ReflectionException Constructor. Takes a string or an instance as an argument */ -ZEND_METHOD(reflection_class, __construct) +ZEND_METHOD(ReflectionClass, __construct) { reflection_class_object_ctor(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0); } @@ -3715,7 +3715,7 @@ static void add_class_vars(zend_class_entry *ce, zend_bool statics, zval *return /* {{{ proto public array ReflectionClass::getStaticProperties() Returns an associative array containing all static property values of the class */ -ZEND_METHOD(reflection_class, getStaticProperties) +ZEND_METHOD(ReflectionClass, getStaticProperties) { reflection_object *intern; zend_class_entry *ce; @@ -3737,7 +3737,7 @@ ZEND_METHOD(reflection_class, getStaticProperties) /* {{{ proto public mixed ReflectionClass::getStaticPropertyValue(string name [, mixed default]) Returns the value of a static property */ -ZEND_METHOD(reflection_class, getStaticPropertyValue) +ZEND_METHOD(ReflectionClass, getStaticPropertyValue) { reflection_object *intern; zend_class_entry *ce; @@ -3770,7 +3770,7 @@ ZEND_METHOD(reflection_class, getStaticPropertyValue) /* {{{ proto public void ReflectionClass::setStaticPropertyValue(string $name, mixed $value) Sets the value of a static property */ -ZEND_METHOD(reflection_class, setStaticPropertyValue) +ZEND_METHOD(ReflectionClass, setStaticPropertyValue) { reflection_object *intern; zend_class_entry *ce; @@ -3816,7 +3816,7 @@ ZEND_METHOD(reflection_class, setStaticPropertyValue) /* {{{ proto public array ReflectionClass::getDefaultProperties() Returns an associative array containing copies of all default property values of the class */ -ZEND_METHOD(reflection_class, getDefaultProperties) +ZEND_METHOD(ReflectionClass, getDefaultProperties) { reflection_object *intern; zend_class_entry *ce; @@ -3836,7 +3836,7 @@ ZEND_METHOD(reflection_class, getDefaultProperties) /* {{{ proto public string ReflectionClass::__toString() Returns a string representation */ -ZEND_METHOD(reflection_class, __toString) +ZEND_METHOD(ReflectionClass, __toString) { reflection_object *intern; zend_class_entry *ce; @@ -3853,7 +3853,7 @@ ZEND_METHOD(reflection_class, __toString) /* {{{ proto public string ReflectionClass::getName() Returns the class' name */ -ZEND_METHOD(reflection_class, getName) +ZEND_METHOD(ReflectionClass, getName) { reflection_object *intern; zend_class_entry *ce; @@ -3869,7 +3869,7 @@ ZEND_METHOD(reflection_class, getName) /* {{{ proto public bool ReflectionClass::isInternal() Returns whether this class is an internal class */ -ZEND_METHOD(reflection_class, isInternal) +ZEND_METHOD(ReflectionClass, isInternal) { reflection_object *intern; zend_class_entry *ce; @@ -3884,7 +3884,7 @@ ZEND_METHOD(reflection_class, isInternal) /* {{{ proto public bool ReflectionClass::isUserDefined() Returns whether this class is user-defined */ -ZEND_METHOD(reflection_class, isUserDefined) +ZEND_METHOD(ReflectionClass, isUserDefined) { reflection_object *intern; zend_class_entry *ce; @@ -3899,7 +3899,7 @@ ZEND_METHOD(reflection_class, isUserDefined) /* {{{ proto public bool ReflectionClass::isAnonymous() Returns whether this class is anonymous */ -ZEND_METHOD(reflection_class, isAnonymous) +ZEND_METHOD(ReflectionClass, isAnonymous) { reflection_object *intern; zend_class_entry *ce; @@ -3914,7 +3914,7 @@ ZEND_METHOD(reflection_class, isAnonymous) /* {{{ proto public string ReflectionClass::getFileName() Returns the filename of the file this class was declared in */ -ZEND_METHOD(reflection_class, getFileName) +ZEND_METHOD(ReflectionClass, getFileName) { reflection_object *intern; zend_class_entry *ce; @@ -3932,7 +3932,7 @@ ZEND_METHOD(reflection_class, getFileName) /* {{{ proto public int ReflectionClass::getStartLine() Returns the line this class' declaration starts at */ -ZEND_METHOD(reflection_class, getStartLine) +ZEND_METHOD(ReflectionClass, getStartLine) { reflection_object *intern; zend_class_entry *ce; @@ -3950,7 +3950,7 @@ ZEND_METHOD(reflection_class, getStartLine) /* {{{ proto public int ReflectionClass::getEndLine() Returns the line this class' declaration ends at */ -ZEND_METHOD(reflection_class, getEndLine) +ZEND_METHOD(ReflectionClass, getEndLine) { reflection_object *intern; zend_class_entry *ce; @@ -3968,7 +3968,7 @@ ZEND_METHOD(reflection_class, getEndLine) /* {{{ proto public string ReflectionClass::getDocComment() Returns the doc comment for this class */ -ZEND_METHOD(reflection_class, getDocComment) +ZEND_METHOD(ReflectionClass, getDocComment) { reflection_object *intern; zend_class_entry *ce; @@ -3986,7 +3986,7 @@ ZEND_METHOD(reflection_class, getDocComment) /* {{{ proto public ReflectionMethod ReflectionClass::getConstructor() Returns the class' constructor if there is one, NULL otherwise */ -ZEND_METHOD(reflection_class, getConstructor) +ZEND_METHOD(ReflectionClass, getConstructor) { reflection_object *intern; zend_class_entry *ce; @@ -4006,7 +4006,7 @@ ZEND_METHOD(reflection_class, getConstructor) /* {{{ proto public bool ReflectionClass::hasMethod(string name) Returns whether a method exists or not */ -ZEND_METHOD(reflection_class, hasMethod) +ZEND_METHOD(ReflectionClass, hasMethod) { reflection_object *intern; zend_class_entry *ce; @@ -4025,7 +4025,7 @@ ZEND_METHOD(reflection_class, hasMethod) /* {{{ proto public ReflectionMethod ReflectionClass::getMethod(string name) throws ReflectionException Returns the class' method specified by its name */ -ZEND_METHOD(reflection_class, getMethod) +ZEND_METHOD(ReflectionClass, getMethod) { reflection_object *intern; zend_class_entry *ce; @@ -4078,7 +4078,7 @@ static void _addmethod(zend_function *mptr, zend_class_entry *ce, zval *retval, /* {{{ proto public ReflectionMethod[] ReflectionClass::getMethods([long $filter]) Returns an array of this class' methods */ -ZEND_METHOD(reflection_class, getMethods) +ZEND_METHOD(ReflectionClass, getMethods) { reflection_object *intern; zend_class_entry *ce; @@ -4124,7 +4124,7 @@ ZEND_METHOD(reflection_class, getMethods) /* {{{ proto public bool ReflectionClass::hasProperty(string name) Returns whether a property exists or not */ -ZEND_METHOD(reflection_class, hasProperty) +ZEND_METHOD(ReflectionClass, hasProperty) { reflection_object *intern; zend_property_info *property_info; @@ -4154,7 +4154,7 @@ ZEND_METHOD(reflection_class, hasProperty) /* {{{ proto public ReflectionProperty ReflectionClass::getProperty(string name) throws ReflectionException Returns the class' property specified by its name */ -ZEND_METHOD(reflection_class, getProperty) +ZEND_METHOD(ReflectionClass, getProperty) { reflection_object *intern; zend_class_entry *ce, *ce2; @@ -4257,7 +4257,7 @@ static void _adddynproperty(zval *ptr, zend_string *key, zend_class_entry *ce, z /* {{{ proto public ReflectionProperty[] ReflectionClass::getProperties([long $filter]) Returns an array of this class' properties */ -ZEND_METHOD(reflection_class, getProperties) +ZEND_METHOD(ReflectionClass, getProperties) { reflection_object *intern; zend_class_entry *ce; @@ -4293,7 +4293,7 @@ ZEND_METHOD(reflection_class, getProperties) /* {{{ proto public bool ReflectionClass::hasConstant(string name) Returns whether a constant exists or not */ -ZEND_METHOD(reflection_class, hasConstant) +ZEND_METHOD(ReflectionClass, hasConstant) { reflection_object *intern; zend_class_entry *ce; @@ -4314,7 +4314,7 @@ ZEND_METHOD(reflection_class, hasConstant) /* {{{ proto public array ReflectionClass::getConstants() Returns an associative array containing this class' constants and their values */ -ZEND_METHOD(reflection_class, getConstants) +ZEND_METHOD(ReflectionClass, getConstants) { reflection_object *intern; zend_class_entry *ce; @@ -4340,7 +4340,7 @@ ZEND_METHOD(reflection_class, getConstants) /* {{{ proto public array ReflectionClass::getReflectionConstants() Returns an associative array containing this class' constants as ReflectionClassConstant objects */ -ZEND_METHOD(reflection_class, getReflectionConstants) +ZEND_METHOD(ReflectionClass, getReflectionConstants) { reflection_object *intern; zend_class_entry *ce; @@ -4362,7 +4362,7 @@ ZEND_METHOD(reflection_class, getReflectionConstants) /* {{{ proto public mixed ReflectionClass::getConstant(string name) Returns the class' constant specified by its name */ -ZEND_METHOD(reflection_class, getConstant) +ZEND_METHOD(ReflectionClass, getConstant) { reflection_object *intern; zend_class_entry *ce; @@ -4388,7 +4388,7 @@ ZEND_METHOD(reflection_class, getConstant) /* {{{ proto public mixed ReflectionClass::getReflectionConstant(string name) Returns the class' constant as ReflectionClassConstant objects */ -ZEND_METHOD(reflection_class, getReflectionConstant) +ZEND_METHOD(ReflectionClass, getReflectionConstant) { reflection_object *intern; zend_class_entry *ce; @@ -4423,7 +4423,7 @@ static void _class_check_flag(INTERNAL_FUNCTION_PARAMETERS, int mask) /* {{{ proto public bool ReflectionClass::isInstantiable() Returns whether this class is instantiable */ -ZEND_METHOD(reflection_class, isInstantiable) +ZEND_METHOD(ReflectionClass, isInstantiable) { reflection_object *intern; zend_class_entry *ce; @@ -4448,7 +4448,7 @@ ZEND_METHOD(reflection_class, isInstantiable) /* {{{ proto public bool ReflectionClass::isCloneable() Returns whether this class is cloneable */ -ZEND_METHOD(reflection_class, isCloneable) +ZEND_METHOD(ReflectionClass, isCloneable) { reflection_object *intern; zend_class_entry *ce; @@ -4485,7 +4485,7 @@ ZEND_METHOD(reflection_class, isCloneable) /* {{{ proto public bool ReflectionClass::isInterface() Returns whether this is an interface or a class */ -ZEND_METHOD(reflection_class, isInterface) +ZEND_METHOD(ReflectionClass, isInterface) { _class_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_INTERFACE); } @@ -4493,7 +4493,7 @@ ZEND_METHOD(reflection_class, isInterface) /* {{{ proto public bool ReflectionClass::isTrait() Returns whether this is a trait */ -ZEND_METHOD(reflection_class, isTrait) +ZEND_METHOD(ReflectionClass, isTrait) { _class_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_TRAIT); } @@ -4501,7 +4501,7 @@ ZEND_METHOD(reflection_class, isTrait) /* {{{ proto public bool ReflectionClass::isFinal() Returns whether this class is final */ -ZEND_METHOD(reflection_class, isFinal) +ZEND_METHOD(ReflectionClass, isFinal) { _class_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_FINAL); } @@ -4509,7 +4509,7 @@ ZEND_METHOD(reflection_class, isFinal) /* {{{ proto public bool ReflectionClass::isAbstract() Returns whether this class is abstract */ -ZEND_METHOD(reflection_class, isAbstract) +ZEND_METHOD(ReflectionClass, isAbstract) { _class_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_IMPLICIT_ABSTRACT_CLASS|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS); } @@ -4517,7 +4517,7 @@ ZEND_METHOD(reflection_class, isAbstract) /* {{{ proto public int ReflectionClass::getModifiers() Returns a bitfield of the access modifiers for this class */ -ZEND_METHOD(reflection_class, getModifiers) +ZEND_METHOD(ReflectionClass, getModifiers) { reflection_object *intern; zend_class_entry *ce; @@ -4535,7 +4535,7 @@ ZEND_METHOD(reflection_class, getModifiers) /* {{{ proto public bool ReflectionClass::isInstance(stdclass object) Returns whether the given object is an instance of this class */ -ZEND_METHOD(reflection_class, isInstance) +ZEND_METHOD(ReflectionClass, isInstance) { reflection_object *intern; zend_class_entry *ce; @@ -4551,7 +4551,7 @@ ZEND_METHOD(reflection_class, isInstance) /* {{{ proto public object ReflectionClass::newInstance([mixed* args], ...) Returns an instance of this class */ -ZEND_METHOD(reflection_class, newInstance) +ZEND_METHOD(ReflectionClass, newInstance) { zval retval; reflection_object *intern; @@ -4625,7 +4625,7 @@ ZEND_METHOD(reflection_class, newInstance) /* {{{ proto public object ReflectionClass::newInstanceWithoutConstructor() Returns an instance of this class without invoking its constructor */ -ZEND_METHOD(reflection_class, newInstanceWithoutConstructor) +ZEND_METHOD(ReflectionClass, newInstanceWithoutConstructor) { reflection_object *intern; zend_class_entry *ce; @@ -4648,7 +4648,7 @@ ZEND_METHOD(reflection_class, newInstanceWithoutConstructor) /* {{{ proto public object ReflectionClass::newInstanceArgs([array args]) Returns an instance of this class */ -ZEND_METHOD(reflection_class, newInstanceArgs) +ZEND_METHOD(ReflectionClass, newInstanceArgs) { zval retval, *val; reflection_object *intern; @@ -4735,7 +4735,7 @@ ZEND_METHOD(reflection_class, newInstanceArgs) /* {{{ proto public ReflectionClass[] ReflectionClass::getInterfaces() Returns an array of interfaces this class implements */ -ZEND_METHOD(reflection_class, getInterfaces) +ZEND_METHOD(ReflectionClass, getInterfaces) { reflection_object *intern; zend_class_entry *ce; @@ -4763,7 +4763,7 @@ ZEND_METHOD(reflection_class, getInterfaces) /* {{{ proto public String[] ReflectionClass::getInterfaceNames() Returns an array of names of interfaces this class implements */ -ZEND_METHOD(reflection_class, getInterfaceNames) +ZEND_METHOD(ReflectionClass, getInterfaceNames) { reflection_object *intern; zend_class_entry *ce; @@ -4790,7 +4790,7 @@ ZEND_METHOD(reflection_class, getInterfaceNames) /* {{{ proto public ReflectionClass[] ReflectionClass::getTraits() Returns an array of traits used by this class */ -ZEND_METHOD(reflection_class, getTraits) +ZEND_METHOD(ReflectionClass, getTraits) { reflection_object *intern; zend_class_entry *ce; @@ -4822,7 +4822,7 @@ ZEND_METHOD(reflection_class, getTraits) /* {{{ proto public String[] ReflectionClass::getTraitNames() Returns an array of names of traits used by this class */ -ZEND_METHOD(reflection_class, getTraitNames) +ZEND_METHOD(ReflectionClass, getTraitNames) { reflection_object *intern; zend_class_entry *ce; @@ -4847,7 +4847,7 @@ ZEND_METHOD(reflection_class, getTraitNames) /* {{{ proto public array ReflectionClass::getTraitAliases() Returns an array of trait aliases */ -ZEND_METHOD(reflection_class, getTraitAliases) +ZEND_METHOD(ReflectionClass, getTraitAliases) { reflection_object *intern; zend_class_entry *ce; @@ -4882,7 +4882,7 @@ ZEND_METHOD(reflection_class, getTraitAliases) /* {{{ proto public ReflectionClass ReflectionClass::getParentClass() Returns the class' parent class, or, if none exists, FALSE */ -ZEND_METHOD(reflection_class, getParentClass) +ZEND_METHOD(ReflectionClass, getParentClass) { reflection_object *intern; zend_class_entry *ce; @@ -4902,7 +4902,7 @@ ZEND_METHOD(reflection_class, getParentClass) /* {{{ proto public bool ReflectionClass::isSubclassOf(string|ReflectionClass class) Returns whether this class is a subclass of another class */ -ZEND_METHOD(reflection_class, isSubclassOf) +ZEND_METHOD(ReflectionClass, isSubclassOf) { reflection_object *intern, *argument; zend_class_entry *ce, *class_ce; @@ -4944,7 +4944,7 @@ ZEND_METHOD(reflection_class, isSubclassOf) /* {{{ proto public bool ReflectionClass::implementsInterface(string|ReflectionClass interface_name) Returns whether this class is a subclass of another class */ -ZEND_METHOD(reflection_class, implementsInterface) +ZEND_METHOD(ReflectionClass, implementsInterface) { reflection_object *intern, *argument; zend_class_entry *ce, *interface_ce; @@ -4991,7 +4991,7 @@ ZEND_METHOD(reflection_class, implementsInterface) /* {{{ proto public bool ReflectionClass::isIterable() Returns whether this class is iterable (can be used inside foreach) */ -ZEND_METHOD(reflection_class, isIterable) +ZEND_METHOD(ReflectionClass, isIterable) { reflection_object *intern; zend_class_entry *ce; @@ -5013,7 +5013,7 @@ ZEND_METHOD(reflection_class, isIterable) /* {{{ proto public ReflectionExtension|NULL ReflectionClass::getExtension() Returns NULL or the extension the class belongs to */ -ZEND_METHOD(reflection_class, getExtension) +ZEND_METHOD(ReflectionClass, getExtension) { reflection_object *intern; zend_class_entry *ce; @@ -5032,7 +5032,7 @@ ZEND_METHOD(reflection_class, getExtension) /* {{{ proto public string|false ReflectionClass::getExtensionName() Returns false or the name of the extension the class belongs to */ -ZEND_METHOD(reflection_class, getExtensionName) +ZEND_METHOD(ReflectionClass, getExtensionName) { reflection_object *intern; zend_class_entry *ce; @@ -5053,7 +5053,7 @@ ZEND_METHOD(reflection_class, getExtensionName) /* {{{ proto public bool ReflectionClass::inNamespace() Returns whether this class is defined in namespace */ -ZEND_METHOD(reflection_class, inNamespace) +ZEND_METHOD(ReflectionClass, inNamespace) { reflection_object *intern; zend_class_entry *ce; @@ -5072,7 +5072,7 @@ ZEND_METHOD(reflection_class, inNamespace) /* {{{ proto public string ReflectionClass::getNamespaceName() Returns the name of namespace where this class is defined */ -ZEND_METHOD(reflection_class, getNamespaceName) +ZEND_METHOD(ReflectionClass, getNamespaceName) { reflection_object *intern; zend_class_entry *ce; @@ -5094,7 +5094,7 @@ ZEND_METHOD(reflection_class, getNamespaceName) /* {{{ proto public string ReflectionClass::getShortName() Returns the short name of the class (without namespace part) */ -ZEND_METHOD(reflection_class, getShortName) +ZEND_METHOD(ReflectionClass, getShortName) { reflection_object *intern; zend_class_entry *ce; @@ -5116,7 +5116,7 @@ ZEND_METHOD(reflection_class, getShortName) /* {{{ proto public void ReflectionObject::__construct(mixed argument) throws ReflectionException Constructor. Takes an instance as an argument */ -ZEND_METHOD(reflection_object, __construct) +ZEND_METHOD(ReflectionObject, __construct) { reflection_class_object_ctor(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1); } @@ -5124,7 +5124,7 @@ ZEND_METHOD(reflection_object, __construct) /* {{{ 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) +ZEND_METHOD(ReflectionProperty, __construct) { zval *classname; zend_string *name; @@ -5196,7 +5196,7 @@ ZEND_METHOD(reflection_property, __construct) /* {{{ proto public string ReflectionProperty::__toString() Returns a string representation */ -ZEND_METHOD(reflection_property, __toString) +ZEND_METHOD(ReflectionProperty, __toString) { reflection_object *intern; property_reference *ref; @@ -5213,7 +5213,7 @@ ZEND_METHOD(reflection_property, __toString) /* {{{ proto public string ReflectionProperty::getName() Returns the class' name */ -ZEND_METHOD(reflection_property, getName) +ZEND_METHOD(ReflectionProperty, getName) { reflection_object *intern; property_reference *ref; @@ -5242,7 +5242,7 @@ static void _property_check_flag(INTERNAL_FUNCTION_PARAMETERS, int mask) /* {{{ /* {{{ proto public bool ReflectionProperty::isPublic() Returns whether this property is public */ -ZEND_METHOD(reflection_property, isPublic) +ZEND_METHOD(ReflectionProperty, isPublic) { _property_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_PUBLIC); } @@ -5250,7 +5250,7 @@ ZEND_METHOD(reflection_property, isPublic) /* {{{ proto public bool ReflectionProperty::isPrivate() Returns whether this property is private */ -ZEND_METHOD(reflection_property, isPrivate) +ZEND_METHOD(ReflectionProperty, isPrivate) { _property_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_PRIVATE); } @@ -5258,7 +5258,7 @@ ZEND_METHOD(reflection_property, isPrivate) /* {{{ proto public bool ReflectionProperty::isProtected() Returns whether this property is protected */ -ZEND_METHOD(reflection_property, isProtected) +ZEND_METHOD(ReflectionProperty, isProtected) { _property_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_PROTECTED); } @@ -5266,7 +5266,7 @@ ZEND_METHOD(reflection_property, isProtected) /* {{{ proto public bool ReflectionProperty::isStatic() Returns whether this property is static */ -ZEND_METHOD(reflection_property, isStatic) +ZEND_METHOD(ReflectionProperty, isStatic) { _property_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_STATIC); } @@ -5274,7 +5274,7 @@ ZEND_METHOD(reflection_property, isStatic) /* {{{ proto public bool ReflectionProperty::isDefault() Returns whether this property is default (declared at compilation time). */ -ZEND_METHOD(reflection_property, isDefault) +ZEND_METHOD(ReflectionProperty, isDefault) { reflection_object *intern; property_reference *ref; @@ -5289,7 +5289,7 @@ ZEND_METHOD(reflection_property, isDefault) /* {{{ proto public int ReflectionProperty::getModifiers() Returns a bitfield of the access modifiers for this property */ -ZEND_METHOD(reflection_property, getModifiers) +ZEND_METHOD(ReflectionProperty, getModifiers) { reflection_object *intern; property_reference *ref; @@ -5306,7 +5306,7 @@ ZEND_METHOD(reflection_property, getModifiers) /* {{{ proto public mixed ReflectionProperty::getValue([stdclass object]) Returns this property's value */ -ZEND_METHOD(reflection_property, getValue) +ZEND_METHOD(ReflectionProperty, getValue) { reflection_object *intern; property_reference *ref; @@ -5360,7 +5360,7 @@ ZEND_METHOD(reflection_property, getValue) /* {{{ proto public void ReflectionProperty::setValue([stdclass object,] mixed value) Sets this property's value */ -ZEND_METHOD(reflection_property, setValue) +ZEND_METHOD(ReflectionProperty, setValue) { reflection_object *intern; property_reference *ref; @@ -5397,7 +5397,7 @@ ZEND_METHOD(reflection_property, setValue) /* {{{ proto public mixed ReflectionProperty::isInitialized([stdclass object]) Returns this property's value */ -ZEND_METHOD(reflection_property, isInitialized) +ZEND_METHOD(ReflectionProperty, isInitialized) { reflection_object *intern; property_reference *ref; @@ -5450,7 +5450,7 @@ ZEND_METHOD(reflection_property, isInitialized) /* {{{ proto public ReflectionClass ReflectionProperty::getDeclaringClass() Get the declaring class */ -ZEND_METHOD(reflection_property, getDeclaringClass) +ZEND_METHOD(ReflectionProperty, getDeclaringClass) { reflection_object *intern; property_reference *ref; @@ -5468,7 +5468,7 @@ ZEND_METHOD(reflection_property, getDeclaringClass) /* {{{ proto public string ReflectionProperty::getDocComment() Returns the doc comment for this property */ -ZEND_METHOD(reflection_property, getDocComment) +ZEND_METHOD(ReflectionProperty, getDocComment) { reflection_object *intern; property_reference *ref; @@ -5486,7 +5486,7 @@ ZEND_METHOD(reflection_property, getDocComment) /* {{{ proto public int ReflectionProperty::setAccessible(bool visible) Sets whether non-public properties can be requested */ -ZEND_METHOD(reflection_property, setAccessible) +ZEND_METHOD(ReflectionProperty, setAccessible) { reflection_object *intern; zend_bool visible; @@ -5503,7 +5503,7 @@ ZEND_METHOD(reflection_property, setAccessible) /* {{{ proto public ReflectionType ReflectionProperty::getType() Returns the type associated with the property */ -ZEND_METHOD(reflection_property, getType) +ZEND_METHOD(ReflectionProperty, getType) { reflection_object *intern; property_reference *ref; @@ -5524,7 +5524,7 @@ ZEND_METHOD(reflection_property, getType) /* {{{ proto public bool ReflectionProperty::hasType() Returns whether property has a type */ -ZEND_METHOD(reflection_property, hasType) +ZEND_METHOD(ReflectionProperty, hasType) { reflection_object *intern; property_reference *ref; @@ -5541,7 +5541,7 @@ ZEND_METHOD(reflection_property, hasType) /* {{{ proto public bool ReflectionProperty::hasDefaultValue() Returns whether property has a default value */ -ZEND_METHOD(reflection_property, hasDefaultValue) +ZEND_METHOD(ReflectionProperty, hasDefaultValue) { reflection_object *intern; property_reference *ref; @@ -5567,7 +5567,7 @@ ZEND_METHOD(reflection_property, hasDefaultValue) /* {{{ proto public mixed ReflectionProperty::getDefaultValue() Returns the default value of a property */ -ZEND_METHOD(reflection_property, getDefaultValue) +ZEND_METHOD(ReflectionProperty, getDefaultValue) { reflection_object *intern; property_reference *ref; @@ -5607,7 +5607,7 @@ ZEND_METHOD(reflection_property, getDefaultValue) /* {{{ proto public void ReflectionExtension::__construct(string name) Constructor. Throws an Exception in case the given extension does not exist */ -ZEND_METHOD(reflection_extension, __construct) +ZEND_METHOD(ReflectionExtension, __construct) { zval *object; char *lcname; @@ -5641,7 +5641,7 @@ ZEND_METHOD(reflection_extension, __construct) /* {{{ proto public string ReflectionExtension::__toString() Returns a string representation */ -ZEND_METHOD(reflection_extension, __toString) +ZEND_METHOD(ReflectionExtension, __toString) { reflection_object *intern; zend_module_entry *module; @@ -5658,7 +5658,7 @@ ZEND_METHOD(reflection_extension, __toString) /* {{{ proto public string ReflectionExtension::getName() Returns this extension's name */ -ZEND_METHOD(reflection_extension, getName) +ZEND_METHOD(ReflectionExtension, getName) { reflection_object *intern; zend_module_entry *module; @@ -5674,7 +5674,7 @@ ZEND_METHOD(reflection_extension, getName) /* {{{ proto public string ReflectionExtension::getVersion() Returns this extension's version */ -ZEND_METHOD(reflection_extension, getVersion) +ZEND_METHOD(ReflectionExtension, getVersion) { reflection_object *intern; zend_module_entry *module; @@ -5695,7 +5695,7 @@ ZEND_METHOD(reflection_extension, getVersion) /* {{{ proto public ReflectionFunction[] ReflectionExtension::getFunctions() Returns an array of this extension's functions */ -ZEND_METHOD(reflection_extension, getFunctions) +ZEND_METHOD(ReflectionExtension, getFunctions) { reflection_object *intern; zend_module_entry *module; @@ -5720,7 +5720,7 @@ ZEND_METHOD(reflection_extension, getFunctions) /* {{{ proto public array ReflectionExtension::getConstants() Returns an associative array containing this extension's constants and their values */ -ZEND_METHOD(reflection_extension, getConstants) +ZEND_METHOD(ReflectionExtension, getConstants) { reflection_object *intern; zend_module_entry *module; @@ -5759,7 +5759,7 @@ static void _addinientry(zend_ini_entry *ini_entry, zval *retval, int number) /* {{{ proto public array ReflectionExtension::getINIEntries() Returns an associative array containing this extension's INI entries and their values */ -ZEND_METHOD(reflection_extension, getINIEntries) +ZEND_METHOD(ReflectionExtension, getINIEntries) { reflection_object *intern; zend_module_entry *module; @@ -5803,7 +5803,7 @@ static void add_extension_class(zend_class_entry *ce, zend_string *key, zval *cl /* {{{ proto public ReflectionClass[] ReflectionExtension::getClasses() Returns an array containing ReflectionClass objects for all classes of this extension */ -ZEND_METHOD(reflection_extension, getClasses) +ZEND_METHOD(ReflectionExtension, getClasses) { reflection_object *intern; zend_module_entry *module; @@ -5824,7 +5824,7 @@ ZEND_METHOD(reflection_extension, getClasses) /* {{{ proto public array ReflectionExtension::getClassNames() Returns an array containing all names of all classes of this extension */ -ZEND_METHOD(reflection_extension, getClassNames) +ZEND_METHOD(ReflectionExtension, getClassNames) { reflection_object *intern; zend_module_entry *module; @@ -5845,7 +5845,7 @@ ZEND_METHOD(reflection_extension, getClassNames) /* {{{ proto public array ReflectionExtension::getDependencies() Returns an array containing all names of all extensions this extension depends on */ -ZEND_METHOD(reflection_extension, getDependencies) +ZEND_METHOD(ReflectionExtension, getDependencies) { reflection_object *intern; zend_module_entry *module; @@ -5911,7 +5911,7 @@ ZEND_METHOD(reflection_extension, getDependencies) /* {{{ proto public void ReflectionExtension::info() Prints phpinfo block for the extension */ -ZEND_METHOD(reflection_extension, info) +ZEND_METHOD(ReflectionExtension, info) { reflection_object *intern; zend_module_entry *module; @@ -5927,7 +5927,7 @@ ZEND_METHOD(reflection_extension, info) /* {{{ proto public bool ReflectionExtension::isPersistent() Returns whether this extension is persistent */ -ZEND_METHOD(reflection_extension, isPersistent) +ZEND_METHOD(ReflectionExtension, isPersistent) { reflection_object *intern; zend_module_entry *module; @@ -5943,7 +5943,7 @@ ZEND_METHOD(reflection_extension, isPersistent) /* {{{ proto public bool ReflectionExtension::isTemporary() Returns whether this extension is temporary */ -ZEND_METHOD(reflection_extension, isTemporary) +ZEND_METHOD(ReflectionExtension, isTemporary) { reflection_object *intern; zend_module_entry *module; @@ -5959,7 +5959,7 @@ ZEND_METHOD(reflection_extension, isTemporary) /* {{{ 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) +ZEND_METHOD(ReflectionZendExtension, __construct) { zval *object; reflection_object *intern; @@ -5989,7 +5989,7 @@ ZEND_METHOD(reflection_zend_extension, __construct) /* {{{ proto public string ReflectionZendExtension::__toString() Returns a string representation */ -ZEND_METHOD(reflection_zend_extension, __toString) +ZEND_METHOD(ReflectionZendExtension, __toString) { reflection_object *intern; zend_extension *extension; @@ -6006,7 +6006,7 @@ ZEND_METHOD(reflection_zend_extension, __toString) /* {{{ proto public string ReflectionZendExtension::getName() Returns the name of this Zend extension */ -ZEND_METHOD(reflection_zend_extension, getName) +ZEND_METHOD(ReflectionZendExtension, getName) { reflection_object *intern; zend_extension *extension; @@ -6022,7 +6022,7 @@ ZEND_METHOD(reflection_zend_extension, getName) /* {{{ proto public string ReflectionZendExtension::getVersion() Returns the version information of this Zend extension */ -ZEND_METHOD(reflection_zend_extension, getVersion) +ZEND_METHOD(ReflectionZendExtension, getVersion) { reflection_object *intern; zend_extension *extension; @@ -6042,7 +6042,7 @@ ZEND_METHOD(reflection_zend_extension, getVersion) /* {{{ proto public void ReflectionZendExtension::getAuthor() * Returns the name of this Zend extension's author */ -ZEND_METHOD(reflection_zend_extension, getAuthor) +ZEND_METHOD(ReflectionZendExtension, getAuthor) { reflection_object *intern; zend_extension *extension; @@ -6062,7 +6062,7 @@ ZEND_METHOD(reflection_zend_extension, getAuthor) /* {{{ proto public void ReflectionZendExtension::getURL() Returns this Zend extension's URL*/ -ZEND_METHOD(reflection_zend_extension, getURL) +ZEND_METHOD(ReflectionZendExtension, getURL) { reflection_object *intern; zend_extension *extension; @@ -6082,7 +6082,7 @@ ZEND_METHOD(reflection_zend_extension, getURL) /* {{{ proto public void ReflectionZendExtension::getCopyright() Returns this Zend extension's copyright information */ -ZEND_METHOD(reflection_zend_extension, getCopyright) +ZEND_METHOD(ReflectionZendExtension, getCopyright) { reflection_object *intern; zend_extension *extension; @@ -6102,7 +6102,7 @@ ZEND_METHOD(reflection_zend_extension, getCopyright) /* {{{ proto public ReflectionReference::__construct() * Dummy constructor -- always throws ReflectionExceptions. */ -ZEND_METHOD(reflection_reference, __construct) +ZEND_METHOD(ReflectionReference, __construct) { _DO_THROW( "Cannot directly instantiate ReflectionReference. " @@ -6123,7 +6123,7 @@ static zend_bool is_ignorable_reference(HashTable *ht, zval *ref) { /* {{{ proto public ReflectionReference|null ReflectionReference::fromArrayElement(array array, mixed key) * Create ReflectionReference for array item. Returns null if not a reference. */ -ZEND_METHOD(reflection_reference, fromArrayElement) +ZEND_METHOD(ReflectionReference, fromArrayElement) { HashTable *ht; zval *key, *item; @@ -6161,7 +6161,7 @@ ZEND_METHOD(reflection_reference, fromArrayElement) /* {{{ proto public int|string ReflectionReference::getId() * Returns a unique identifier for the reference. * The format of the return value is unspecified and may change. */ -ZEND_METHOD(reflection_reference, getId) +ZEND_METHOD(ReflectionReference, getId) { reflection_object *intern; unsigned char digest[20]; @@ -6195,277 +6195,6 @@ ZEND_METHOD(reflection_reference, getId) } /* }}} */ -/* {{{ method tables */ -static const zend_function_entry reflection_exception_functions[] = { - PHP_FE_END -}; - -static const zend_function_entry reflection_functions[] = { - ZEND_ME(reflection, getModifierNames, arginfo_class_Reflection_getModifierNames, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) - PHP_FE_END -}; - -static const zend_function_entry reflector_functions[] = { - PHP_FE_END -}; - -static const zend_function_entry reflection_function_abstract_functions[] = { - 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_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 -}; - -static const zend_function_entry reflection_generator_functions[] = { - 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 -}; - -static const zend_function_entry reflection_method_functions[] = { - 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 -}; - -static const zend_function_entry reflection_class_functions[] = { - 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 -}; - -static const zend_function_entry reflection_object_functions[] = { - ZEND_ME(reflection_object, __construct, arginfo_class_ReflectionObject___construct, 0) - PHP_FE_END -}; - -static const zend_function_entry reflection_property_functions[] = { - 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 -}; - -static const zend_function_entry reflection_class_constant_functions[] = { - 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 -}; - -static const zend_function_entry reflection_parameter_functions[] = { - 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_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_class_ReflectionNamedType_getName, 0) - ZEND_ME(reflection_named_type, isBuiltin, arginfo_class_ReflectionNamedType_isBuiltin, 0) - PHP_FE_END -}; - -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_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 -}; - -static const zend_function_entry reflection_zend_extension_functions[] = { - 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 -}; - -static const zend_function_entry reflection_reference_functions[] = { - 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_class_ReflectionReference___clone, ZEND_ACC_PRIVATE) - ZEND_ME(reflection_reference, __construct, arginfo_class_ReflectionReference___construct, ZEND_ACC_PRIVATE) - PHP_FE_END -}; -/* }}} */ - static const zend_function_entry reflection_ext_functions[] = { /* {{{ */ PHP_FE_END }; /* }}} */ @@ -6505,54 +6234,54 @@ PHP_MINIT_FUNCTION(reflection) /* {{{ */ reflection_object_handlers.write_property = _reflection_write_property; reflection_object_handlers.get_gc = reflection_get_gc; - INIT_CLASS_ENTRY(_reflection_entry, "ReflectionException", reflection_exception_functions); + INIT_CLASS_ENTRY(_reflection_entry, "ReflectionException", class_ReflectionException_methods); reflection_exception_ptr = zend_register_internal_class_ex(&_reflection_entry, zend_ce_exception); - INIT_CLASS_ENTRY(_reflection_entry, "Reflection", reflection_functions); + INIT_CLASS_ENTRY(_reflection_entry, "Reflection", class_Reflection_methods); reflection_ptr = zend_register_internal_class(&_reflection_entry); - INIT_CLASS_ENTRY(_reflection_entry, "Reflector", reflector_functions); + INIT_CLASS_ENTRY(_reflection_entry, "Reflector", class_Reflector_methods); 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); + INIT_CLASS_ENTRY(_reflection_entry, "ReflectionFunctionAbstract", class_ReflectionFunctionAbstract_methods); reflection_init_class_handlers(&_reflection_entry); reflection_function_abstract_ptr = zend_register_internal_class(&_reflection_entry); zend_class_implements(reflection_function_abstract_ptr, 1, reflector_ptr); zend_declare_property_string(reflection_function_abstract_ptr, "name", sizeof("name")-1, "", ZEND_ACC_ABSTRACT); - INIT_CLASS_ENTRY(_reflection_entry, "ReflectionFunction", reflection_function_functions); + INIT_CLASS_ENTRY(_reflection_entry, "ReflectionFunction", class_ReflectionFunction_methods); reflection_init_class_handlers(&_reflection_entry); reflection_function_ptr = zend_register_internal_class_ex(&_reflection_entry, reflection_function_abstract_ptr); zend_declare_property_string(reflection_function_ptr, "name", sizeof("name")-1, "", ZEND_ACC_PUBLIC); REGISTER_REFLECTION_CLASS_CONST_LONG(function, "IS_DEPRECATED", ZEND_ACC_DEPRECATED); - INIT_CLASS_ENTRY(_reflection_entry, "ReflectionGenerator", reflection_generator_functions); + INIT_CLASS_ENTRY(_reflection_entry, "ReflectionGenerator", class_ReflectionGenerator_methods); reflection_init_class_handlers(&_reflection_entry); reflection_generator_ptr = zend_register_internal_class(&_reflection_entry); - INIT_CLASS_ENTRY(_reflection_entry, "ReflectionParameter", reflection_parameter_functions); + INIT_CLASS_ENTRY(_reflection_entry, "ReflectionParameter", class_ReflectionParameter_methods); reflection_init_class_handlers(&_reflection_entry); reflection_parameter_ptr = zend_register_internal_class(&_reflection_entry); zend_class_implements(reflection_parameter_ptr, 1, reflector_ptr); zend_declare_property_string(reflection_parameter_ptr, "name", sizeof("name")-1, "", ZEND_ACC_PUBLIC); - INIT_CLASS_ENTRY(_reflection_entry, "ReflectionType", reflection_type_functions); + INIT_CLASS_ENTRY(_reflection_entry, "ReflectionType", class_ReflectionType_methods); 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); + INIT_CLASS_ENTRY(_reflection_entry, "ReflectionNamedType", class_ReflectionNamedType_methods); 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); + INIT_CLASS_ENTRY(_reflection_entry, "ReflectionUnionType", class_ReflectionUnionType_methods); 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); + INIT_CLASS_ENTRY(_reflection_entry, "ReflectionMethod", class_ReflectionMethod_methods); reflection_init_class_handlers(&_reflection_entry); reflection_method_ptr = zend_register_internal_class_ex(&_reflection_entry, reflection_function_abstract_ptr); zend_declare_property_string(reflection_method_ptr, "name", sizeof("name")-1, "", ZEND_ACC_PUBLIC); @@ -6565,7 +6294,7 @@ PHP_MINIT_FUNCTION(reflection) /* {{{ */ REGISTER_REFLECTION_CLASS_CONST_LONG(method, "IS_ABSTRACT", ZEND_ACC_ABSTRACT); REGISTER_REFLECTION_CLASS_CONST_LONG(method, "IS_FINAL", ZEND_ACC_FINAL); - INIT_CLASS_ENTRY(_reflection_entry, "ReflectionClass", reflection_class_functions); + INIT_CLASS_ENTRY(_reflection_entry, "ReflectionClass", class_ReflectionClass_methods); reflection_init_class_handlers(&_reflection_entry); reflection_class_ptr = zend_register_internal_class(&_reflection_entry); zend_class_implements(reflection_class_ptr, 1, reflector_ptr); @@ -6576,18 +6305,18 @@ PHP_MINIT_FUNCTION(reflection) /* {{{ */ REGISTER_REFLECTION_CLASS_CONST_LONG(class, "IS_EXPLICIT_ABSTRACT", ZEND_ACC_EXPLICIT_ABSTRACT_CLASS); REGISTER_REFLECTION_CLASS_CONST_LONG(class, "IS_FINAL", ZEND_ACC_FINAL); - INIT_CLASS_ENTRY(_reflection_entry, "ReflectionObject", reflection_object_functions); + INIT_CLASS_ENTRY(_reflection_entry, "ReflectionObject", class_ReflectionObject_methods); reflection_init_class_handlers(&_reflection_entry); reflection_object_ptr = zend_register_internal_class_ex(&_reflection_entry, reflection_class_ptr); - INIT_CLASS_ENTRY(_reflection_entry, "ReflectionProperty", reflection_property_functions); + INIT_CLASS_ENTRY(_reflection_entry, "ReflectionProperty", class_ReflectionProperty_methods); reflection_init_class_handlers(&_reflection_entry); reflection_property_ptr = zend_register_internal_class(&_reflection_entry); zend_class_implements(reflection_property_ptr, 1, reflector_ptr); zend_declare_property_string(reflection_property_ptr, "name", sizeof("name")-1, "", ZEND_ACC_PUBLIC); zend_declare_property_string(reflection_property_ptr, "class", sizeof("class")-1, "", ZEND_ACC_PUBLIC); - INIT_CLASS_ENTRY(_reflection_entry, "ReflectionClassConstant", reflection_class_constant_functions); + INIT_CLASS_ENTRY(_reflection_entry, "ReflectionClassConstant", class_ReflectionClassConstant_methods); reflection_init_class_handlers(&_reflection_entry); reflection_class_constant_ptr = zend_register_internal_class(&_reflection_entry); zend_class_implements(reflection_class_constant_ptr, 1, reflector_ptr); @@ -6599,19 +6328,19 @@ PHP_MINIT_FUNCTION(reflection) /* {{{ */ REGISTER_REFLECTION_CLASS_CONST_LONG(property, "IS_PROTECTED", ZEND_ACC_PROTECTED); REGISTER_REFLECTION_CLASS_CONST_LONG(property, "IS_PRIVATE", ZEND_ACC_PRIVATE); - INIT_CLASS_ENTRY(_reflection_entry, "ReflectionExtension", reflection_extension_functions); + INIT_CLASS_ENTRY(_reflection_entry, "ReflectionExtension", class_ReflectionExtension_methods); reflection_init_class_handlers(&_reflection_entry); reflection_extension_ptr = zend_register_internal_class(&_reflection_entry); zend_class_implements(reflection_extension_ptr, 1, reflector_ptr); zend_declare_property_string(reflection_extension_ptr, "name", sizeof("name")-1, "", ZEND_ACC_PUBLIC); - INIT_CLASS_ENTRY(_reflection_entry, "ReflectionZendExtension", reflection_zend_extension_functions); + INIT_CLASS_ENTRY(_reflection_entry, "ReflectionZendExtension", class_ReflectionZendExtension_methods); reflection_init_class_handlers(&_reflection_entry); reflection_zend_extension_ptr = zend_register_internal_class(&_reflection_entry); zend_class_implements(reflection_zend_extension_ptr, 1, reflector_ptr); zend_declare_property_string(reflection_zend_extension_ptr, "name", sizeof("name")-1, "", ZEND_ACC_PUBLIC); - INIT_CLASS_ENTRY(_reflection_entry, "ReflectionReference", reflection_reference_functions); + INIT_CLASS_ENTRY(_reflection_entry, "ReflectionReference", class_ReflectionReference_methods); reflection_init_class_handlers(&_reflection_entry); _reflection_entry.ce_flags |= ZEND_ACC_FINAL; reflection_reference_ptr = zend_register_internal_class(&_reflection_entry); diff --git a/ext/reflection/php_reflection.stub.php b/ext/reflection/php_reflection.stub.php index 00c7013f099af..be6269fe78ba1 100644 --- a/ext/reflection/php_reflection.stub.php +++ b/ext/reflection/php_reflection.stub.php @@ -1,5 +1,7 @@ ce_flags |= ZEND_ACC_INTERFACE; - INIT_CLASS_ENTRY(ce, PS_SID_IFACE_NAME, php_session_id_iface_functions); + INIT_CLASS_ENTRY(ce, PS_SID_IFACE_NAME, class_SessionIdInterface_methods); php_session_id_iface_entry = zend_register_internal_class(&ce); php_session_id_iface_entry->ce_flags |= ZEND_ACC_INTERFACE; - INIT_CLASS_ENTRY(ce, PS_UPDATE_TIMESTAMP_IFACE_NAME, php_session_update_timestamp_iface_functions); + INIT_CLASS_ENTRY(ce, PS_UPDATE_TIMESTAMP_IFACE_NAME, class_SessionUpdateTimestampHandlerInterface_methods); php_session_update_timestamp_iface_entry = zend_register_internal_class(&ce); php_session_update_timestamp_iface_entry->ce_flags |= ZEND_ACC_INTERFACE; /* Register base class */ - INIT_CLASS_ENTRY(ce, PS_CLASS_NAME, php_session_class_functions); + INIT_CLASS_ENTRY(ce, PS_CLASS_NAME, class_SessionHandler_methods); php_session_class_entry = zend_register_internal_class(&ce); zend_class_implements(php_session_class_entry, 1, php_session_iface_entry); zend_class_implements(php_session_class_entry, 1, php_session_id_iface_entry); @@ -3251,7 +3177,7 @@ zend_module_entry session_module_entry = { NULL, session_deps, "session", - session_functions, + ext_functions, PHP_MINIT(session), PHP_MSHUTDOWN(session), PHP_RINIT(session), PHP_RSHUTDOWN(session), PHP_MINFO(session), diff --git a/ext/session/session.stub.php b/ext/session/session.stub.php index 8c3a6480259cb..24942aba9b477 100644 --- a/ext/session/session.stub.php +++ b/ext/session/session.stub.php @@ -1,5 +1,7 @@