#ifdef HAVE_CONFIG_H

#include "config.h"

#include "php.h"

#include "php_ini.h"

#include "php_reflection.h"

#include "ext/standard/info.h"

#include "ext/standard/sha1.h"

#include "ext/random/php_random.h"

#include "zend.h"

#include "zend_API.h"

#include "zend_ast.h"

#include "zend_attributes.h"

#include "zend_exceptions.h"

#include "zend_operators.h"

#include "zend_constants.h"

#include "zend_ini.h"

#include "zend_interfaces.h"

#include "zend_closures.h"

#include "zend_generators.h"

#include "zend_extensions.h"

#include "zend_builtin_functions.h"

#include "zend_smart_str.h"

#include "zend_enum.h"

#include "zend_fibers.h"

#define REFLECTION_ATTRIBUTE_IS_INSTANCEOF (1 << 1)

#include "php_reflection_arginfo.h"

#define REFLECTION_KEY_LEN 16

ZEND_BEGIN_MODULE_GLOBALS(reflection)

bool key_initialized;

unsigned char key[REFLECTION_KEY_LEN];

ZEND_END_MODULE_GLOBALS(reflection)

ZEND_DECLARE_MODULE_GLOBALS(reflection)

#define REFLECTION_G(v) ZEND_MODULE_GLOBALS_ACCESSOR(reflection, v)

static zend_always_inline zval *reflection_prop_name(zval *object) {

/* $name is always in the first property slot. */

ZEND_ASSERT(Z_OBJCE_P(object)->default_properties_count >= 1);

return &Z_OBJ_P(object)->properties_table[0];

}

static zend_always_inline zval *reflection_prop_class(zval *object) {

/* $class is always in the second property slot. */

ZEND_ASSERT(Z_OBJCE_P(object)->default_properties_count >= 2);

return &Z_OBJ_P(object)->properties_table[1];

}

PHPAPI zend_class_entry *reflector_ptr;

PHPAPI zend_class_entry *reflection_exception_ptr;

PHPAPI zend_class_entry *reflection_ptr;

PHPAPI zend_class_entry *reflection_function_abstract_ptr;

PHPAPI zend_class_entry *reflection_function_ptr;

PHPAPI zend_class_entry *reflection_generator_ptr;

PHPAPI zend_class_entry *reflection_parameter_ptr;

PHPAPI zend_class_entry *reflection_type_ptr;

PHPAPI zend_class_entry *reflection_named_type_ptr;

PHPAPI zend_class_entry *reflection_intersection_type_ptr;

PHPAPI zend_class_entry *reflection_union_type_ptr;

PHPAPI zend_class_entry *reflection_class_ptr;

PHPAPI zend_class_entry *reflection_object_ptr;

PHPAPI zend_class_entry *reflection_method_ptr;

PHPAPI zend_class_entry *reflection_property_ptr;

PHPAPI zend_class_entry *reflection_class_constant_ptr;

PHPAPI zend_class_entry *reflection_extension_ptr;

PHPAPI zend_class_entry *reflection_zend_extension_ptr;

PHPAPI zend_class_entry *reflection_reference_ptr;

PHPAPI zend_class_entry *reflection_attribute_ptr;

PHPAPI zend_class_entry *reflection_enum_ptr;

PHPAPI zend_class_entry *reflection_enum_unit_case_ptr;

PHPAPI zend_class_entry *reflection_enum_backed_case_ptr;

PHPAPI zend_class_entry *reflection_fiber_ptr;

#define _DO_THROW(msg) \

zend_throw_exception(reflection_exception_ptr, msg, 0);

#define GET_REFLECTION_OBJECT() do { \

intern = Z_REFLECTION_P(ZEND_THIS); \

if (intern->ptr == NULL) { \

if (EG(exception) && EG(exception)->ce == reflection_exception_ptr) { \

RETURN_THROWS(); \

} \

zend_throw_error(NULL, "Internal error: Failed to retrieve the reflection object"); \

RETURN_THROWS(); \

} \

} while (0)

#define GET_REFLECTION_OBJECT_PTR(target) do { \

GET_REFLECTION_OBJECT(); \

target = intern->ptr; \

} while (0)

typedef struct _property_reference {

zend_property_info *prop;

zend_string *unmangled_name;

} property_reference;

typedef struct _parameter_reference {

} parameter_reference;

typedef struct _type_reference {

} type_reference;

typedef struct _attribute_reference {

} attribute_reference;

typedef enum {

REF_TYPE_OTHER, /* Must be 0 */

REF_TYPE_FUNCTION,

REF_TYPE_GENERATOR,

REF_TYPE_FIBER,

REF_TYPE_PARAMETER,

REF_TYPE_TYPE,

REF_TYPE_PROPERTY,

REF_TYPE_CLASS_CONSTANT,

REF_TYPE_ATTRIBUTE

} reflection_type_t;

typedef struct {

zval obj;

void *ptr;

zend_class_entry *ce;

reflection_type_t ref_type;

zend_object zo;

} reflection_object;

static inline reflection_object *reflection_object_from_obj(zend_object *obj) {

return (reflection_object*)((char*)(obj) - XtOffsetOf(reflection_object, zo));

}

#define Z_REFLECTION_P(zv) reflection_object_from_obj(Z_OBJ_P((zv)))

static zend_object_handlers reflection_object_handlers;

static zend_always_inline uint32_t prop_get_flags(property_reference *ref) {

return ref->prop ? ref->prop->flags : ZEND_ACC_PUBLIC;

}

static inline bool is_closure_invoke(zend_class_entry *ce, zend_string *lcname) {

return ce == zend_ce_closure

&& zend_string_equals_literal(lcname, ZEND_INVOKE_FUNC_NAME);

}

static zend_function *_copy_function(zend_function *fptr) /* {{{ */

{

if (fptr

&& (fptr->internal_function.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE))

{

zend_function *copy_fptr;

copy_fptr = emalloc(sizeof(zend_function));

memcpy(copy_fptr, fptr, sizeof(zend_function));

copy_fptr->internal_function.function_name = zend_string_copy(fptr->internal_function.function_name);

return copy_fptr;

} else {

/* no copy needed */

return fptr;

}

}

static void _free_function(zend_function *fptr) /* {{{ */

{

if (fptr

&& (fptr->internal_function.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE))

{

zend_string_release_ex(fptr->internal_function.function_name, 0);

zend_free_trampoline(fptr);

}

}

static void reflection_free_objects_storage(zend_object *object) /* {{{ */

{

reflection_object *intern = reflection_object_from_obj(object);

parameter_reference *reference;

property_reference *prop_reference;

if (intern->ptr) {

switch (intern->ref_type) {

case REF_TYPE_PARAMETER:

reference = (parameter_reference*)intern->ptr;

_free_function(reference->fptr);

efree(intern->ptr);

break;

case REF_TYPE_TYPE:

{

type_reference *type_ref = intern->ptr;

if (ZEND_TYPE_HAS_NAME(type_ref->type)) {

zend_string_release(ZEND_TYPE_NAME(type_ref->type));

}

efree(type_ref);

break;

}

case REF_TYPE_FUNCTION:

_free_function(intern->ptr);

break;

case REF_TYPE_PROPERTY:

prop_reference = (property_reference*)intern->ptr;

zend_string_release_ex(prop_reference->unmangled_name, 0);

efree(intern->ptr);

break;

case REF_TYPE_ATTRIBUTE: {

attribute_reference *attr_ref = intern->ptr;

if (attr_ref->filename) {

zend_string_release(attr_ref->filename);

}

efree(intern->ptr);

break;

}

case REF_TYPE_GENERATOR:

case REF_TYPE_FIBER:

case REF_TYPE_CLASS_CONSTANT:

case REF_TYPE_OTHER:

break;

}

}

intern->ptr = NULL;

zval_ptr_dtor(&intern->obj);

zend_object_std_dtor(object);

}

static HashTable *reflection_get_gc(zend_object *obj, zval **gc_data, int *gc_data_count) /* {{{ */

{

reflection_object *intern = reflection_object_from_obj(obj);

*gc_data = &intern->obj;

*gc_data_count = 1;

return zend_std_get_properties(obj);

}

static zend_object *reflection_objects_new(zend_class_entry *class_type) /* {{{ */

{

reflection_object *intern = zend_object_alloc(sizeof(reflection_object), class_type);

zend_object_std_init(&intern->zo, class_type);

object_properties_init(&intern->zo, class_type);

return &intern->zo;

}

static zval *reflection_instantiate(zend_class_entry *pce, zval *object) /* {{{ */

{

object_init_ex(object, pce);

return object;

}

static void _const_string(smart_str *str, char *name, zval *value, char *indent);

static void _function_string(smart_str *str, zend_function *fptr, zend_class_entry *scope, char* indent);

static void _property_string(smart_str *str, zend_property_info *prop, const char *prop_name, char* indent);

static void _class_const_string(smart_str *str, zend_string *name, zend_class_constant *c, char* indent);

static void _class_string(smart_str *str, zend_class_entry *ce, zval *obj, char *indent);

static void _extension_string(smart_str *str, zend_module_entry *module, char *indent);

static void _zend_extension_string(smart_str *str, zend_extension *extension, char *indent);

static void _class_string(smart_str *str, zend_class_entry *ce, zval *obj, char *indent)

{

int count, count_static_props = 0, count_static_funcs = 0, count_shadow_props = 0;

zend_string *sub_indent = strpprintf(0, "%s ", indent);

/* TBD: Repair indenting of doc comment (or is this to be done in the parser?) */

if (ce->type == ZEND_USER_CLASS && ce->info.user.doc_comment) {

smart_str_append_printf(str, "%s%s", indent, ZSTR_VAL(ce->info.user.doc_comment));

smart_str_appendc(str, '\n');

}

if (obj && Z_TYPE_P(obj) == IS_OBJECT) {

smart_str_append_printf(str, "%sObject of class [ ", indent);

} else {

char *kind = "Class";

if (ce->ce_flags & ZEND_ACC_INTERFACE) {

kind = "Interface";

} else if (ce->ce_flags & ZEND_ACC_TRAIT) {

kind = "Trait";

}

smart_str_append_printf(str, "%s%s [ ", indent, kind);

}

smart_str_append_printf(str, (ce->type == ZEND_USER_CLASS) ? "<user" : "<internal");

if (ce->type == ZEND_INTERNAL_CLASS && ce->info.internal.module) {

smart_str_append_printf(str, ":%s", ce->info.internal.module->name);

}

smart_str_append_printf(str, "> ");

if (ce->get_iterator != NULL) {

smart_str_append_printf(str, "<iterateable> ");

}

if (ce->ce_flags & ZEND_ACC_INTERFACE) {

smart_str_append_printf(str, "interface ");

} else if (ce->ce_flags & ZEND_ACC_TRAIT) {

smart_str_append_printf(str, "trait ");

} else {

if (ce->ce_flags & (ZEND_ACC_IMPLICIT_ABSTRACT_CLASS|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS)) {

smart_str_append_printf(str, "abstract ");

}

if (ce->ce_flags & ZEND_ACC_FINAL) {

smart_str_append_printf(str, "final ");

}

if (ce->ce_flags & ZEND_ACC_READONLY_CLASS) {

smart_str_append_printf(str, "readonly ");

}

smart_str_append_printf(str, "class ");

}

smart_str_append_printf(str, "%s", ZSTR_VAL(ce->name));

if (ce->parent) {

smart_str_append_printf(str, " extends %s", ZSTR_VAL(ce->parent->name));

}

if (ce->num_interfaces) {

uint32_t i;

ZEND_ASSERT(ce->ce_flags & ZEND_ACC_LINKED);

if (ce->ce_flags & ZEND_ACC_INTERFACE) {

smart_str_append_printf(str, " extends %s", ZSTR_VAL(ce->interfaces[0]->name));

} else {

smart_str_append_printf(str, " implements %s", ZSTR_VAL(ce->interfaces[0]->name));

}

for (i = 1; i < ce->num_interfaces; ++i) {

smart_str_append_printf(str, ", %s", ZSTR_VAL(ce->interfaces[i]->name));

}

}

smart_str_append_printf(str, " ] {\n");

/* The information where a class is declared is only available for user classes */

if (ce->type == ZEND_USER_CLASS) {

smart_str_append_printf(str, "%s @@ %s %d-%d\n", indent, ZSTR_VAL(ce->info.user.filename),

ce->info.user.line_start, ce->info.user.line_end);

}

/* Constants */

smart_str_append_printf(str, "\n");

count = zend_hash_num_elements(&ce->constants_table);

smart_str_append_printf(str, "%s - Constants [%d] {\n", indent, count);

if (count > 0) {

zend_string *key;

zend_class_constant *c;

ZEND_HASH_MAP_FOREACH_STR_KEY_PTR(CE_CONSTANTS_TABLE(ce), key, c) {

_class_const_string(str, key, c, ZSTR_VAL(sub_indent));

if (UNEXPECTED(EG(exception))) {

zend_string_release(sub_indent);

return;

}

} ZEND_HASH_FOREACH_END();

}

smart_str_append_printf(str, "%s }\n", indent);

/* Static properties */

/* counting static properties */

count = zend_hash_num_elements(&ce->properties_info);

if (count > 0) {

zend_property_info *prop;

ZEND_HASH_MAP_FOREACH_PTR(&ce->properties_info, prop) {

if ((prop->flags & ZEND_ACC_PRIVATE) && prop->ce != ce) {

count_shadow_props++;

} else if (prop->flags & ZEND_ACC_STATIC) {

count_static_props++;

}

} ZEND_HASH_FOREACH_END();

}

/* static properties */

smart_str_append_printf(str, "\n%s - Static properties [%d] {\n", indent, count_static_props);

if (count_static_props > 0) {

zend_property_info *prop;

ZEND_HASH_MAP_FOREACH_PTR(&ce->properties_info, prop) {

if ((prop->flags & ZEND_ACC_STATIC) && (!(prop->flags & ZEND_ACC_PRIVATE) || prop->ce == ce)) {

_property_string(str, prop, NULL, ZSTR_VAL(sub_indent));

}

} ZEND_HASH_FOREACH_END();

}

smart_str_append_printf(str, "%s }\n", indent);

/* Static methods */

/* counting static methods */

count = zend_hash_num_elements(&ce->function_table);

if (count > 0) {

zend_function *mptr;

ZEND_HASH_MAP_FOREACH_PTR(&ce->function_table, mptr) {

if ((mptr->common.fn_flags & ZEND_ACC_STATIC)

&& ((mptr->common.fn_flags & ZEND_ACC_PRIVATE) == 0 || mptr->common.scope == ce))

{

count_static_funcs++;

}

} ZEND_HASH_FOREACH_END();

}

/* static methods */

smart_str_append_printf(str, "\n%s - Static methods [%d] {", indent, count_static_funcs);

if (count_static_funcs > 0) {

zend_function *mptr;

ZEND_HASH_MAP_FOREACH_PTR(&ce->function_table, mptr) {

if ((mptr->common.fn_flags & ZEND_ACC_STATIC)

&& ((mptr->common.fn_flags & ZEND_ACC_PRIVATE) == 0 || mptr->common.scope == ce))

{

smart_str_append_printf(str, "\n");

_function_string(str, mptr, ce, ZSTR_VAL(sub_indent));

}

} ZEND_HASH_FOREACH_END();

} else {

smart_str_append_printf(str, "\n");

}

smart_str_append_printf(str, "%s }\n", indent);

/* Default/Implicit properties */

count = zend_hash_num_elements(&ce->properties_info) - count_static_props - count_shadow_props;

smart_str_append_printf(str, "\n%s - Properties [%d] {\n", indent, count);

if (count > 0) {

zend_property_info *prop;

ZEND_HASH_MAP_FOREACH_PTR(&ce->properties_info, prop) {

if (!(prop->flags & ZEND_ACC_STATIC)

&& (!(prop->flags & ZEND_ACC_PRIVATE) || prop->ce == ce)) {

_property_string(str, prop, NULL, ZSTR_VAL(sub_indent));

}

} ZEND_HASH_FOREACH_END();

}

smart_str_append_printf(str, "%s }\n", indent);

if (obj && Z_TYPE_P(obj) == IS_OBJECT) {

HashTable *properties = Z_OBJ_HT_P(obj)->get_properties(Z_OBJ_P(obj));

zend_string *prop_name;

smart_str prop_str = {0};

count = 0;

if (properties && zend_hash_num_elements(properties)) {

ZEND_HASH_MAP_FOREACH_STR_KEY(properties, prop_name) {

if (prop_name && ZSTR_LEN(prop_name) && ZSTR_VAL(prop_name)[0]) { /* skip all private and protected properties */

if (!zend_hash_exists(&ce->properties_info, prop_name)) {

count++;

_property_string(&prop_str, NULL, ZSTR_VAL(prop_name), ZSTR_VAL(sub_indent));

}

}

} ZEND_HASH_FOREACH_END();

}

smart_str_append_printf(str, "\n%s - Dynamic properties [%d] {\n", indent, count);

smart_str_append_smart_str(str, &prop_str);

smart_str_append_printf(str, "%s }\n", indent);

smart_str_free(&prop_str);

}

/* Non static methods */

count = zend_hash_num_elements(&ce->function_table) - count_static_funcs;

if (count > 0) {

zend_function *mptr;

smart_str method_str = {0};

count = 0;

ZEND_HASH_MAP_FOREACH_PTR(&ce->function_table, mptr) {

if ((mptr->common.fn_flags & ZEND_ACC_STATIC) == 0

&& ((mptr->common.fn_flags & ZEND_ACC_PRIVATE) == 0 || mptr->common.scope == ce))

{

zend_function *closure;

/* see if this is a closure */

if (obj && is_closure_invoke(ce, mptr->common.function_name)

&& (closure = zend_get_closure_invoke_method(Z_OBJ_P(obj))) != NULL)

{

mptr = closure;

} else {

closure = NULL;

}

smart_str_appendc(&method_str, '\n');

_function_string(&method_str, mptr, ce, ZSTR_VAL(sub_indent));

count++;

_free_function(closure);

}

} ZEND_HASH_FOREACH_END();

smart_str_append_printf(str, "\n%s - Methods [%d] {", indent, count);

smart_str_append_smart_str(str, &method_str);

if (!count) {

smart_str_append_printf(str, "\n");

}

smart_str_free(&method_str);

} else {

smart_str_append_printf(str, "\n%s - Methods [0] {\n", indent);

}

smart_str_append_printf(str, "%s }\n", indent);

smart_str_append_printf(str, "%s}\n", indent);

zend_string_release_ex(sub_indent, 0);

}

static void _const_string(smart_str *str, char *name, zval *value, char *indent)

{

const char *type = zend_zval_type_name(value);

if (Z_TYPE_P(value) == IS_ARRAY) {

smart_str_append_printf(str, "%s Constant [ %s %s ] { Array }\n",

indent, type, name);

} else if (Z_TYPE_P(value) == IS_STRING) {

smart_str_append_printf(str, "%s Constant [ %s %s ] { %s }\n",

indent, type, name, Z_STRVAL_P(value));

} else {

zend_string *tmp_value_str;

zend_string *value_str = zval_get_tmp_string(value, &tmp_value_str);

smart_str_append_printf(str, "%s Constant [ %s %s ] { %s }\n",

indent, type, name, ZSTR_VAL(value_str));

zend_tmp_string_release(tmp_value_str);

}

}

static void _class_const_string(smart_str *str, zend_string *name, zend_class_constant *c, char *indent)

{

if (Z_TYPE(c->value) == IS_CONSTANT_AST && zend_update_class_constant(c, name, c->ce) == FAILURE) {

return;

}

const char *visibility = zend_visibility_string(ZEND_CLASS_CONST_FLAGS(c));

const char *final = ZEND_CLASS_CONST_FLAGS(c) & ZEND_ACC_FINAL ? "final " : "";

zend_string *type_str = ZEND_TYPE_IS_SET(c->type) ? zend_type_to_string(c->type) : NULL;

const char *type = type_str ? ZSTR_VAL(type_str) : zend_zval_type_name(&c->value);

smart_str_append_printf(str, "%sConstant [ %s%s %s %s ] { ",

indent, final, visibility, type, ZSTR_VAL(name));

if (Z_TYPE(c->value) == IS_ARRAY) {

smart_str_appends(str, "Array");

} else if (Z_TYPE(c->value) == IS_OBJECT) {

smart_str_appends(str, "Object");

} else {

zend_string *tmp_value_str;

zend_string *value_str = zval_get_tmp_string(&c->value, &tmp_value_str);

smart_str_append(str, value_str);

zend_tmp_string_release(tmp_value_str);

}

smart_str_appends(str, " }\n");

if (type_str) {

zend_string_release(type_str);

}

}

static zend_op *get_recv_op(zend_op_array *op_array, uint32_t offset)

{

zend_op *op = op_array->opcodes;

zend_op *end = op + op_array->last;

++offset;

while (op < end) {

if ((op->opcode == ZEND_RECV || op->opcode == ZEND_RECV_INIT

|| op->opcode == ZEND_RECV_VARIADIC) && op->op1.num == offset)

{

return op;

}

++op;

}

ZEND_ASSERT(0 && "Failed to find op");

return NULL;

}

static zval *get_default_from_recv(zend_op_array *op_array, uint32_t offset) {

zend_op *recv = get_recv_op(op_array, offset);

if (!recv || recv->opcode != ZEND_RECV_INIT) {

return NULL;

}

return RT_CONSTANT(recv, recv->op2);

}

static int format_default_value(smart_str *str, zval *value) {

if (Z_TYPE_P(value) <= IS_STRING) {

smart_str_append_scalar(str, value, SIZE_MAX);

} else if (Z_TYPE_P(value) == IS_ARRAY) {

zend_string *str_key;

zend_long num_key;

zval *zv;

bool is_list = zend_array_is_list(Z_ARRVAL_P(value));

bool first = true;

smart_str_appendc(str, '[');

ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(value), num_key, str_key, zv) {

if (!first) {

smart_str_appends(str, ", ");

}

first = false;

if (!is_list) {

if (str_key) {

smart_str_appendc(str, '\'');

smart_str_append_escaped(str, ZSTR_VAL(str_key), ZSTR_LEN(str_key));

smart_str_appendc(str, '\'');

} else {

smart_str_append_long(str, num_key);

}

smart_str_appends(str, " => ");

}

format_default_value(str, zv);

} ZEND_HASH_FOREACH_END();

smart_str_appendc(str, ']');

} else if (Z_TYPE_P(value) == IS_OBJECT) {

zend_object *obj = Z_OBJ_P(value);

zend_class_entry *class = obj->ce;

ZEND_ASSERT(class->ce_flags & ZEND_ACC_ENUM);

smart_str_append(str, class->name);

smart_str_appends(str, "::");

smart_str_append(str, Z_STR_P(zend_enum_fetch_case_name(obj)));

} else {

ZEND_ASSERT(Z_TYPE_P(value) == IS_CONSTANT_AST);

zend_string *ast_str = zend_ast_export("", Z_ASTVAL_P(value), "");

smart_str_append(str, ast_str);

zend_string_release(ast_str);

}

return SUCCESS;

}

static inline bool has_internal_arg_info(const zend_function *fptr) {

return fptr->type == ZEND_INTERNAL_FUNCTION

&& !(fptr->common.fn_flags & ZEND_ACC_USER_ARG_INFO);

}

static void _parameter_string(smart_str *str, zend_function *fptr, struct _zend_arg_info *arg_info, uint32_t offset, bool required, char* indent)

{

smart_str_append_printf(str, "Parameter #%d [ ", offset);

if (!required) {

smart_str_append_printf(str, "<optional> ");

} else {

smart_str_append_printf(str, "<required> ");

}

if (ZEND_TYPE_IS_SET(arg_info->type)) {

zend_string *type_str = zend_type_to_string(arg_info->type);

smart_str_append(str, type_str);

smart_str_appendc(str, ' ');

zend_string_release(type_str);

}

if (ZEND_ARG_SEND_MODE(arg_info)) {

smart_str_appendc(str, '&');

}

if (ZEND_ARG_IS_VARIADIC(arg_info)) {

smart_str_appends(str, "...");

}

smart_str_append_printf(str, "$%s", has_internal_arg_info(fptr)

? ((zend_internal_arg_info*)arg_info)->name : ZSTR_VAL(arg_info->name));

if (!required && !ZEND_ARG_IS_VARIADIC(arg_info)) {

if (fptr->type == ZEND_INTERNAL_FUNCTION) {

smart_str_appends(str, " = ");

/* TODO: We don't have a way to fetch the default value for an internal function

if (has_internal_arg_info(fptr)

&& ((zend_internal_arg_info*)arg_info)->default_value) {

smart_str_appends(str, ((zend_internal_arg_info*)arg_info)->default_value);

} else {

smart_str_appends(str, "<default>");

}

} else {

zval *default_value = get_default_from_recv((zend_op_array*)fptr, offset);

if (default_value) {

smart_str_appends(str, " = ");

if (format_default_value(str, default_value) == FAILURE) {

return;

}

}

}

}

smart_str_appends(str, " ]");

}

static void _function_parameter_string(smart_str *str, zend_function *fptr, char* indent)

{

struct _zend_arg_info *arg_info = fptr->common.arg_info;

uint32_t i, num_args, num_required = fptr->common.required_num_args;

if (!arg_info) {

return;

}

num_args = fptr->common.num_args;

if (fptr->common.fn_flags & ZEND_ACC_VARIADIC) {

num_args++;

}

smart_str_appendc(str, '\n');

smart_str_append_printf(str, "%s- Parameters [%d] {\n", indent, num_args);

for (i = 0; i < num_args; i++) {

smart_str_append_printf(str, "%s ", indent);

_parameter_string(str, fptr, arg_info, i, i < num_required, indent);

smart_str_appendc(str, '\n');

arg_info++;

}

smart_str_append_printf(str, "%s}\n", indent);

}

static void _function_closure_string(smart_str *str, zend_function *fptr, char* indent)

{

uint32_t i, count;

zend_string *key;

HashTable *static_variables;

if (fptr->type != ZEND_USER_FUNCTION || !fptr->op_array.static_variables) {

return;

}

static_variables = ZEND_MAP_PTR_GET(fptr->op_array.static_variables_ptr);

count = zend_hash_num_elements(static_variables);

if (!count) {

return;

}

smart_str_append_printf(str, "\n");

smart_str_append_printf(str, "%s- Bound Variables [%d] {\n", indent, zend_hash_num_elements(static_variables));

i = 0;

ZEND_HASH_MAP_FOREACH_STR_KEY(static_variables, key) {

smart_str_append_printf(str, "%s Variable #%d [ $%s ]\n", indent, i++, ZSTR_VAL(key));

} ZEND_HASH_FOREACH_END();

smart_str_append_printf(str, "%s}\n", indent);

}

static void _function_string(smart_str *str, zend_function *fptr, zend_class_entry *scope, char* indent)

{

smart_str param_indent = {0};

zend_function *overwrites;

zend_string *lc_name;

/* TBD: Repair indenting of doc comment (or is this to be done in the parser?)

if (fptr->type == ZEND_USER_FUNCTION && fptr->op_array.doc_comment) {

smart_str_append_printf(str, "%s%s\n", indent, ZSTR_VAL(fptr->op_array.doc_comment));

}

smart_str_appendl(str, indent, strlen(indent));

smart_str_append_printf(str, fptr->common.fn_flags & ZEND_ACC_CLOSURE ? "Closure [ " : (fptr->common.scope ? "Method [ " : "Function [ "));

smart_str_append_printf(str, (fptr->type == ZEND_USER_FUNCTION) ? "<user" : "<internal");

if (fptr->common.fn_flags & ZEND_ACC_DEPRECATED) {

smart_str_appends(str, ", deprecated");

}

if (fptr->type == ZEND_INTERNAL_FUNCTION && ((zend_internal_function*)fptr)->module) {

smart_str_append_printf(str, ":%s", ((zend_internal_function*)fptr)->module->name);

}

if (scope && fptr->common.scope) {

if (fptr->common.scope != scope) {

smart_str_append_printf(str, ", inherits %s", ZSTR_VAL(fptr->common.scope->name));

} else if (fptr->common.scope->parent) {

lc_name = zend_string_tolower(fptr->common.function_name);

if ((overwrites = zend_hash_find_ptr(&fptr->common.scope->parent->function_table, lc_name)) != NULL) {

if (fptr->common.scope != overwrites->common.scope && !(overwrites->common.fn_flags & ZEND_ACC_PRIVATE)) {

smart_str_append_printf(str, ", overwrites %s", ZSTR_VAL(overwrites->common.scope->name));

}

}

zend_string_release_ex(lc_name, 0);

}

}

if (fptr->common.prototype && fptr->common.prototype->common.scope) {

smart_str_append_printf(str, ", prototype %s", ZSTR_VAL(fptr->common.prototype->common.scope->name));

}

if (fptr->common.fn_flags & ZEND_ACC_CTOR) {

smart_str_appends(str, ", ctor");

}

smart_str_appends(str, "> ");

if (fptr->common.fn_flags & ZEND_ACC_ABSTRACT) {

smart_str_appends(str, "abstract ");

}

if (fptr->common.fn_flags & ZEND_ACC_FINAL) {

smart_str_appends(str, "final ");

}

if (fptr->common.fn_flags & ZEND_ACC_STATIC) {

smart_str_appends(str, "static ");

}

if (fptr->common.scope) {

/* These are mutually exclusive */

switch (fptr->common.fn_flags & ZEND_ACC_PPP_MASK) {

case ZEND_ACC_PUBLIC:

smart_str_appends(str, "public ");

break;

case ZEND_ACC_PRIVATE:

smart_str_appends(str, "private ");

break;

case ZEND_ACC_PROTECTED:

smart_str_appends(str, "protected ");

break;

default:

smart_str_appends(str, "<visibility error> ");

break;

}

smart_str_appends(str, "method ");

} else {

smart_str_appends(str, "function ");

}

if (fptr->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE) {

smart_str_appendc(str, '&');

}

smart_str_append_printf(str, "%s ] {\n", ZSTR_VAL(fptr->common.function_name));

/* The information where a function is declared is only available for user classes */

if (fptr->type == ZEND_USER_FUNCTION) {

smart_str_append_printf(str, "%s @@ %s %d - %d\n", indent,

ZSTR_VAL(fptr->op_array.filename),

fptr->op_array.line_start,

fptr->op_array.line_end);

}

smart_str_append_printf(&param_indent, "%s ", indent);

smart_str_0(&param_indent);

if (fptr->common.fn_flags & ZEND_ACC_CLOSURE) {

_function_closure_string(str, fptr, ZSTR_VAL(param_indent.s));

}

_function_parameter_string(str, fptr, ZSTR_VAL(param_indent.s));

smart_str_free(&param_indent);

if ((fptr->op_array.fn_flags & ZEND_ACC_HAS_RETURN_TYPE)) {

smart_str_append_printf(str, " %s- %s [ ", indent, ZEND_ARG_TYPE_IS_TENTATIVE(&fptr->common.arg_info[-1]) ? "Tentative return" : "Return");

if (ZEND_TYPE_IS_SET(fptr->common.arg_info[-1].type)) {

zend_string *type_str = zend_type_to_string(fptr->common.arg_info[-1].type);

smart_str_append_printf(str, "%s ", ZSTR_VAL(type_str));

zend_string_release(type_str);

}

smart_str_appends(str, "]\n");

}

smart_str_append_printf(str, "%s}\n", indent);

}

static zval *property_get_default(zend_property_info *prop_info) {

zend_class_entry *ce = prop_info->ce;

if (prop_info->flags & ZEND_ACC_STATIC) {

zval *prop = &ce->default_static_members_table[prop_info->offset];

ZVAL_DEINDIRECT(prop);

return prop;

} else {

return &ce->default_properties_table[OBJ_PROP_TO_NUM(prop_info->offset)];

}

}

static void _property_string(smart_str *str, zend_property_info *prop, const char *prop_name, char* indent)

{

smart_str_append_printf(str, "%sProperty [ ", indent);

if (!prop) {

smart_str_append_printf(str, "<dynamic> public $%s", prop_name);

} else {

/* These are mutually exclusive */

switch (prop->flags & ZEND_ACC_PPP_MASK) {

case ZEND_ACC_PUBLIC:

smart_str_appends(str, "public ");

break;

case ZEND_ACC_PRIVATE:

smart_str_appends(str, "private ");

break;

case ZEND_ACC_PROTECTED:

smart_str_appends(str, "protected ");

break;

}

if (prop->flags & ZEND_ACC_STATIC) {

smart_str_appends(str, "static ");

}

if (prop->flags & ZEND_ACC_READONLY) {

smart_str_appends(str, "readonly ");

}

if (ZEND_TYPE_IS_SET(prop->type)) {

zend_string *type_str = zend_type_to_string(prop->type);

smart_str_append(str, type_str);

smart_str_appendc(str, ' ');

zend_string_release(type_str);

}

if (!prop_name) {

const char *class_name;

zend_unmangle_property_name(prop->name, &class_name, &prop_name);

}

smart_str_append_printf(str, "$%s", prop_name);

zval *default_value = property_get_default(prop);

if (!Z_ISUNDEF_P(default_value)) {

smart_str_appends(str, " = ");

if (format_default_value(str, default_value) == FAILURE) {

return;

}

}

}

smart_str_appends(str, " ]\n");

}

static void _extension_ini_string(zend_ini_entry *ini_entry, smart_str *str, char *indent, int number) /* {{{ */

{

char *comma = "";

if (number == ini_entry->module_number) {

smart_str_append_printf(str, " %sEntry [ %s <", indent, ZSTR_VAL(ini_entry->name));

if (ini_entry->modifiable == ZEND_INI_ALL) {

smart_str_appends(str, "ALL");

} else {

if (ini_entry->modifiable & ZEND_INI_USER) {

smart_str_appends(str, "USER");

comma = ",";

}

if (ini_entry->modifiable & ZEND_INI_PERDIR) {

smart_str_append_printf(str, "%sPERDIR", comma);

comma = ",";

}

if (ini_entry->modifiable & ZEND_INI_SYSTEM) {

smart_str_append_printf(str, "%sSYSTEM", comma);

}

}

smart_str_appends(str, "> ]\n");

smart_str_append_printf(str, " %s Current = '%s'\n", indent, ini_entry->value ? ZSTR_VAL(ini_entry->value) : "");

if (ini_entry->modified) {

smart_str_append_printf(str, " %s Default = '%s'\n", indent, ini_entry->orig_value ? ZSTR_VAL(ini_entry->orig_value) : "");

}

smart_str_append_printf(str, " %s}\n", indent);

}

}

static void _extension_class_string(zend_class_entry *ce, zend_string *key, smart_str *str, char *indent, zend_module_entry *module, int *num_classes) /* {{{ */

{

if (ce->type == ZEND_INTERNAL_CLASS && ce->info.internal.module && !strcasecmp(ce->info.internal.module->name, module->name)) {

/* dump class if it is not an alias */

if (zend_string_equals_ci(ce->name, key)) {

smart_str_append_printf(str, "\n");

_class_string(str, ce, NULL, indent);

(*num_classes)++;

}

}

}

static void _extension_string(smart_str *str, zend_module_entry *module, char *indent) /* {{{ */

{

smart_str_append_printf(str, "%sExtension [ ", indent);

if (module->type == MODULE_PERSISTENT) {

smart_str_appends(str, "<persistent>");

}

if (module->type == MODULE_TEMPORARY) {

smart_str_appends(str, "<temporary>" );

}

smart_str_append_printf(str, " extension #%d %s version %s ] {\n",

module->module_number, module->name,

(module->version == NO_VERSION_YET) ? "<no_version>" : module->version);

if (module->deps) {

const zend_module_dep* dep = module->deps;

smart_str_appends(str, "\n - Dependencies {\n");