/*

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

| PHP Version 7 |

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

| Copyright (c) 1997-2016 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"

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

#if MBO_0

ZEND_BEGIN_MODULE_GLOBALS(reflection)

int dummy;

ZEND_END_MODULE_GLOBALS(reflection)

#ifdef ZTS

# define REFLECTION_G(v) \

ZEND_TSRMG(reflection_globals_id, zend_reflection_globals*, v)

extern int reflection_globals_id;

#else

# define REFLECTION_G(v) (reflection_globals.v)

extern zend_reflection_globals reflectionglobals;

#endif

ZEND_DECLARE_MODULE_GLOBALS(reflection)

#endif /* MBO_0 */

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

/* {{{ Smart string functions */

typedef struct _string {

zend_string *buf;

size_t alloced;

} string;

static void string_init(string *str)

{

str->buf= zend_string_alloc(1024, 0);

str->alloced = 1024;

ZSTR_VAL(str->buf)[0] = '\0';

ZSTR_LEN(str->buf) = 0;

}

static string *string_printf(string *str, const char *format, ...)

{

size_t len;

va_list arg;

char *s_tmp;

va_start(arg, format);

len = zend_vspprintf(&s_tmp, 0, format, arg);

if (len) {

register size_t nlen = (ZSTR_LEN(str->buf) + 1 + len + (1024 - 1)) & ~(1024 - 1);

if (str->alloced < nlen) {

size_t old_len = ZSTR_LEN(str->buf);

str->alloced = nlen;

str->buf = zend_string_extend(str->buf, str->alloced, 0);

ZSTR_LEN(str->buf) = old_len;

}

memcpy(ZSTR_VAL(str->buf) + ZSTR_LEN(str->buf), s_tmp, len + 1);

ZSTR_LEN(str->buf) += len;

}

efree(s_tmp);

va_end(arg);

return str;

}

static string *string_write(string *str, char *buf, size_t len)

{

register size_t nlen = (ZSTR_LEN(str->buf) + 1 + len + (1024 - 1)) & ~(1024 - 1);

if (str->alloced < nlen) {

size_t old_len = ZSTR_LEN(str->buf);

str->alloced = nlen;

str->buf = zend_string_extend(str->buf, str->alloced, 0);

ZSTR_LEN(str->buf) = old_len;

}

memcpy(ZSTR_VAL(str->buf) + ZSTR_LEN(str->buf), buf, len);

ZSTR_LEN(str->buf) += len;

ZSTR_VAL(str->buf)[ZSTR_LEN(str->buf)] = '\0';

return str;

}

static string *string_append(string *str, string *append)

{

if (ZSTR_LEN(append->buf) > 0) {

string_write(str, ZSTR_VAL(append->buf), ZSTR_LEN(append->buf));

}

return str;

}

static void string_free(string *str)

{

zend_string_release(str->buf);

str->alloced = 0;

str->buf = NULL;

}

/* }}} */

/* {{{ 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;

uint32_t 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 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(string *str, char *name, zval *value, char *indent);

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

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

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

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

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

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

/* {{{ _class_string */

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

{

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

string sub_indent;

string_init(&sub_indent);

string_printf(&sub_indent, "%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) {

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

string_write(str, "\n", 1);

}

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

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

}

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

}

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

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

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

}

string_printf(str, "> ");

if (ce->get_iterator != NULL) {

string_printf(str, "<iterateable> ");

}

if (ce->ce_flags & ZEND_ACC_INTERFACE) {

string_printf(str, "interface ");

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

string_printf(str, "trait ");

} else {

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

string_printf(str, "abstract ");

}

if (ce->ce_flags & ZEND_ACC_FINAL) {

string_printf(str, "final ");

}

string_printf(str, "class ");

}

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

if (ce->parent) {

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

}

if (ce->num_interfaces) {

uint32_t i;

if (ce->ce_flags & ZEND_ACC_INTERFACE) {

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

} else {

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

}

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

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

}

}

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

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

if (ce->type == ZEND_USER_CLASS) {

string_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 */

string_printf(str, "\n");

count = zend_hash_num_elements(&ce->constants_table);

string_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.buf));

} ZEND_HASH_FOREACH_END();

}

string_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 */

string_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.buf));

}

} ZEND_HASH_FOREACH_END();

}

string_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 */

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

{

string_printf(str, "\n");

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

}

} ZEND_HASH_FOREACH_END();

} else {

string_printf(str, "\n");

}

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

/* Default/Implicit properties */

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

string_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.buf));

}

} ZEND_HASH_FOREACH_END();

}

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

if (obj && Z_TYPE_P(obj) == IS_OBJECT && Z_OBJ_HT_P(obj)->get_properties) {

string dyn;

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

zend_string *prop_name;

string_init(&dyn);

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(&dyn, NULL, ZSTR_VAL(prop_name), ZSTR_VAL(sub_indent.buf));

}

}

} ZEND_HASH_FOREACH_END();

}

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

string_append(str, &dyn);

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

string_free(&dyn);

}

/* Non static methods */

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

if (count > 0) {

zend_function *mptr;

zend_string *key;

string dyn;

count = 0;

string_init(&dyn);

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;

}

string_printf(&dyn, "\n");

_function_string(&dyn, mptr, ce, ZSTR_VAL(sub_indent.buf));

count++;

_free_function(closure);

}

}

} ZEND_HASH_FOREACH_END();

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

if (!count) {

string_printf(str, "\n");

}

string_append(str, &dyn);

string_free(&dyn);

} else {

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

}

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

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

string_free(&sub_indent);

}

/* }}} */

/* {{{ _const_string */

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

{

char *type = zend_zval_type_name(value);

if (Z_TYPE_P(value) == IS_ARRAY) {

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

indent, type, name);

} else {

zend_string *value_str = zval_get_string(value);

string_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(string *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) {

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

indent, visibility, type, name);

} else {

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

string_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(string *str, zend_function *fptr, struct _zend_arg_info *arg_info, uint32_t offset, uint32_t required, char* indent)

{

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

if (offset >= required) {

string_printf(str, "<optional> ");

} else {

string_printf(str, "<required> ");

}

if (arg_info->class_name) {

string_printf(str, "%s ",

(fptr->type == ZEND_INTERNAL_FUNCTION &&

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

((zend_internal_arg_info*)arg_info)->class_name :

ZSTR_VAL(arg_info->class_name));

if (arg_info->allow_null) {

string_printf(str, "or NULL ");

}

} else if (arg_info->type_hint) {

string_printf(str, "%s ", zend_get_type_by_const(arg_info->type_hint));

if (arg_info->allow_null) {

string_printf(str, "or NULL ");

}

}

if (arg_info->pass_by_reference) {

string_write(str, "&", sizeof("&")-1);

}

if (arg_info->is_variadic) {

string_write(str, "...", sizeof("...")-1);

}

if (arg_info->name) {

string_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 {

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

}

if (fptr->type == ZEND_USER_FUNCTION && offset >= 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;

string_write(str, " = ", sizeof(" = ")-1);

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

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

if (Z_TYPE(zv) == IS_TRUE) {

string_write(str, "true", sizeof("true")-1);

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

string_write(str, "false", sizeof("false")-1);

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

string_write(str, "NULL", sizeof("NULL")-1);

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

string_write(str, "'", sizeof("'")-1);

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

if (Z_STRLEN(zv) > 15) {

string_write(str, "...", sizeof("...")-1);

}

string_write(str, "'", sizeof("'")-1);

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

string_write(str, "Array", sizeof("Array")-1);

} else {

zend_string *zv_str = zval_get_string(&zv);

string_write(str, ZSTR_VAL(zv_str), ZSTR_LEN(zv_str));

zend_string_release(zv_str);

}

zval_ptr_dtor(&zv);

}

}

string_write(str, " ]", sizeof(" ]")-1);

}

/* }}} */

/* {{{ _function_parameter_string */

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

{

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

uint32_t i, num_args, 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++;

}

string_printf(str, "\n");

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

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

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

_parameter_string(str, fptr, arg_info, i, required, indent);

string_write(str, "\n", sizeof("\n")-1);

arg_info++;

}

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

}

/* }}} */

/* {{{ _function_closure_string */

static void _function_closure_string(string *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;

}

string_printf(str, "\n");

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

i = 0;

ZEND_HASH_FOREACH_STR_KEY(static_variables, key) {

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

} ZEND_HASH_FOREACH_END();

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

}

/* }}} */

/* {{{ _function_string */

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

{

string param_indent;

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

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

}

string_write(str, indent, strlen(indent));

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

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

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

string_printf(str, ", deprecated");

}

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

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

}

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

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

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

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

}

}

efree(lc_name);

}

}

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

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

}

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

string_printf(str, ", ctor");

}

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

string_printf(str, ", dtor");

}

string_printf(str, "> ");

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

string_printf(str, "abstract ");

}

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

string_printf(str, "final ");

}

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

string_printf(str, "static ");

}

if (fptr->common.scope) {

/* These are mutually exclusive */

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

case ZEND_ACC_PUBLIC:

string_printf(str, "public ");

break;

case ZEND_ACC_PRIVATE:

string_printf(str, "private ");

break;

case ZEND_ACC_PROTECTED:

string_printf(str, "protected ");

break;

default:

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

break;

}

string_printf(str, "method ");

} else {

string_printf(str, "function ");

}

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

string_printf(str, "&");

}

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

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

ZSTR_VAL(fptr->op_array.filename),

fptr->op_array.line_start,

fptr->op_array.line_end);

}

string_init(&param_indent);

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

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

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

}

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

string_free(&param_indent);

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

string_printf(str, " %s- Return [ ", indent);

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

string_printf(str, "%s ",

(fptr->type == ZEND_INTERNAL_FUNCTION &&

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

((zend_internal_arg_info*)(fptr->common.arg_info - 1))->class_name :

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

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

string_printf(str, "or NULL ");

}

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

string_printf(str, "%s ", zend_get_type_by_const(fptr->common.arg_info[-1].type_hint));

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

string_printf(str, "or NULL ");

}

}

string_printf(str, "]\n");

}

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

}

/* }}} */

/* {{{ _property_string */

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

{

const char *class_name;

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

if (!prop) {

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

} else {

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

if (prop->flags & ZEND_ACC_IMPLICIT_PUBLIC) {

string_write(str, "<implicit> ", sizeof("<implicit> ") - 1);

} else {

string_write(str, "<default> ", sizeof("<default> ") - 1);

}

}

/* These are mutually exclusive */

switch (prop->flags & ZEND_ACC_PPP_MASK) {

case ZEND_ACC_PUBLIC:

string_printf(str, "public ");

break;

case ZEND_ACC_PRIVATE:

string_printf(str, "private ");

break;

case ZEND_ACC_PROTECTED:

string_printf(str, "protected ");

break;

}

if(prop->flags & ZEND_ACC_STATIC) {

string_printf(str, "static ");

}

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

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

}

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

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

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

int number = va_arg(args, int);

char *comma = "";

if (number == ini_entry->module_number) {

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

if (ini_entry->modifiable == ZEND_INI_ALL) {

string_printf(str, "ALL");

} else {

if (ini_entry->modifiable & ZEND_INI_USER) {

string_printf(str, "USER");

comma = ",";

}

if (ini_entry->modifiable & ZEND_INI_PERDIR) {

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

comma = ",";

}

if (ini_entry->modifiable & ZEND_INI_SYSTEM) {

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

}

}

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

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