/*

+----------------------------------------------------------------------+

| PHP Version 7 |

+----------------------------------------------------------------------+

| Copyright (c) 1997-2017 The PHP Group |

+----------------------------------------------------------------------+

| This source file is subject to version 3.01 of the PHP license, |

| that is bundled with this package in the file LICENSE, and is |

| available through the world-wide-web at the following url: |

| http://www.php.net/license/3_01.txt |

| If you did not receive a copy of the PHP license and are unable to |

| obtain it through the world-wide-web, please send a note to |

| license@php.net so we can mail you a copy immediately. |

+----------------------------------------------------------------------+

| Authors: Timm Friebe <thekid@thekid.de> |

| George Schlossnagle <george@omniti.com> |

| Andrei Zmievski <andrei@gravitonic.com> |

| Marcus Boerger <helly@php.net> |

| Johannes Schlueter <johannes@php.net> |

+----------------------------------------------------------------------+

*/

/* $Id$ */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include "php.h"

#include "php_ini.h"

#include "php_reflection.h"

#include "ext/standard/info.h"

#include "zend.h"

#include "zend_API.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"

#define reflection_update_property(object, name, value) do { \

zval member; \

ZVAL_STRINGL(&member, name, sizeof(name)-1); \

zend_std_write_property(object, &member, value, NULL); \

if (Z_REFCOUNTED_P(value)) Z_DELREF_P(value); \

zval_ptr_dtor(&member); \

} while (0)

/* Class entry pointers */

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_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;

/* Method macros */

#define METHOD_NOTSTATIC(ce) \

if ((Z_TYPE(EX(This)) != IS_OBJECT) || !instanceof_function(Z_OBJCE(EX(This)), ce)) { \

php_error_docref(NULL, E_ERROR, "%s() cannot be called statically", get_active_function_name()); \

return; \

} \

/* Exception throwing macro */

#define _DO_THROW(msg) \

zend_throw_exception(reflection_exception_ptr, msg, 0); \

return; \

#define RETURN_ON_EXCEPTION \

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

return; \

}

#define GET_REFLECTION_OBJECT() \

intern = Z_REFLECTION_P(getThis()); \

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

RETURN_ON_EXCEPTION \

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

return; \

} \

#define GET_REFLECTION_OBJECT_PTR(target) \

GET_REFLECTION_OBJECT() \

target = intern->ptr; \

/* Class constants */

#define REGISTER_REFLECTION_CLASS_CONST_LONG(class_name, const_name, value) \

zend_declare_class_constant_long(reflection_ ## class_name ## _ptr, const_name, sizeof(const_name)-1, (zend_long)value);

/* {{{ Object structure */

/* Struct for properties */

typedef struct _property_reference {

zend_class_entry *ce;

zend_property_info prop;

} property_reference;

/* Struct for parameters */

typedef struct _parameter_reference {

uint32_t offset;

zend_bool required;

struct _zend_arg_info *arg_info;

zend_function *fptr;

} parameter_reference;

/* Struct for type hints */

typedef struct _type_reference {

struct _zend_arg_info *arg_info;

zend_function *fptr;

} type_reference;

typedef enum {

REF_TYPE_OTHER, /* Must be 0 */

REF_TYPE_FUNCTION,

REF_TYPE_GENERATOR,

REF_TYPE_PARAMETER,

REF_TYPE_TYPE,

REF_TYPE_PROPERTY,

REF_TYPE_DYNAMIC_PROPERTY,

REF_TYPE_CLASS_CONSTANT

} reflection_type_t;

/* Struct for reflection objects */

typedef struct {

zval dummy; /* holder for the second property */

zval obj;

void *ptr;

zend_class_entry *ce;

reflection_type_t ref_type;

unsigned int ignore_visibility:1;

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 zval *_default_load_entry(zval *object, char *name, size_t name_len) /* {{{ */

{

zval *value;

if ((value = zend_hash_str_find_ind(Z_OBJPROP_P(object), name, name_len)) == NULL) {

return NULL;

}

return value;

}

/* }}} */

static void _default_get_entry(zval *object, char *name, int name_len, zval *return_value) /* {{{ */

{

zval *value;

if ((value = _default_load_entry(object, name, name_len)) == NULL) {

RETURN_FALSE;

}

ZVAL_DUP(return_value, value);

}

/* }}} */

#ifdef ilia_0

static void _default_lookup_entry(zval *object, char *name, int name_len, zval **return_value) /* {{{ */

{

zval **value;

if (zend_hash_find(Z_OBJPROP_P(object), name, name_len, (void **) &value) == FAILURE) {

*return_value = NULL;

} else {

*return_value = *value;

}

}

/* }}} */

#endif

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(fptr->internal_function.function_name);

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;

type_reference *typ_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:

typ_reference = (type_reference*)intern->ptr;

_free_function(typ_reference->fptr);

efree(intern->ptr);

break;

case REF_TYPE_FUNCTION:

_free_function(intern->ptr);

break;

case REF_TYPE_PROPERTY:

efree(intern->ptr);

break;

case REF_TYPE_DYNAMIC_PROPERTY:

prop_reference = (property_reference*)intern->ptr;

zend_string_release(prop_reference->prop.name);

efree(intern->ptr);

break;

case REF_TYPE_GENERATOR:

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(zval *obj, zval **gc_data, int *gc_data_count) /* {{{ */

{

reflection_object *intern = Z_REFLECTION_P(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;

intern = ecalloc(1, sizeof(reflection_object) + zend_object_properties_size(class_type));

intern->zo.ce = class_type;

zend_object_std_init(&intern->zo, class_type);

object_properties_init(&intern->zo, class_type);

intern->zo.handlers = &reflection_object_handlers;

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, char *prop_name, char* indent);

static void _class_const_string(smart_str *str, char *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);

/* {{{ _class_string */

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 ");

}

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;

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_FOREACH_STR_KEY_PTR(&ce->constants_table, key, c) {

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

} 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_FOREACH_PTR(&ce->properties_info, prop) {

if(prop->flags & ZEND_ACC_SHADOW) {

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_FOREACH_PTR(&ce->properties_info, prop) {

if ((prop->flags & ZEND_ACC_STATIC) && !(prop->flags & ZEND_ACC_SHADOW)) {

_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_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_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_FOREACH_PTR(&ce->properties_info, prop) {

if (!(prop->flags & (ZEND_ACC_STATIC|ZEND_ACC_SHADOW))) {

_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 && Z_OBJ_HT_P(obj)->get_properties) {

HashTable *properties = Z_OBJ_HT_P(obj)->get_properties(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;

zend_string *key;

smart_str method_str = {0};

count = 0;

ZEND_HASH_FOREACH_STR_KEY_PTR(&ce->function_table, key, mptr) {

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

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

{

size_t len = ZSTR_LEN(mptr->common.function_name);

/* Do not display old-style inherited constructors */

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

|| mptr->common.scope == ce

|| !key

|| zend_binary_strcasecmp(ZSTR_VAL(key), ZSTR_LEN(key), ZSTR_VAL(mptr->common.function_name), len) == 0)

{

zend_function *closure;

/* see if this is a closure */

if (ce == zend_ce_closure && obj && (len == sizeof(ZEND_INVOKE_FUNC_NAME)-1)

&& memcmp(ZSTR_VAL(mptr->common.function_name), ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1) == 0

&& (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(sub_indent);

}

/* }}} */

/* {{{ _const_string */

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

{

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 {

zend_string *value_str = zval_get_string(value);

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

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

zend_string_release(value_str);

}

}

/* }}} */

/* {{{ _class_const_string */

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

{

char *visibility = zend_visibility_string(Z_ACCESS_FLAGS(c->value));

char *type;

zval_update_constant_ex(&c->value, c->ce);

type = zend_zval_type_name(&c->value);

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

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

indent, visibility, type, name);

} else {

zend_string *value_str = zval_get_string(&c->value);

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

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

zend_string_release(value_str);

}

}

/* }}} */

/* {{{ _get_recv_opcode */

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;

}

return NULL;

}

/* }}} */

/* {{{ _parameter_string */

static void _parameter_string(smart_str *str, zend_function *fptr, struct _zend_arg_info *arg_info, uint32_t offset, zend_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_CLASS(arg_info->type)) {

smart_str_append_printf(str, "%s ",

ZSTR_VAL(ZEND_TYPE_NAME(arg_info->type)));

if (ZEND_TYPE_ALLOW_NULL(arg_info->type)) {

smart_str_append_printf(str, "or NULL ");

}

} else if (ZEND_TYPE_IS_CODE(arg_info->type)) {

smart_str_append_printf(str, "%s ", zend_get_type_by_const(ZEND_TYPE_CODE(arg_info->type)));

if (ZEND_TYPE_ALLOW_NULL(arg_info->type)) {

smart_str_append_printf(str, "or NULL ");

}

}

if (arg_info->pass_by_reference) {

smart_str_appendc(str, '&');

}

if (arg_info->is_variadic) {

smart_str_appends(str, "...");

}

if (arg_info->name) {

smart_str_append_printf(str, "$%s",

(fptr->type == ZEND_INTERNAL_FUNCTION &&

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

((zend_internal_arg_info*)arg_info)->name :

ZSTR_VAL(arg_info->name));

} else {

smart_str_append_printf(str, "$param%d", offset);

}

if (fptr->type == ZEND_USER_FUNCTION && !required) {

zend_op *precv = _get_recv_op((zend_op_array*)fptr, offset);

if (precv && precv->opcode == ZEND_RECV_INIT && precv->op2_type != IS_UNUSED) {

zval zv;

smart_str_appends(str, " = ");

ZVAL_DUP(&zv, RT_CONSTANT(&fptr->op_array, precv->op2));

zval_update_constant_ex(&zv, fptr->common.scope);

if (Z_TYPE(zv) == IS_TRUE) {

smart_str_appends(str, "true");

} else if (Z_TYPE(zv) == IS_FALSE) {

smart_str_appends(str, "false");

} else if (Z_TYPE(zv) == IS_NULL) {

smart_str_appends(str, "NULL");

} else if (Z_TYPE(zv) == IS_STRING) {

smart_str_appendc(str, '\'');

smart_str_appendl(str, Z_STRVAL(zv), MIN(Z_STRLEN(zv), 15));

if (Z_STRLEN(zv) > 15) {

smart_str_appends(str, "...");

}

smart_str_appendc(str, '\'');

} else if (Z_TYPE(zv) == IS_ARRAY) {

smart_str_appends(str, "Array");

} else {

zend_string *zv_str = zval_get_string(&zv);

smart_str_append(str, zv_str);

zend_string_release(zv_str);

}

zval_ptr_dtor(&zv);

}

}

smart_str_appends(str, " ]");

}

/* }}} */

/* {{{ _function_parameter_string */

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

}

/* }}} */

/* {{{ _function_closure_string */

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 = fptr->op_array.static_variables;

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_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);

}

/* }}} */

/* {{{ _function_string */

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;

size_t lc_name_len;

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

* What's "wrong" is that any whitespace before the doc comment start is

* swallowed, leading to an unaligned comment.

*/

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_len = ZSTR_LEN(fptr->common.function_name);

lc_name = zend_string_alloc(lc_name_len, 0);

zend_str_tolower_copy(ZSTR_VAL(lc_name), ZSTR_VAL(fptr->common.function_name), lc_name_len);

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

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

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

}

}

efree(lc_name);

}

}

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");

}

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

smart_str_appends(str, ", dtor");

}

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- Return [ ", indent);

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

smart_str_append_printf(str, "%s ",

ZSTR_VAL(ZEND_TYPE_NAME(fptr->common.arg_info[-1].type)));

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

smart_str_appends(str, "or NULL ");

}

} else if (ZEND_TYPE_IS_CODE(fptr->common.arg_info[-1].type)) {

smart_str_append_printf(str, "%s ", zend_get_type_by_const(ZEND_TYPE_CODE(fptr->common.arg_info[-1].type)));

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

smart_str_appends(str, "or NULL ");

}

}

smart_str_appends(str, "]\n");

}

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

}

/* }}} */

/* {{{ _property_string */

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

{

const char *class_name;

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

if (!prop) {

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

} else {

if (!(prop->flags & ZEND_ACC_STATIC)) {

if (prop->flags & ZEND_ACC_IMPLICIT_PUBLIC) {

smart_str_appends(str, "<implicit> ");

} else {

smart_str_appends(str, "<default> ");

}

}

/* 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 ");

}

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

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

}

smart_str_appends(str, " ]\n");

}

/* }}} */

static int _extension_ini_string(zval *el, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */

{

zend_ini_entry *ini_entry = (zend_ini_entry*)Z_PTR_P(el);

smart_str *str = va_arg(args, smart_str *);

char *indent = va_arg(args, char *);

int number = va_arg(args, int);

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

}

return ZEND_HASH_APPLY_KEEP;

}

/* }}} */

static int _extension_class_string(zval *el, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */

{

zend_class_entry *ce = (zend_class_entry*)Z_PTR_P(el);

smart_str *str = va_arg(args, smart_str *);

char *indent = va_arg(args, char *);

struct _zend_module_entry *module = va_arg(args, struct _zend_module_entry*);

int *num_classes = va_arg(args, int*);

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_binary_strcasecmp(ZSTR_VAL(ce->name), ZSTR_LEN(ce->name), ZSTR_VAL(hash_key->key), ZSTR_LEN(hash_key->key))) {

smart_str_append_printf(str, "\n");

_class_string(str, ce, NULL, indent);

(*num_classes)++;

}

}

return ZEND_HASH_APPLY_KEEP;

}

/* }}} */

static int _extension_const_string(zval *el, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */

{

zend_constant *constant = (zend_constant*)Z_PTR_P(el);

smart_str *str = va_arg(args, smart_str *);

char *indent = va_arg(args, char *);

struct _zend_module_entry *module = va_arg(args, struct _zend_module_entry*);

int *num_classes = va_arg(args, int*);

if (constant->module_number == module->module_number) {

_const_string(str, ZSTR_VAL(constant->name), &constant->value, indent);

(*num_classes)++;

}

return ZEND_HASH_APPLY_KEEP;

}

/* }}} */

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");

while(dep->name) {

smart_str_append_printf(str, "%s Dependency [ %s (", indent, dep->name);

switch(dep->type) {

case MODULE_DEP_REQUIRED:

smart_str_appends(str, "Required");

break;

case MODULE_DEP_CONFLICTS:

smart_str_appends(str, "Conflicts");

break;

case MODULE_DEP_OPTIONAL:

smart_str_appends(str, "Optional");

break;

default:

smart_str_appends(str, "Error"); /* shouldn't happen */

break;

}

if (dep->rel) {

smart_str_append_printf(str, " %s", dep->rel);

}

if (dep->version) {

smart_str_append_printf(str, " %s", dep->version);

}

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

dep++;