}
/* {{{ Preventing __clone from being called */
-ZEND_METHOD(reflection, __clone)
+ZEND_METHOD(ReflectionClass, __clone)
{
/* Should never be executable */
_DO_THROW("Cannot clone object using __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;
/* {{{ 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;
/* {{{ proto public string ReflectionFunction::__toString()
Returns a string representation */
-ZEND_METHOD(reflection_function, __toString)
+ZEND_METHOD(ReflectionFunction, __toString)
{
reflection_object *intern;
zend_function *fptr;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ proto public mixed ReflectionFunction::invoke([mixed* args])
Invokes the function */
-ZEND_METHOD(reflection_function, invoke)
+ZEND_METHOD(ReflectionFunction, invoke)
{
zval retval;
zval *params = NULL;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* }}} */
/* {{{ proto public void ReflectionGenerator::__construct(object Generator) */
-ZEND_METHOD(reflection_generator, __construct)
+ZEND_METHOD(ReflectionGenerator, __construct)
{
zval *generator, *object;
reflection_object *intern;
}
/* {{{ 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);
/* }}} */
/* {{{ 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;
/* }}} */
/* {{{ 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;
/* }}} */
/* {{{ 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;
/* }}} */
/* {{{ 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;
/* }}} */
/* {{{ 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;
/* {{{ 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;
/* {{{ proto public string ReflectionParameter::__toString()
Returns a string representation */
-ZEND_METHOD(reflection_parameter, __toString)
+ZEND_METHOD(ReflectionParameter, __toString)
{
reflection_object *intern;
parameter_reference *param;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ proto public string ReflectionMethod::__toString()
Returns a string representation */
-ZEND_METHOD(reflection_method, __toString)
+ZEND_METHOD(ReflectionMethod, __toString)
{
reflection_object *intern;
zend_function *mptr;
/* {{{ proto public mixed ReflectionMethod::getClosure([mixed object])
Invokes the function */
-ZEND_METHOD(reflection_method, getClosure)
+ZEND_METHOD(ReflectionMethod, getClosure)
{
reflection_object *intern;
zval *obj;
/* {{{ 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);
}
/* {{{ 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);
}
/* {{{ 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);
}
/* {{{ 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);
}
/* {{{ 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);
}
/* {{{ 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);
}
/* {{{ 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);
}
/* {{{ 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);
}
/* {{{ 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);
}
/* {{{ 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);
}
/* {{{ 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);
}
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ proto public ReflectionClass ReflectionMethod::getDeclaringClass()
Get the declaring class */
-ZEND_METHOD(reflection_method, getDeclaringClass)
+ZEND_METHOD(ReflectionMethod, getDeclaringClass)
{
reflection_object *intern;
zend_function *mptr;
/* {{{ proto public ReflectionClass ReflectionMethod::getPrototype()
Get the prototype */
-ZEND_METHOD(reflection_method, getPrototype)
+ZEND_METHOD(ReflectionMethod, getPrototype)
{
reflection_object *intern;
zend_function *mptr;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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();
/* {{{ 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);
}
/* {{{ 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);
}
/* {{{ 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);
}
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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);
}
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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);
}
/* {{{ 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);
}
/* {{{ 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);
}
/* {{{ 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);
}
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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);
}
/* {{{ 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;
/* {{{ proto public string ReflectionProperty::__toString()
Returns a string representation */
-ZEND_METHOD(reflection_property, __toString)
+ZEND_METHOD(ReflectionProperty, __toString)
{
reflection_object *intern;
property_reference *ref;
/* {{{ proto public string ReflectionProperty::getName()
Returns the class' name */
-ZEND_METHOD(reflection_property, getName)
+ZEND_METHOD(ReflectionProperty, getName)
{
reflection_object *intern;
property_reference *ref;
/* {{{ 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);
}
/* {{{ 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);
}
/* {{{ 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);
}
/* {{{ 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);
}
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ proto public ReflectionClass ReflectionProperty::getDeclaringClass()
Get the declaring class */
-ZEND_METHOD(reflection_property, getDeclaringClass)
+ZEND_METHOD(ReflectionProperty, getDeclaringClass)
{
reflection_object *intern;
property_reference *ref;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ 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;
/* {{{ proto public ReflectionReference::__construct()
* Dummy constructor -- always throws ReflectionExceptions. */
-ZEND_METHOD(reflection_reference, __construct)
+ZEND_METHOD(ReflectionReference, __construct)
{
_DO_THROW(
"Cannot directly instantiate ReflectionReference. "
/* {{{ 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;
/* {{{ 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];
}
/* }}} */
-/* {{{ 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
}; /* }}} */
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);
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);
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);
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);
#define arginfo_class_ReflectionClass_getModifiers arginfo_class_ReflectionFunctionAbstract___clone
-ZEND_BEGIN_ARG_INFO_EX(arginfo_class_ReflectionClass_isIntance, 0, 0, 1)
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_ReflectionClass_isInstance, 0, 0, 1)
ZEND_ARG_TYPE_INFO(0, object, IS_OBJECT, 0)
ZEND_END_ARG_INFO()
#define arginfo_class_ReflectionReference___clone arginfo_class_ReflectionFunctionAbstract___clone
#define arginfo_class_ReflectionReference___construct arginfo_class_ReflectionFunctionAbstract___clone
+
+
+ZEND_METHOD(Reflection, getModifierNames);
+ZEND_METHOD(ReflectionClass, __clone);
+ZEND_METHOD(ReflectionFunctionAbstract, inNamespace);
+ZEND_METHOD(ReflectionFunctionAbstract, isClosure);
+ZEND_METHOD(ReflectionFunctionAbstract, isDeprecated);
+ZEND_METHOD(ReflectionFunctionAbstract, isInternal);
+ZEND_METHOD(ReflectionFunctionAbstract, isUserDefined);
+ZEND_METHOD(ReflectionFunctionAbstract, isGenerator);
+ZEND_METHOD(ReflectionFunctionAbstract, isVariadic);
+ZEND_METHOD(ReflectionFunctionAbstract, getClosureThis);
+ZEND_METHOD(ReflectionFunctionAbstract, getClosureScopeClass);
+ZEND_METHOD(ReflectionFunctionAbstract, getDocComment);
+ZEND_METHOD(ReflectionFunctionAbstract, getEndLine);
+ZEND_METHOD(ReflectionFunctionAbstract, getExtension);
+ZEND_METHOD(ReflectionFunctionAbstract, getExtensionName);
+ZEND_METHOD(ReflectionFunctionAbstract, getFileName);
+ZEND_METHOD(ReflectionFunctionAbstract, getName);
+ZEND_METHOD(ReflectionFunctionAbstract, getNamespaceName);
+ZEND_METHOD(ReflectionFunctionAbstract, getNumberOfParameters);
+ZEND_METHOD(ReflectionFunctionAbstract, getNumberOfRequiredParameters);
+ZEND_METHOD(ReflectionFunctionAbstract, getParameters);
+ZEND_METHOD(ReflectionFunctionAbstract, getShortName);
+ZEND_METHOD(ReflectionFunctionAbstract, getStartLine);
+ZEND_METHOD(ReflectionFunctionAbstract, getStaticVariables);
+ZEND_METHOD(ReflectionFunctionAbstract, returnsReference);
+ZEND_METHOD(ReflectionFunctionAbstract, hasReturnType);
+ZEND_METHOD(ReflectionFunctionAbstract, getReturnType);
+ZEND_METHOD(ReflectionFunction, __construct);
+ZEND_METHOD(ReflectionFunction, __toString);
+ZEND_METHOD(ReflectionFunction, isDisabled);
+ZEND_METHOD(ReflectionFunction, invoke);
+ZEND_METHOD(ReflectionFunction, invokeArgs);
+ZEND_METHOD(ReflectionFunction, getClosure);
+ZEND_METHOD(ReflectionGenerator, __construct);
+ZEND_METHOD(ReflectionGenerator, getExecutingLine);
+ZEND_METHOD(ReflectionGenerator, getExecutingFile);
+ZEND_METHOD(ReflectionGenerator, getTrace);
+ZEND_METHOD(ReflectionGenerator, getFunction);
+ZEND_METHOD(ReflectionGenerator, getThis);
+ZEND_METHOD(ReflectionGenerator, getExecutingGenerator);
+ZEND_METHOD(ReflectionMethod, __construct);
+ZEND_METHOD(ReflectionMethod, __toString);
+ZEND_METHOD(ReflectionMethod, isPublic);
+ZEND_METHOD(ReflectionMethod, isPrivate);
+ZEND_METHOD(ReflectionMethod, isProtected);
+ZEND_METHOD(ReflectionMethod, isAbstract);
+ZEND_METHOD(ReflectionMethod, isFinal);
+ZEND_METHOD(ReflectionMethod, isStatic);
+ZEND_METHOD(ReflectionMethod, isConstructor);
+ZEND_METHOD(ReflectionMethod, isDestructor);
+ZEND_METHOD(ReflectionMethod, getClosure);
+ZEND_METHOD(ReflectionMethod, getModifiers);
+ZEND_METHOD(ReflectionMethod, invoke);
+ZEND_METHOD(ReflectionMethod, invokeArgs);
+ZEND_METHOD(ReflectionMethod, getDeclaringClass);
+ZEND_METHOD(ReflectionMethod, getPrototype);
+ZEND_METHOD(ReflectionMethod, setAccessible);
+ZEND_METHOD(ReflectionClass, __construct);
+ZEND_METHOD(ReflectionClass, __toString);
+ZEND_METHOD(ReflectionClass, getName);
+ZEND_METHOD(ReflectionClass, isInternal);
+ZEND_METHOD(ReflectionClass, isUserDefined);
+ZEND_METHOD(ReflectionClass, isAnonymous);
+ZEND_METHOD(ReflectionClass, isInstantiable);
+ZEND_METHOD(ReflectionClass, isCloneable);
+ZEND_METHOD(ReflectionClass, getFileName);
+ZEND_METHOD(ReflectionClass, getStartLine);
+ZEND_METHOD(ReflectionClass, getEndLine);
+ZEND_METHOD(ReflectionClass, getDocComment);
+ZEND_METHOD(ReflectionClass, getConstructor);
+ZEND_METHOD(ReflectionClass, hasMethod);
+ZEND_METHOD(ReflectionClass, getMethod);
+ZEND_METHOD(ReflectionClass, getMethods);
+ZEND_METHOD(ReflectionClass, hasProperty);
+ZEND_METHOD(ReflectionClass, getProperty);
+ZEND_METHOD(ReflectionClass, getProperties);
+ZEND_METHOD(ReflectionClass, hasConstant);
+ZEND_METHOD(ReflectionClass, getConstants);
+ZEND_METHOD(ReflectionClass, getReflectionConstants);
+ZEND_METHOD(ReflectionClass, getConstant);
+ZEND_METHOD(ReflectionClass, getReflectionConstant);
+ZEND_METHOD(ReflectionClass, getInterfaces);
+ZEND_METHOD(ReflectionClass, getInterfaceNames);
+ZEND_METHOD(ReflectionClass, isInterface);
+ZEND_METHOD(ReflectionClass, getTraits);
+ZEND_METHOD(ReflectionClass, getTraitNames);
+ZEND_METHOD(ReflectionClass, getTraitAliases);
+ZEND_METHOD(ReflectionClass, isTrait);
+ZEND_METHOD(ReflectionClass, isAbstract);
+ZEND_METHOD(ReflectionClass, isFinal);
+ZEND_METHOD(ReflectionClass, getModifiers);
+ZEND_METHOD(ReflectionClass, isInstance);
+ZEND_METHOD(ReflectionClass, newInstance);
+ZEND_METHOD(ReflectionClass, newInstanceWithoutConstructor);
+ZEND_METHOD(ReflectionClass, newInstanceArgs);
+ZEND_METHOD(ReflectionClass, getParentClass);
+ZEND_METHOD(ReflectionClass, isSubclassOf);
+ZEND_METHOD(ReflectionClass, getStaticProperties);
+ZEND_METHOD(ReflectionClass, getStaticPropertyValue);
+ZEND_METHOD(ReflectionClass, setStaticPropertyValue);
+ZEND_METHOD(ReflectionClass, getDefaultProperties);
+ZEND_METHOD(ReflectionClass, isIterable);
+ZEND_METHOD(ReflectionClass, implementsInterface);
+ZEND_METHOD(ReflectionClass, getExtension);
+ZEND_METHOD(ReflectionClass, getExtensionName);
+ZEND_METHOD(ReflectionClass, inNamespace);
+ZEND_METHOD(ReflectionClass, getNamespaceName);
+ZEND_METHOD(ReflectionClass, getShortName);
+ZEND_METHOD(ReflectionObject, __construct);
+ZEND_METHOD(ReflectionProperty, __construct);
+ZEND_METHOD(ReflectionProperty, __toString);
+ZEND_METHOD(ReflectionProperty, getName);
+ZEND_METHOD(ReflectionProperty, getValue);
+ZEND_METHOD(ReflectionProperty, setValue);
+ZEND_METHOD(ReflectionProperty, isInitialized);
+ZEND_METHOD(ReflectionProperty, isPublic);
+ZEND_METHOD(ReflectionProperty, isPrivate);
+ZEND_METHOD(ReflectionProperty, isProtected);
+ZEND_METHOD(ReflectionProperty, isStatic);
+ZEND_METHOD(ReflectionProperty, isDefault);
+ZEND_METHOD(ReflectionProperty, getModifiers);
+ZEND_METHOD(ReflectionProperty, getDeclaringClass);
+ZEND_METHOD(ReflectionProperty, getDocComment);
+ZEND_METHOD(ReflectionProperty, setAccessible);
+ZEND_METHOD(ReflectionProperty, getType);
+ZEND_METHOD(ReflectionProperty, hasType);
+ZEND_METHOD(ReflectionProperty, hasDefaultValue);
+ZEND_METHOD(ReflectionProperty, getDefaultValue);
+ZEND_METHOD(ReflectionClassConstant, __construct);
+ZEND_METHOD(ReflectionClassConstant, __toString);
+ZEND_METHOD(ReflectionClassConstant, getName);
+ZEND_METHOD(ReflectionClassConstant, getValue);
+ZEND_METHOD(ReflectionClassConstant, isPublic);
+ZEND_METHOD(ReflectionClassConstant, isPrivate);
+ZEND_METHOD(ReflectionClassConstant, isProtected);
+ZEND_METHOD(ReflectionClassConstant, getModifiers);
+ZEND_METHOD(ReflectionClassConstant, getDeclaringClass);
+ZEND_METHOD(ReflectionClassConstant, getDocComment);
+ZEND_METHOD(ReflectionParameter, __construct);
+ZEND_METHOD(ReflectionParameter, __toString);
+ZEND_METHOD(ReflectionParameter, getName);
+ZEND_METHOD(ReflectionParameter, isPassedByReference);
+ZEND_METHOD(ReflectionParameter, canBePassedByValue);
+ZEND_METHOD(ReflectionParameter, getDeclaringFunction);
+ZEND_METHOD(ReflectionParameter, getDeclaringClass);
+ZEND_METHOD(ReflectionParameter, getClass);
+ZEND_METHOD(ReflectionParameter, hasType);
+ZEND_METHOD(ReflectionParameter, getType);
+ZEND_METHOD(ReflectionParameter, isArray);
+ZEND_METHOD(ReflectionParameter, isCallable);
+ZEND_METHOD(ReflectionParameter, allowsNull);
+ZEND_METHOD(ReflectionParameter, getPosition);
+ZEND_METHOD(ReflectionParameter, isOptional);
+ZEND_METHOD(ReflectionParameter, isDefaultValueAvailable);
+ZEND_METHOD(ReflectionParameter, getDefaultValue);
+ZEND_METHOD(ReflectionParameter, isDefaultValueConstant);
+ZEND_METHOD(ReflectionParameter, getDefaultValueConstantName);
+ZEND_METHOD(ReflectionParameter, isVariadic);
+ZEND_METHOD(ReflectionType, allowsNull);
+ZEND_METHOD(ReflectionType, __toString);
+ZEND_METHOD(ReflectionNamedType, getName);
+ZEND_METHOD(ReflectionNamedType, isBuiltin);
+ZEND_METHOD(ReflectionUnionType, getTypes);
+ZEND_METHOD(ReflectionExtension, __construct);
+ZEND_METHOD(ReflectionExtension, __toString);
+ZEND_METHOD(ReflectionExtension, getName);
+ZEND_METHOD(ReflectionExtension, getVersion);
+ZEND_METHOD(ReflectionExtension, getFunctions);
+ZEND_METHOD(ReflectionExtension, getConstants);
+ZEND_METHOD(ReflectionExtension, getINIEntries);
+ZEND_METHOD(ReflectionExtension, getClasses);
+ZEND_METHOD(ReflectionExtension, getClassNames);
+ZEND_METHOD(ReflectionExtension, getDependencies);
+ZEND_METHOD(ReflectionExtension, info);
+ZEND_METHOD(ReflectionExtension, isPersistent);
+ZEND_METHOD(ReflectionExtension, isTemporary);
+ZEND_METHOD(ReflectionZendExtension, __construct);
+ZEND_METHOD(ReflectionZendExtension, __toString);
+ZEND_METHOD(ReflectionZendExtension, getName);
+ZEND_METHOD(ReflectionZendExtension, getVersion);
+ZEND_METHOD(ReflectionZendExtension, getAuthor);
+ZEND_METHOD(ReflectionZendExtension, getURL);
+ZEND_METHOD(ReflectionZendExtension, getCopyright);
+ZEND_METHOD(ReflectionReference, fromArrayElement);
+ZEND_METHOD(ReflectionReference, getId);
+ZEND_METHOD(ReflectionReference, __construct);
+
+
+static const zend_function_entry class_ReflectionException_methods[] = {
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_Reflection_methods[] = {
+ ZEND_ME(Reflection, getModifierNames, arginfo_class_Reflection_getModifierNames, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_Reflector_methods[] = {
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_ReflectionFunctionAbstract_methods[] = {
+ ZEND_MALIAS(ReflectionClass, __clone, __clone, arginfo_class_ReflectionFunctionAbstract___clone, ZEND_ACC_PRIVATE|ZEND_ACC_FINAL)
+ ZEND_ME(ReflectionFunctionAbstract, inNamespace, arginfo_class_ReflectionFunctionAbstract_inNamespace, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionFunctionAbstract, isClosure, arginfo_class_ReflectionFunctionAbstract_isClosure, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionFunctionAbstract, isDeprecated, arginfo_class_ReflectionFunctionAbstract_isDeprecated, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionFunctionAbstract, isInternal, arginfo_class_ReflectionFunctionAbstract_isInternal, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionFunctionAbstract, isUserDefined, arginfo_class_ReflectionFunctionAbstract_isUserDefined, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionFunctionAbstract, isGenerator, arginfo_class_ReflectionFunctionAbstract_isGenerator, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionFunctionAbstract, isVariadic, arginfo_class_ReflectionFunctionAbstract_isVariadic, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionFunctionAbstract, getClosureThis, arginfo_class_ReflectionFunctionAbstract_getClosureThis, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionFunctionAbstract, getClosureScopeClass, arginfo_class_ReflectionFunctionAbstract_getClosureScopeClass, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionFunctionAbstract, getDocComment, arginfo_class_ReflectionFunctionAbstract_getDocComment, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionFunctionAbstract, getEndLine, arginfo_class_ReflectionFunctionAbstract_getEndLine, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionFunctionAbstract, getExtension, arginfo_class_ReflectionFunctionAbstract_getExtension, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionFunctionAbstract, getExtensionName, arginfo_class_ReflectionFunctionAbstract_getExtensionName, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionFunctionAbstract, getFileName, arginfo_class_ReflectionFunctionAbstract_getFileName, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionFunctionAbstract, getName, arginfo_class_ReflectionFunctionAbstract_getName, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionFunctionAbstract, getNamespaceName, arginfo_class_ReflectionFunctionAbstract_getNamespaceName, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionFunctionAbstract, getNumberOfParameters, arginfo_class_ReflectionFunctionAbstract_getNumberOfParameters, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionFunctionAbstract, getNumberOfRequiredParameters, arginfo_class_ReflectionFunctionAbstract_getNumberOfRequiredParameters, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionFunctionAbstract, getParameters, arginfo_class_ReflectionFunctionAbstract_getParameters, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionFunctionAbstract, getShortName, arginfo_class_ReflectionFunctionAbstract_getShortName, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionFunctionAbstract, getStartLine, arginfo_class_ReflectionFunctionAbstract_getStartLine, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionFunctionAbstract, getStaticVariables, arginfo_class_ReflectionFunctionAbstract_getStaticVariables, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionFunctionAbstract, returnsReference, arginfo_class_ReflectionFunctionAbstract_returnsReference, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionFunctionAbstract, hasReturnType, arginfo_class_ReflectionFunctionAbstract_hasReturnType, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionFunctionAbstract, getReturnType, arginfo_class_ReflectionFunctionAbstract_getReturnType, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_ReflectionFunction_methods[] = {
+ ZEND_ME(ReflectionFunction, __construct, arginfo_class_ReflectionFunction___construct, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionFunction, __toString, arginfo_class_ReflectionFunction___toString, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionFunction, isDisabled, arginfo_class_ReflectionFunction_isDisabled, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionFunction, invoke, arginfo_class_ReflectionFunction_invoke, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionFunction, invokeArgs, arginfo_class_ReflectionFunction_invokeArgs, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionFunction, getClosure, arginfo_class_ReflectionFunction_getClosure, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_ReflectionGenerator_methods[] = {
+ ZEND_ME(ReflectionGenerator, __construct, arginfo_class_ReflectionGenerator___construct, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionGenerator, getExecutingLine, arginfo_class_ReflectionGenerator_getExecutingLine, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionGenerator, getExecutingFile, arginfo_class_ReflectionGenerator_getExecutingFile, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionGenerator, getTrace, arginfo_class_ReflectionGenerator_getTrace, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionGenerator, getFunction, arginfo_class_ReflectionGenerator_getFunction, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionGenerator, getThis, arginfo_class_ReflectionGenerator_getThis, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionGenerator, getExecutingGenerator, arginfo_class_ReflectionGenerator_getExecutingGenerator, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_ReflectionMethod_methods[] = {
+ ZEND_ME(ReflectionMethod, __construct, arginfo_class_ReflectionMethod___construct, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionMethod, __toString, arginfo_class_ReflectionMethod___toString, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionMethod, isPublic, arginfo_class_ReflectionMethod_isPublic, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionMethod, isPrivate, arginfo_class_ReflectionMethod_isPrivate, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionMethod, isProtected, arginfo_class_ReflectionMethod_isProtected, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionMethod, isAbstract, arginfo_class_ReflectionMethod_isAbstract, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionMethod, isFinal, arginfo_class_ReflectionMethod_isFinal, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionMethod, isStatic, arginfo_class_ReflectionMethod_isStatic, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionMethod, isConstructor, arginfo_class_ReflectionMethod_isConstructor, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionMethod, isDestructor, arginfo_class_ReflectionMethod_isDestructor, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionMethod, getClosure, arginfo_class_ReflectionMethod_getClosure, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionMethod, getModifiers, arginfo_class_ReflectionMethod_getModifiers, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionMethod, invoke, arginfo_class_ReflectionMethod_invoke, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionMethod, invokeArgs, arginfo_class_ReflectionMethod_invokeArgs, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionMethod, getDeclaringClass, arginfo_class_ReflectionMethod_getDeclaringClass, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionMethod, getPrototype, arginfo_class_ReflectionMethod_getPrototype, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionMethod, setAccessible, arginfo_class_ReflectionMethod_setAccessible, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_ReflectionClass_methods[] = {
+ ZEND_ME(ReflectionClass, __clone, arginfo_class_ReflectionClass___clone, ZEND_ACC_PRIVATE|ZEND_ACC_FINAL)
+ ZEND_ME(ReflectionClass, __construct, arginfo_class_ReflectionClass___construct, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, __toString, arginfo_class_ReflectionClass___toString, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, getName, arginfo_class_ReflectionClass_getName, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, isInternal, arginfo_class_ReflectionClass_isInternal, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, isUserDefined, arginfo_class_ReflectionClass_isUserDefined, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, isAnonymous, arginfo_class_ReflectionClass_isAnonymous, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, isInstantiable, arginfo_class_ReflectionClass_isInstantiable, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, isCloneable, arginfo_class_ReflectionClass_isCloneable, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, getFileName, arginfo_class_ReflectionClass_getFileName, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, getStartLine, arginfo_class_ReflectionClass_getStartLine, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, getEndLine, arginfo_class_ReflectionClass_getEndLine, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, getDocComment, arginfo_class_ReflectionClass_getDocComment, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, getConstructor, arginfo_class_ReflectionClass_getConstructor, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, hasMethod, arginfo_class_ReflectionClass_hasMethod, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, getMethod, arginfo_class_ReflectionClass_getMethod, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, getMethods, arginfo_class_ReflectionClass_getMethods, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, hasProperty, arginfo_class_ReflectionClass_hasProperty, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, getProperty, arginfo_class_ReflectionClass_getProperty, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, getProperties, arginfo_class_ReflectionClass_getProperties, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, hasConstant, arginfo_class_ReflectionClass_hasConstant, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, getConstants, arginfo_class_ReflectionClass_getConstants, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, getReflectionConstants, arginfo_class_ReflectionClass_getReflectionConstants, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, getConstant, arginfo_class_ReflectionClass_getConstant, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, getReflectionConstant, arginfo_class_ReflectionClass_getReflectionConstant, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, getInterfaces, arginfo_class_ReflectionClass_getInterfaces, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, getInterfaceNames, arginfo_class_ReflectionClass_getInterfaceNames, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, isInterface, arginfo_class_ReflectionClass_isInterface, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, getTraits, arginfo_class_ReflectionClass_getTraits, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, getTraitNames, arginfo_class_ReflectionClass_getTraitNames, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, getTraitAliases, arginfo_class_ReflectionClass_getTraitAliases, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, isTrait, arginfo_class_ReflectionClass_isTrait, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, isAbstract, arginfo_class_ReflectionClass_isAbstract, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, isFinal, arginfo_class_ReflectionClass_isFinal, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, getModifiers, arginfo_class_ReflectionClass_getModifiers, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, isInstance, arginfo_class_ReflectionClass_isInstance, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, newInstance, arginfo_class_ReflectionClass_newInstance, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, newInstanceWithoutConstructor, arginfo_class_ReflectionClass_newInstanceWithoutConstructor, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, newInstanceArgs, arginfo_class_ReflectionClass_newInstanceArgs, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, getParentClass, arginfo_class_ReflectionClass_getParentClass, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, isSubclassOf, arginfo_class_ReflectionClass_isSubclassOf, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, getStaticProperties, arginfo_class_ReflectionClass_getStaticProperties, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, getStaticPropertyValue, arginfo_class_ReflectionClass_getStaticPropertyValue, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, setStaticPropertyValue, arginfo_class_ReflectionClass_setStaticPropertyValue, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, getDefaultProperties, arginfo_class_ReflectionClass_getDefaultProperties, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, isIterable, arginfo_class_ReflectionClass_isIterable, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(ReflectionClass, isIterateable, isIterable, arginfo_class_ReflectionClass_isIterateable, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, implementsInterface, arginfo_class_ReflectionClass_implementsInterface, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, getExtension, arginfo_class_ReflectionClass_getExtension, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, getExtensionName, arginfo_class_ReflectionClass_getExtensionName, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, inNamespace, arginfo_class_ReflectionClass_inNamespace, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, getNamespaceName, arginfo_class_ReflectionClass_getNamespaceName, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClass, getShortName, arginfo_class_ReflectionClass_getShortName, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_ReflectionObject_methods[] = {
+ ZEND_ME(ReflectionObject, __construct, arginfo_class_ReflectionObject___construct, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_ReflectionProperty_methods[] = {
+ ZEND_MALIAS(ReflectionClass, __clone, __clone, arginfo_class_ReflectionProperty___clone, ZEND_ACC_PRIVATE|ZEND_ACC_FINAL)
+ ZEND_ME(ReflectionProperty, __construct, arginfo_class_ReflectionProperty___construct, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionProperty, __toString, arginfo_class_ReflectionProperty___toString, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionProperty, getName, arginfo_class_ReflectionProperty_getName, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionProperty, getValue, arginfo_class_ReflectionProperty_getValue, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionProperty, setValue, arginfo_class_ReflectionProperty_setValue, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionProperty, isInitialized, arginfo_class_ReflectionProperty_isInitialized, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionProperty, isPublic, arginfo_class_ReflectionProperty_isPublic, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionProperty, isPrivate, arginfo_class_ReflectionProperty_isPrivate, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionProperty, isProtected, arginfo_class_ReflectionProperty_isProtected, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionProperty, isStatic, arginfo_class_ReflectionProperty_isStatic, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionProperty, isDefault, arginfo_class_ReflectionProperty_isDefault, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionProperty, getModifiers, arginfo_class_ReflectionProperty_getModifiers, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionProperty, getDeclaringClass, arginfo_class_ReflectionProperty_getDeclaringClass, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionProperty, getDocComment, arginfo_class_ReflectionProperty_getDocComment, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionProperty, setAccessible, arginfo_class_ReflectionProperty_setAccessible, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionProperty, getType, arginfo_class_ReflectionProperty_getType, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionProperty, hasType, arginfo_class_ReflectionProperty_hasType, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionProperty, hasDefaultValue, arginfo_class_ReflectionProperty_hasDefaultValue, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionProperty, getDefaultValue, arginfo_class_ReflectionProperty_getDefaultValue, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_ReflectionClassConstant_methods[] = {
+ ZEND_MALIAS(ReflectionClass, __clone, __clone, arginfo_class_ReflectionClassConstant___clone, ZEND_ACC_PRIVATE|ZEND_ACC_FINAL)
+ ZEND_ME(ReflectionClassConstant, __construct, arginfo_class_ReflectionClassConstant___construct, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClassConstant, __toString, arginfo_class_ReflectionClassConstant___toString, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClassConstant, getName, arginfo_class_ReflectionClassConstant_getName, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClassConstant, getValue, arginfo_class_ReflectionClassConstant_getValue, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClassConstant, isPublic, arginfo_class_ReflectionClassConstant_isPublic, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClassConstant, isPrivate, arginfo_class_ReflectionClassConstant_isPrivate, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClassConstant, isProtected, arginfo_class_ReflectionClassConstant_isProtected, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClassConstant, getModifiers, arginfo_class_ReflectionClassConstant_getModifiers, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClassConstant, getDeclaringClass, arginfo_class_ReflectionClassConstant_getDeclaringClass, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionClassConstant, getDocComment, arginfo_class_ReflectionClassConstant_getDocComment, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_ReflectionParameter_methods[] = {
+ ZEND_MALIAS(ReflectionClass, __clone, __clone, arginfo_class_ReflectionParameter___clone, ZEND_ACC_PRIVATE|ZEND_ACC_FINAL)
+ ZEND_ME(ReflectionParameter, __construct, arginfo_class_ReflectionParameter___construct, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionParameter, __toString, arginfo_class_ReflectionParameter___toString, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionParameter, getName, arginfo_class_ReflectionParameter_getName, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionParameter, isPassedByReference, arginfo_class_ReflectionParameter_isPassedByReference, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionParameter, canBePassedByValue, arginfo_class_ReflectionParameter_canBePassedByValue, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionParameter, getDeclaringFunction, arginfo_class_ReflectionParameter_getDeclaringFunction, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionParameter, getDeclaringClass, arginfo_class_ReflectionParameter_getDeclaringClass, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionParameter, getClass, arginfo_class_ReflectionParameter_getClass, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionParameter, hasType, arginfo_class_ReflectionParameter_hasType, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionParameter, getType, arginfo_class_ReflectionParameter_getType, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionParameter, isArray, arginfo_class_ReflectionParameter_isArray, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionParameter, isCallable, arginfo_class_ReflectionParameter_isCallable, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionParameter, allowsNull, arginfo_class_ReflectionParameter_allowsNull, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionParameter, getPosition, arginfo_class_ReflectionParameter_getPosition, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionParameter, isOptional, arginfo_class_ReflectionParameter_isOptional, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionParameter, isDefaultValueAvailable, arginfo_class_ReflectionParameter_isDefaultValueAvailable, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionParameter, getDefaultValue, arginfo_class_ReflectionParameter_getDefaultValue, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionParameter, isDefaultValueConstant, arginfo_class_ReflectionParameter_isDefaultValueConstant, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionParameter, getDefaultValueConstantName, arginfo_class_ReflectionParameter_getDefaultValueConstantName, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionParameter, isVariadic, arginfo_class_ReflectionParameter_isVariadic, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_ReflectionType_methods[] = {
+ ZEND_MALIAS(ReflectionClass, __clone, __clone, arginfo_class_ReflectionType___clone, ZEND_ACC_PRIVATE|ZEND_ACC_FINAL)
+ ZEND_ME(ReflectionType, allowsNull, arginfo_class_ReflectionType_allowsNull, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionType, __toString, arginfo_class_ReflectionType___toString, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_ReflectionNamedType_methods[] = {
+ ZEND_ME(ReflectionNamedType, getName, arginfo_class_ReflectionNamedType_getName, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionNamedType, isBuiltin, arginfo_class_ReflectionNamedType_isBuiltin, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_ReflectionUnionType_methods[] = {
+ ZEND_ME(ReflectionUnionType, getTypes, arginfo_class_ReflectionUnionType_getTypes, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_ReflectionExtension_methods[] = {
+ ZEND_MALIAS(ReflectionClass, __clone, __clone, arginfo_class_ReflectionExtension___clone, ZEND_ACC_PRIVATE|ZEND_ACC_FINAL)
+ ZEND_ME(ReflectionExtension, __construct, arginfo_class_ReflectionExtension___construct, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionExtension, __toString, arginfo_class_ReflectionExtension___toString, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionExtension, getName, arginfo_class_ReflectionExtension_getName, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionExtension, getVersion, arginfo_class_ReflectionExtension_getVersion, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionExtension, getFunctions, arginfo_class_ReflectionExtension_getFunctions, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionExtension, getConstants, arginfo_class_ReflectionExtension_getConstants, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionExtension, getINIEntries, arginfo_class_ReflectionExtension_getINIEntries, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionExtension, getClasses, arginfo_class_ReflectionExtension_getClasses, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionExtension, getClassNames, arginfo_class_ReflectionExtension_getClassNames, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionExtension, getDependencies, arginfo_class_ReflectionExtension_getDependencies, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionExtension, info, arginfo_class_ReflectionExtension_info, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionExtension, isPersistent, arginfo_class_ReflectionExtension_isPersistent, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionExtension, isTemporary, arginfo_class_ReflectionExtension_isTemporary, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_ReflectionZendExtension_methods[] = {
+ ZEND_MALIAS(ReflectionClass, __clone, __clone, arginfo_class_ReflectionZendExtension___clone, ZEND_ACC_PRIVATE|ZEND_ACC_FINAL)
+ ZEND_ME(ReflectionZendExtension, __construct, arginfo_class_ReflectionZendExtension___construct, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionZendExtension, __toString, arginfo_class_ReflectionZendExtension___toString, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionZendExtension, getName, arginfo_class_ReflectionZendExtension_getName, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionZendExtension, getVersion, arginfo_class_ReflectionZendExtension_getVersion, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionZendExtension, getAuthor, arginfo_class_ReflectionZendExtension_getAuthor, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionZendExtension, getURL, arginfo_class_ReflectionZendExtension_getURL, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionZendExtension, getCopyright, arginfo_class_ReflectionZendExtension_getCopyright, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_ReflectionReference_methods[] = {
+ ZEND_ME(ReflectionReference, fromArrayElement, arginfo_class_ReflectionReference_fromArrayElement, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
+ ZEND_ME(ReflectionReference, getId, arginfo_class_ReflectionReference_getId, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(ReflectionClass, __clone, __clone, arginfo_class_ReflectionReference___clone, ZEND_ACC_PRIVATE)
+ ZEND_ME(ReflectionReference, __construct, arginfo_class_ReflectionReference___construct, ZEND_ACC_PRIVATE)
+ ZEND_FE_END
+};
projects / php / commitdiff