#include "zend_compile.h"

#include "zend_execute.h"

#include "zend_lazy_objects.h"

#include "zend_object_handlers.h"

#include "zend_type_info.h"

#include "zend_types.h"

#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_csprng.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;

PHPAPI zend_class_entry *reflection_constant_ptr;

PHPAPI zend_class_entry *reflection_property_hook_type_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 {

} 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(const property_reference *ref) {

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

}

static inline bool is_closure_invoke(const zend_class_entry *ce, const 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_property_reference(property_reference *reference)

{

zend_string_release_ex(reference->unmangled_name, 0);

efree(reference);

}

static void reflection_free_parameter_reference(parameter_reference *reference)

{

_free_function(reference->fptr);

efree(reference);

}

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

{

reflection_object *intern = reflection_object_from_obj(object);

if (intern->ptr) {

switch (intern->ref_type) {

case REF_TYPE_PARAMETER:

reflection_free_parameter_reference(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:

reflection_free_property_reference(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 void _const_string(smart_str *str, const char *name, zval *value, const char *indent);

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

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

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

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

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

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

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

static void _class_string(smart_str *str, zend_class_entry *ce, zval *obj, const 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->doc_comment) {

smart_str_append_printf(str, "%s%s", indent, ZSTR_VAL(ce->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";

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

kind = "Enum";

}

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

}

smart_str_appends(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_appends(str, "> ");

if (ce->get_iterator != NULL) {

smart_str_appends(str, "<iterateable> ");

}

if (ce->ce_flags & ZEND_ACC_INTERFACE) {

smart_str_appends(str, "interface ");

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

smart_str_appends(str, "trait ");

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

smart_str_appends(str, "enum ");

} else {

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

smart_str_appends(str, "abstract ");

}

if (ce->ce_flags & ZEND_ACC_FINAL) {

smart_str_appends(str, "final ");

}

if (ce->ce_flags & ZEND_ACC_READONLY_CLASS) {

smart_str_appends(str, "readonly ");

}

smart_str_appends(str, "class ");

}

smart_str_append(str, ce->name);

if (ce->parent) {

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

}

// Show backing type of enums

if ((ce->ce_flags & ZEND_ACC_ENUM) && (ce->enum_backing_type != IS_UNDEF)) {

smart_str_appends(str,

ce->enum_backing_type == IS_STRING ? ": string" : ": int"

);

}

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_appends(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 */

uint32_t total_count = zend_hash_num_elements(&ce->constants_table);

uint32_t constant_count = 0;

uint32_t enum_case_count = 0;

smart_str constant_str = {0};

smart_str enum_case_str = {0};

/* So that we don't need to loop through all of the constants multiple

if (total_count > 0) {

zend_string *key;

zend_class_constant *c;

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

if (ZEND_CLASS_CONST_FLAGS(c) & ZEND_CLASS_CONST_IS_CASE) {

_enum_case_string(&enum_case_str, key, c, ZSTR_VAL(sub_indent));

enum_case_count++;

} else {

_class_const_string(&constant_str, key, c, ZSTR_VAL(sub_indent));

constant_count++;

}

if (UNEXPECTED(EG(exception))) {

zend_string_release(sub_indent);

smart_str_free(&enum_case_str);

smart_str_free(&constant_str);

return;

}

} ZEND_HASH_FOREACH_END();

}

// Enum cases go first, but the heading is only shown if there are any

if (enum_case_count) {

smart_str_appendc(str, '\n');

smart_str_append_printf(str, "%s - Enum cases [%d] {\n", indent, enum_case_count);

smart_str_append_smart_str(str, &enum_case_str);

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

}

smart_str_appendc(str, '\n');

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

smart_str_append_smart_str(str, &constant_str);

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

smart_str_free(&enum_case_str);

smart_str_free(&constant_str);

/* 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_appendc(str, '\n');

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

}

} ZEND_HASH_FOREACH_END();

} else {

smart_str_appendc(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 = zend_get_properties_no_lazy_init(Z_OBJ_P(obj));

zend_string *prop_name;

smart_str prop_str = {0};

count = 0;

if (properties && zend_hash_num_elements(properties)) {

ZEND_HASH_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_appendc(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, const char *name, zval *value, const char *indent)

{

const char *type = zend_zval_type_name(value);

uint32_t flags = Z_CONSTANT_FLAGS_P(value);

smart_str_appends(str, indent);

smart_str_appends(str, "Constant [ ");

if (flags & (CONST_PERSISTENT|CONST_NO_FILE_CACHE|CONST_DEPRECATED)) {

bool first = true;

smart_str_appendc(str, '<');

#define DUMP_CONST_FLAG(flag, output) \

do { \

if (flags & flag) { \

if (!first) smart_str_appends(str, ", "); \

smart_str_appends(str, output); \

first = false; \

} \

} while (0)

DUMP_CONST_FLAG(CONST_PERSISTENT, "persistent");

DUMP_CONST_FLAG(CONST_NO_FILE_CACHE, "no_file_cache");

DUMP_CONST_FLAG(CONST_DEPRECATED, "deprecated");

#undef DUMP_CONST_FLAG

smart_str_appends(str, "> ");

}

smart_str_appends(str, type);

smart_str_appendc(str, ' ');

smart_str_appends(str, name);

smart_str_appends(str, " ] { ");

if (Z_TYPE_P(value) == IS_ARRAY) {

smart_str_append(str, ZSTR_KNOWN(ZEND_STR_ARRAY_CAPITALIZED));

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

smart_str_appends(str, 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(str, value_str);

zend_tmp_string_release(tmp_value_str);

}

smart_str_appends(str, " }\n");

}

static void _class_const_string(smart_str *str, const zend_string *name, zend_class_constant *c, const 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);

if (c->doc_comment) {

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

}

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 void _enum_case_string(smart_str *str, const zend_string *name, zend_class_constant *c, const char *indent)

{

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

return;

}

if (c->doc_comment) {

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

}

smart_str_append_printf(str, "%sCase %s", indent, ZSTR_VAL(name));

if (c->ce->enum_backing_type == IS_UNDEF) {

// No value

smart_str_appendc(str, '\n');

} else {

/* Has a value, which is the enum instance, get the value from that.

zval *enum_val = zend_enum_fetch_case_value(Z_OBJ(c->value));

zend_string *tmp_value_str;

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

smart_str_append_printf(str, " = %s\n", ZSTR_VAL(value_str));

zend_tmp_string_release(tmp_value_str);

}

}

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

{

zend_op *op = op_array->opcodes;

const 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 (smart_str_append_zval(str, value, SIZE_MAX) == SUCCESS) {

/* Nothing to do. */

} 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) {

/* This branch is reached if the constant AST was already evaluated and

zend_object *obj = Z_OBJ_P(value);

zend_class_entry *class = obj->ce;

ZEND_ASSERT(!(class->ce_flags & ZEND_ACC_ENUM));

smart_str_appends(str, "object(");

smart_str_append(str, class->name);

smart_str_appendc(str, ')');

} 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_appends(str, "<optional> ");

} else {

smart_str_appends(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, const zend_function *fptr, const char* indent)

{

uint32_t i, count;

const zend_string *key;

const 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_appendc(str, '\n');

smart_str_append_printf(str, "%s- Bound Variables [%u] {\n", indent, count);

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, const 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));

} else if (fptr->type == ZEND_INTERNAL_FUNCTION && fptr->internal_function.doc_comment) {

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

}

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

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

smart_str_appends(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 if (prop_info->flags & ZEND_ACC_VIRTUAL) {

return NULL;

} 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, const char* indent)

{