}
-void zend_shutdown()
+void zend_shutdown(TSRMLS_D)
{
#ifdef ZEND_WIN32
zend_shutdown_timeout_thread();
free(GLOBAL_FUNCTION_TABLE);
zend_hash_destroy(GLOBAL_CLASS_TABLE);
free(GLOBAL_CLASS_TABLE);
- zend_shutdown_extensions();
+ zend_shutdown_extensions(TSRMLS_C);
free(zend_version_info);
#ifndef ZTS
zend_shutdown_constants();
}
-void zend_activate_modules(void)
+void zend_activate_modules(TSRMLS_D)
{
- zend_hash_apply(&module_registry, (apply_func_t) module_registry_request_startup);
+ zend_hash_apply(&module_registry, (apply_func_t) module_registry_request_startup TSRMLS_CC);
}
void zend_deactivate_modules(TSRMLS_D)
EG(opline_ptr) = NULL; /* we're no longer executing anything */
zend_try {
- zend_hash_apply(&module_registry, (apply_func_t) module_registry_cleanup);
+ zend_hash_apply(&module_registry, (apply_func_t) module_registry_cleanup TSRMLS_CC);
} zend_end_try();
}
#define BYREF_FORCE_REST 3
int zend_startup(zend_utility_functions *utility_functions, char **extensions, int start_builtin_functions);
-void zend_shutdown(void);
+void zend_shutdown(TSRMLS_D);
void zend_set_utility_values(zend_utility_values *utility_values);
ZEND_API int _object_init_ex(zval *arg, zend_class_entry *class_type ZEND_FILE_LINE_DC)
{
zval *tmp;
+ TSRMLS_FETCH();
if (!class_type->constants_updated) {
- zend_hash_apply_with_argument(&class_type->default_properties, (int (*)(void *,void *)) zval_update_constant, (void *) 1);
+ zend_hash_apply_with_argument(&class_type->default_properties, (apply_func_arg_t) zval_update_constant, (void *) 1 TSRMLS_CC);
class_type->constants_updated = 1;
}
TSRMLS_FETCH();
if (module->type == MODULE_TEMPORARY) {
- zend_clean_module_rsrc_dtors(module->module_number);
+ zend_clean_module_rsrc_dtors(module->module_number TSRMLS_CC);
clean_module_constants(module->module_number TSRMLS_CC);
if (module->request_shutdown_func)
module->request_shutdown_func(module->type, module->module_number TSRMLS_CC);
/* call request startup for all modules */
-int module_registry_request_startup(zend_module_entry *module)
+int module_registry_request_startup(zend_module_entry *module TSRMLS_DC)
{
if (module->request_startup_func) {
- TSRMLS_FETCH();
-
#if 0
zend_printf("%s: Request startup\n",module->name);
#endif
/* for persistent modules - call request shutdown and flag NOT to erase
* for temporary modules - do nothing, and flag to erase
*/
-int module_registry_cleanup(zend_module_entry *module)
+int module_registry_cleanup(zend_module_entry *module TSRMLS_DC)
{
- TSRMLS_FETCH();
-
switch(module->type) {
case MODULE_PERSISTENT:
if (module->request_shutdown_func) {
};
-ZEND_API int zend_disable_function(char *function_name, uint function_name_length)
+ZEND_API int zend_disable_function(char *function_name, uint function_name_length TSRMLS_DC)
{
- TSRMLS_FETCH();
-
if (zend_hash_del(CG(function_table), function_name, function_name_length+1)==FAILURE) {
return FAILURE;
}
ZEND_API zend_class_entry *zend_register_internal_class_ex(zend_class_entry *class_entry, zend_class_entry *parent_ce, char *parent_name TSRMLS_DC);
ZEND_API zend_module_entry *zend_get_module(int module_number);
-ZEND_API int zend_disable_function(char *function_name, uint function_name_length);
+ZEND_API int zend_disable_function(char *function_name, uint function_name_length TSRMLS_DC);
ZEND_API void zend_wrong_param_count(TSRMLS_D);
ZEND_API zend_bool zend_is_callable(zval *callable, zend_bool syntax_only, char **callable_name);
efree(lcname);
array_init(return_value);
if (!ce->constants_updated) {
- zend_hash_apply_with_argument(&ce->default_properties, (int (*)(void *,void *)) zval_update_constant, (void *) 1);
+ zend_hash_apply_with_argument(&ce->default_properties, (apply_func_arg_t) zval_update_constant, (void *) 1 TSRMLS_CC);
ce->constants_updated = 1;
}
zend_hash_copy(return_value->value.ht, &ce->default_properties, (copy_ctor_func_t) zval_add_ref, (void *) &tmp, sizeof(zval *));
}
-static int add_extension_info(zend_module_entry *module, void *arg)
+static int add_extension_info(zend_module_entry *module, void *arg TSRMLS_DC)
{
zval *name_array = (zval *)arg;
add_next_index_string(name_array, module->name, 1);
return 0;
}
-static int add_constant_info(zend_constant *constant, void *arg)
+static int add_constant_info(zend_constant *constant, void *arg TSRMLS_DC)
{
zval *name_array = (zval *)arg;
zval *const_val;
}
array_init(return_value);
- zend_hash_apply_with_argument(&module_registry, (int (*)(void *, void*)) add_extension_info, return_value);
+ zend_hash_apply_with_argument(&module_registry, (apply_func_arg_t) add_extension_info, return_value TSRMLS_CC);
}
/* }}} */
}
array_init(return_value);
- zend_hash_apply_with_argument(EG(zend_constants), (int (*)(void *, void*)) add_constant_info, return_value);
+ zend_hash_apply_with_argument(EG(zend_constants), (apply_func_arg_t) add_constant_info, return_value TSRMLS_CC);
}
{
zend_do_extended_info(TSRMLS_C);
zend_do_return(NULL, 0 TSRMLS_CC);
- pass_two(CG(active_op_array));
+ pass_two(CG(active_op_array) TSRMLS_CC);
CG(active_op_array) = function_token->u.op_array;
/* Pop the switch and foreach seperators */
void zend_activate(TSRMLS_D);
void zend_deactivate(TSRMLS_D);
-void zend_activate_modules(void);
+void zend_activate_modules(TSRMLS_D);
void zend_deactivate_modules(TSRMLS_D);
zend_op *get_next_op(zend_op_array *op_array TSRMLS_DC);
void init_op(zend_op *op TSRMLS_DC);
int get_next_op_number(zend_op_array *op_array);
-int print_class(zend_class_entry *class_entry);
+int print_class(zend_class_entry *class_entry TSRMLS_DC);
void print_op_array(zend_op_array *op_array, int optimizations);
-int pass_two(zend_op_array *op_array);
+int pass_two(zend_op_array *op_array TSRMLS_DC);
zend_brk_cont_element *get_next_brk_cont_element(zend_op_array *op_array);
ZEND_API zend_bool zend_is_compiling(TSRMLS_D);
ZEND_API char *zend_make_compiled_string_description(char *name TSRMLS_DC);
}
-static int clean_non_persistent_constant(zend_constant *c)
+static int clean_non_persistent_constant(zend_constant *c TSRMLS_DC)
{
if (c->flags & CONST_PERSISTENT) {
return 0;
}
-static int clean_module_constant(zend_constant *c, int *module_number)
+static int clean_module_constant(zend_constant *c, int *module_number TSRMLS_DC)
{
if (c->module_number == *module_number) {
return 1;
void clean_module_constants(int module_number TSRMLS_DC)
{
- zend_hash_apply_with_argument(EG(zend_constants), (int (*)(void *,void *)) clean_module_constant, (void *) &module_number);
+ zend_hash_apply_with_argument(EG(zend_constants), (apply_func_arg_t) clean_module_constant, (void *) &module_number TSRMLS_CC);
}
void clean_non_persistent_constants(TSRMLS_D)
{
- zend_hash_apply(EG(zend_constants), (apply_func_t) clean_non_persistent_constant);
+ zend_hash_apply(EG(zend_constants), (apply_func_t) clean_non_persistent_constant TSRMLS_CC);
}
static void zend_fetch_dimension_address(znode *result, znode *op1, znode *op2, temp_variable *Ts, int type TSRMLS_DC);
static void zend_fetch_property_address(znode *result, znode *op1, znode *op2, temp_variable *Ts, int type TSRMLS_DC);
static void zend_fetch_dimension_address_from_tmp_var(znode *result, znode *op1, znode *op2, temp_variable *Ts TSRMLS_DC);
-static void zend_extension_statement_handler(zend_extension *extension, zend_op_array *op_array);
-static void zend_extension_fcall_begin_handler(zend_extension *extension, zend_op_array *op_array);
-static void zend_extension_fcall_end_handler(zend_extension *extension, zend_op_array *op_array);
+static void zend_extension_statement_handler(zend_extension *extension, zend_op_array *op_array TSRMLS_DC);
+static void zend_extension_fcall_begin_handler(zend_extension *extension, zend_op_array *op_array TSRMLS_DC);
+static void zend_extension_fcall_end_handler(zend_extension *extension, zend_op_array *op_array TSRMLS_DC);
#define RETURN_VALUE_USED(opline) (!((opline)->result.u.EA.type & EXT_TYPE_UNUSED))
/* Utility Functions for Extensions */
-static void zend_extension_statement_handler(zend_extension *extension, zend_op_array *op_array)
+static void zend_extension_statement_handler(zend_extension *extension, zend_op_array *op_array TSRMLS_DC)
{
if (extension->statement_handler) {
extension->statement_handler(op_array);
}
-static void zend_extension_fcall_begin_handler(zend_extension *extension, zend_op_array *op_array)
+static void zend_extension_fcall_begin_handler(zend_extension *extension, zend_op_array *op_array TSRMLS_DC)
{
if (extension->fcall_begin_handler) {
extension->fcall_begin_handler(op_array);
}
-static void zend_extension_fcall_end_handler(zend_extension *extension, zend_op_array *op_array)
+static void zend_extension_fcall_end_handler(zend_extension *extension, zend_op_array *op_array TSRMLS_DC)
{
if (extension->fcall_end_handler) {
extension->fcall_end_handler(op_array);
if (op2->u.fetch_type == ZEND_FETCH_LOCAL) {
FREE_OP(op1, free_op1);
} else if (op2->u.fetch_type == ZEND_FETCH_STATIC) {
- zval_update_constant(retval, (void *) 1);
+ zval_update_constant(retval, (void *) 1 TSRMLS_CC);
}
if (varname == &tmp_varname) {
#if ZEND_INTENSIVE_DEBUGGING
#define CHECK_SYMBOL_TABLES() \
- zend_hash_apply(&EG(symbol_table), (apply_func_t) zend_check_symbol); \
+ zend_hash_apply(&EG(symbol_table), (apply_func_t) zend_check_symbol TSRMLS_CC); \
if (&EG(symbol_table)!=EG(active_symbol_table)) { \
- zend_hash_apply(EG(active_symbol_table), (apply_func_t) zend_check_symbol); \
+ zend_hash_apply(EG(active_symbol_table), (apply_func_t) zend_check_symbol TSRMLS_CC); \
}
-static int zend_check_symbol(zval **pz)
+static int zend_check_symbol(zval **pz TSRMLS_DC)
{
if ((*pz)->type>9) {
fprintf(stderr, "Warning! %x has invalid type!\n", *pz);
} else if ((*pz)->type==IS_ARRAY) {
- zend_hash_apply((*pz)->value.ht, (apply_func_t) zend_check_symbol);
+ zend_hash_apply((*pz)->value.ht, (apply_func_t) zend_check_symbol TSRMLS_CC);
} else if ((*pz)->type==IS_OBJECT) {
- zend_hash_apply((*pz)->value.obj.properties, (apply_func_t) zend_check_symbol);
+ zend_hash_apply((*pz)->value.obj.properties, (apply_func_t) zend_check_symbol TSRMLS_CC);
}
return 0;
zval_copy_ctor(default_value);
}
default_value->refcount=1;
- zval_update_constant(&default_value, 0);
+ zval_update_constant(&default_value, 0 TSRMLS_CC);
default_value->refcount=0;
default_value->is_ref=0;
param = &default_value;
NEXT_OPCODE();
case ZEND_EXT_STMT:
if (!EG(no_extensions)) {
- zend_llist_apply_with_argument(&zend_extensions, (void (*)(void *, void *)) zend_extension_statement_handler, op_array);
+ zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_statement_handler, op_array TSRMLS_CC);
}
NEXT_OPCODE();
case ZEND_EXT_FCALL_BEGIN:
if (!EG(no_extensions)) {
- zend_llist_apply_with_argument(&zend_extensions, (void (*)(void *, void *)) zend_extension_fcall_begin_handler, op_array);
+ zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_fcall_begin_handler, op_array TSRMLS_CC);
}
NEXT_OPCODE();
case ZEND_EXT_FCALL_END:
if (!EG(no_extensions)) {
- zend_llist_apply_with_argument(&zend_extensions, (void (*)(void *, void *)) zend_extension_fcall_end_handler, op_array);
+ zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_fcall_end_handler, op_array TSRMLS_CC);
}
NEXT_OPCODE();
case ZEND_DECLARE_FUNCTION_OR_CLASS:
return result;
}
-ZEND_API int zval_update_constant(zval **pp, void *arg);
+ZEND_API int zval_update_constant(zval **pp, void *arg TSRMLS_DC);
/* dedicated Zend executor functions - do not use! */
static inline void zend_ptr_stack_clear_multiple(TSRMLS_D)
#endif
-static void zend_extension_activator(zend_extension *extension)
+static void zend_extension_activator(zend_extension *extension TSRMLS_DC)
{
if (extension->activate) {
extension->activate();
}
-static void zend_extension_deactivator(zend_extension *extension)
+static void zend_extension_deactivator(zend_extension *extension TSRMLS_DC)
{
if (extension->deactivate) {
extension->deactivate();
}
-static int is_not_internal_function(zend_function *function)
+static int is_not_internal_function(zend_function *function TSRMLS_DC)
{
return(function->type != ZEND_INTERNAL_FUNCTION);
}
-static int is_not_internal_class(zend_class_entry *ce)
+static int is_not_internal_class(zend_class_entry *ce TSRMLS_DC)
{
return(ce->type != ZEND_INTERNAL_CLASS);
}
zend_hash_init(&EG(symbol_table), 50, NULL, ZVAL_PTR_DTOR, 0);
EG(active_symbol_table) = &EG(symbol_table);
- zend_llist_apply(&zend_extensions, (void (*)(void *)) zend_extension_activator);
+ zend_llist_apply(&zend_extensions, (llist_apply_func_t) zend_extension_activator TSRMLS_CC);
EG(opline_ptr) = NULL;
EG(garbage_ptr) = 0;
efree(*EG(symtable_cache_ptr));
EG(symtable_cache_ptr)--;
}
- zend_llist_apply(&zend_extensions, (void (*)(void *)) zend_extension_deactivator);
+ zend_llist_apply(&zend_extensions, (llist_apply_func_t) zend_extension_deactivator TSRMLS_CC);
zend_hash_destroy(&EG(symbol_table));
zend_ptr_stack_destroy(&EG(argument_stack));
/* Destroy all op arrays */
- zend_hash_apply(EG(function_table), (apply_func_t) is_not_internal_function);
- zend_hash_apply(EG(class_table), (apply_func_t) is_not_internal_class);
+ zend_hash_apply(EG(function_table), (apply_func_t) is_not_internal_function TSRMLS_CC);
+ zend_hash_apply(EG(class_table), (apply_func_t) is_not_internal_class TSRMLS_CC);
} zend_end_try();
zend_destroy_rsrc_list(TSRMLS_C); /* must be destroyed after the main symbol table and
}
-ZEND_API int zval_update_constant(zval **pp, void *arg)
+ZEND_API int zval_update_constant(zval **pp, void *arg TSRMLS_DC)
{
zval *p = *pp;
zend_bool inline_change = (zend_bool) (unsigned long) arg;
zval const_value;
- TSRMLS_FETCH();
if (p->type == IS_CONSTANT) {
int refcount;
}
zend_hash_del(p->value.ht, str_index, str_index_len);
}
- zend_hash_apply_with_argument(p->value.ht, (int (*)(void *,void *)) zval_update_constant, (void *) 1);
+ zend_hash_apply_with_argument(p->value.ht, (apply_func_arg_t) zval_update_constant, (void *) 1 TSRMLS_CC);
}
return 0;
}
}
-static void zend_extension_shutdown(zend_extension *extension)
+static void zend_extension_shutdown(zend_extension *extension TSRMLS_DC)
{
#if ZEND_EXTENSIONS_SUPPORT
if (extension->shutdown) {
}
-void zend_shutdown_extensions()
+void zend_shutdown_extensions(TSRMLS_D)
{
- zend_llist_apply(&zend_extensions, (void (*)(void *)) zend_extension_shutdown);
+ zend_llist_apply(&zend_extensions, (llist_apply_func_t) zend_extension_shutdown TSRMLS_CC);
zend_llist_destroy(&zend_extensions);
}
}
-static void zend_extension_message_dispatcher(zend_extension *extension, int num_args, va_list args)
+static void zend_extension_message_dispatcher(zend_extension *extension, int num_args, va_list args TSRMLS_DC)
{
int message;
void *arg;
ZEND_API void zend_extension_dispatch_message(int message, void *arg)
{
- zend_llist_apply_with_arguments(&zend_extensions, (llist_apply_with_args_func_t) zend_extension_message_dispatcher, 2, message, arg);
+ TSRMLS_FETCH();
+
+ zend_llist_apply_with_arguments(&zend_extensions, (llist_apply_with_args_func_t) zend_extension_message_dispatcher TSRMLS_CC, 2, message, arg);
}
void zend_append_version_info(zend_extension *extension);
int zend_startup_extensions_mechanism(void);
int zend_startup_extensions(void);
-void zend_shutdown_extensions(void);
+void zend_shutdown_extensions(TSRMLS_D);
ZEND_API zend_extension *zend_get_extension(char *extension_name);
#endif /* ZEND_EXTENSIONS_H */
*/
-ZEND_API void zend_hash_apply(HashTable *ht, apply_func_t apply_func)
+ZEND_API void zend_hash_apply(HashTable *ht, apply_func_t apply_func TSRMLS_DC)
{
Bucket *p;
HASH_PROTECT_RECURSION(ht);
p = ht->pListHead;
while (p != NULL) {
- if (apply_func(p->pData)) {
+ if (apply_func(p->pData TSRMLS_CC)) {
p = zend_hash_apply_deleter(ht, p);
} else {
p = p->pListNext;
}
-ZEND_API void zend_hash_apply_with_argument(HashTable *ht, apply_func_arg_t apply_func, void *argument)
+ZEND_API void zend_hash_apply_with_argument(HashTable *ht, apply_func_arg_t apply_func, void *argument TSRMLS_DC)
{
Bucket *p;
typedef int (*compare_func_t)(const void *, const void *);
typedef void (*sort_func_t)(void *, size_t, register size_t, compare_func_t);
typedef void (*dtor_func_t)(void *pDest);
-typedef int (*apply_func_t)(void *pDest);
+typedef int (*apply_func_t)(void *pDest TSRMLS_DC);
typedef int (*apply_func_arg_t)(void *pDest, void *argument);
typedef void (*copy_ctor_func_t)(void *pElement);
typedef int (*apply_func_args_t)(void *pDest, int num_args, va_list args, zend_hash_key *hash_key);
ZEND_API void zend_hash_graceful_destroy(HashTable *ht);
-ZEND_API void zend_hash_apply(HashTable *ht, apply_func_t apply_func);
-ZEND_API void zend_hash_apply_with_argument(HashTable *ht, apply_func_arg_t apply_func, void *);
+ZEND_API void zend_hash_apply(HashTable *ht, apply_func_t apply_func TSRMLS_DC);
+ZEND_API void zend_hash_apply_with_argument(HashTable *ht, apply_func_arg_t apply_func, void * TSRMLS_DC);
ZEND_API void zend_hash_apply_with_arguments(HashTable *ht, apply_func_args_t apply_func, int, ...);
/*
* hash_apply functions
*/
-static int zend_remove_ini_entries(zend_ini_entry *ini_entry, int *module_number)
+static int zend_remove_ini_entries(zend_ini_entry *ini_entry, int *module_number TSRMLS_DC)
{
if (ini_entry->module_number == *module_number) {
return 1;
}
-static int zend_restore_ini_entry_cb(zend_ini_entry *ini_entry, int stage)
+static int zend_restore_ini_entry_cb(zend_ini_entry *ini_entry, int stage TSRMLS_DC)
{
- TSRMLS_FETCH();
-
if (ini_entry->modified) {
if (ini_entry->on_modify) {
ini_entry->on_modify(ini_entry, ini_entry->orig_value, ini_entry->orig_value_length, ini_entry->mh_arg1, ini_entry->mh_arg2, ini_entry->mh_arg3, stage TSRMLS_CC);
ZEND_API int zend_ini_deactivate(TSRMLS_D)
{
- zend_hash_apply_with_argument(&EG(ini_directives), (int (*)(void *, void *)) zend_restore_ini_entry_cb, (void *) ZEND_INI_STAGE_DEACTIVATE);
+ zend_hash_apply_with_argument(&EG(ini_directives), (apply_func_arg_t) zend_restore_ini_entry_cb, (void *) ZEND_INI_STAGE_DEACTIVATE TSRMLS_CC);
return SUCCESS;
}
ZEND_API void zend_unregister_ini_entries(int module_number)
{
- zend_hash_apply_with_argument(registered_zend_ini_directives, (int (*)(void *, void *)) zend_remove_ini_entries, (void *) &module_number);
+ TSRMLS_FETCH();
+
+ zend_hash_apply_with_argument(registered_zend_ini_directives, (apply_func_arg_t) zend_remove_ini_entries, (void *) &module_number TSRMLS_CC);
}
-static int zend_ini_refresh_cache(zend_ini_entry *p, int stage)
+static int zend_ini_refresh_cache(zend_ini_entry *p, int stage TSRMLS_DC)
{
- TSRMLS_FETCH();
-
if (p->on_modify) {
p->on_modify(p, p->value, p->value_length, p->mh_arg1, p->mh_arg2, p->mh_arg3, stage TSRMLS_CC);
}
ZEND_API void zend_ini_refresh_caches(int stage TSRMLS_DC)
{
- zend_hash_apply_with_argument(&EG(ini_directives), (int (*)(void *, void *)) zend_ini_refresh_cache, (void *)(long) stage);
+ zend_hash_apply_with_argument(&EG(ini_directives), (apply_func_arg_t) zend_ini_refresh_cache, (void *)(long) stage TSRMLS_CC);
}
return FAILURE;
}
- zend_restore_ini_entry_cb(ini_entry, stage);
+ zend_restore_ini_entry_cb(ini_entry, stage TSRMLS_CC);
return SUCCESS;
}
}
-static int clean_module_resource(zend_rsrc_list_entry *le, int *resource_id)
+static int clean_module_resource(zend_rsrc_list_entry *le, int *resource_id TSRMLS_DC)
{
if (le->type == *resource_id) {
return 1;
}
-static int zend_clean_module_rsrc_dtors_cb(zend_rsrc_list_dtors_entry *ld, int *module_number)
+static int zend_clean_module_rsrc_dtors_cb(zend_rsrc_list_dtors_entry *ld, int *module_number TSRMLS_DC)
{
if (ld->module_number == *module_number) {
- TSRMLS_FETCH();
-
- zend_hash_apply_with_argument(&EG(regular_list), (int (*)(void *,void *)) clean_module_resource, (void *) &(ld->resource_id));
- zend_hash_apply_with_argument(&EG(persistent_list), (int (*)(void *,void *)) clean_module_resource, (void *) &(ld->resource_id));
+ zend_hash_apply_with_argument(&EG(regular_list), (apply_func_arg_t) clean_module_resource, (void *) &(ld->resource_id) TSRMLS_CC);
+ zend_hash_apply_with_argument(&EG(persistent_list), (apply_func_arg_t) clean_module_resource, (void *) &(ld->resource_id) TSRMLS_CC);
return 1;
} else {
return 0;
}
-void zend_clean_module_rsrc_dtors(int module_number)
+void zend_clean_module_rsrc_dtors(int module_number TSRMLS_DC)
{
- zend_hash_apply_with_argument(&list_destructors, (int (*)(void *,void *)) zend_clean_module_rsrc_dtors_cb, (void *) &module_number);
+ zend_hash_apply_with_argument(&list_destructors, (apply_func_arg_t) zend_clean_module_rsrc_dtors_cb, (void *) &module_number TSRMLS_CC);
}
void list_entry_destructor(void *ptr);
void plist_entry_destructor(void *ptr);
-void zend_clean_module_rsrc_dtors(int module_number);
+void zend_clean_module_rsrc_dtors(int module_number TSRMLS_DC);
int zend_init_rsrc_list(TSRMLS_D);
int zend_init_rsrc_plist(TSRMLS_D);
void zend_destroy_rsrc_list(TSRMLS_D);
}
-ZEND_API void zend_llist_apply(zend_llist *l, void (*func)(void *data))
+ZEND_API void zend_llist_apply(zend_llist *l, llist_apply_func_t func TSRMLS_DC)
{
zend_llist_element *element;
for (element=l->head; element; element=element->next) {
- func(element->data);
+ func(element->data TSRMLS_CC);
}
}
}
-ZEND_API void zend_llist_apply_with_argument(zend_llist *l, void (*func)(void *data, void *arg), void *arg)
+ZEND_API void zend_llist_apply_with_argument(zend_llist *l, llist_apply_with_arg_func_t func, void *arg TSRMLS_DC)
{
zend_llist_element *element;
for (element=l->head; element; element=element->next) {
- func(element->data, arg);
+ func(element->data, arg TSRMLS_CC);
}
}
-ZEND_API void zend_llist_apply_with_arguments(zend_llist *l, llist_apply_with_args_func_t func, int num_args, ...)
+ZEND_API void zend_llist_apply_with_arguments(zend_llist *l, llist_apply_with_args_func_t func TSRMLS_DC, int num_args, ...)
{
zend_llist_element *element;
va_list args;
va_start(args, num_args);
for (element=l->head; element; element=element->next) {
- func(element->data, num_args, args);
+ func(element->data, num_args, args TSRMLS_CC);
}
va_end(args);
}
typedef void (*llist_dtor_func_t)(void *);
typedef int (*llist_compare_func_t)(const zend_llist_element *, const zend_llist_element *);
-typedef void (*llist_apply_with_arg_func_t)(void *data, void *arg);
-typedef void (*llist_apply_with_args_func_t)(void *data, int num_args, va_list args);
-typedef void (*llist_apply_func_t)(void *);
+typedef void (*llist_apply_with_args_func_t)(void *data, int num_args, va_list args TSRMLS_DC);
+typedef void (*llist_apply_with_arg_func_t)(void *data, void *arg TSRMLS_DC);
+typedef void (*llist_apply_func_t)(void * TSRMLS_DC);
typedef struct _zend_llist {
zend_llist_element *head;
ZEND_API void zend_llist_clean(zend_llist *l);
ZEND_API void zend_llist_remove_tail(zend_llist *l);
ZEND_API void zend_llist_copy(zend_llist *dst, zend_llist *src);
-ZEND_API void zend_llist_apply(zend_llist *l, llist_apply_func_t);
+ZEND_API void zend_llist_apply(zend_llist *l, llist_apply_func_t func TSRMLS_DC);
ZEND_API void zend_llist_apply_with_del(zend_llist *l, int (*func)(void *data));
-ZEND_API void zend_llist_apply_with_argument(zend_llist *l, llist_apply_with_arg_func_t, void *arg);
-ZEND_API void zend_llist_apply_with_arguments(zend_llist *l, llist_apply_with_args_func_t func, int num_args, ...);
+ZEND_API void zend_llist_apply_with_argument(zend_llist *l, llist_apply_with_arg_func_t func, void *arg TSRMLS_DC);
+ZEND_API void zend_llist_apply_with_arguments(zend_llist *l, llist_apply_with_args_func_t func TSRMLS_DC, int num_args, ...);
ZEND_API int zend_llist_count(zend_llist *l);
ZEND_API void zend_llist_sort(zend_llist *l, llist_compare_func_t comp_func);
extern ZEND_API HashTable module_registry;
void module_destructor(zend_module_entry *module);
-int module_registry_cleanup(zend_module_entry *module);
-int module_registry_request_startup(zend_module_entry *module);
+int module_registry_cleanup(zend_module_entry *module TSRMLS_DC);
+int module_registry_request_startup(zend_module_entry *module TSRMLS_DC);
#define ZEND_MODULE_DTOR (void (*)(void *)) module_destructor
#endif
#include "zend_API.h"
-static void zend_extension_op_array_ctor_handler(zend_extension *extension, zend_op_array *op_array)
+static void zend_extension_op_array_ctor_handler(zend_extension *extension, zend_op_array *op_array TSRMLS_DC)
{
if (extension->op_array_ctor) {
extension->op_array_ctor(op_array);
}
-static void zend_extension_op_array_dtor_handler(zend_extension *extension, zend_op_array *op_array)
+static void zend_extension_op_array_dtor_handler(zend_extension *extension, zend_op_array *op_array TSRMLS_DC)
{
if (extension->op_array_dtor) {
extension->op_array_dtor(op_array);
op_array->start_op = NULL;
- zend_llist_apply_with_argument(&zend_extensions, (void (*)(void *, void *)) zend_extension_op_array_ctor_handler, op_array);
+ zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_op_array_ctor_handler, op_array TSRMLS_CC);
}
{
zend_op *opline = op_array->opcodes;
zend_op *end = op_array->opcodes+op_array->last;
+ TSRMLS_FETCH();
if (op_array->static_variables) {
zend_hash_destroy(op_array->static_variables);
efree(op_array->brk_cont_array);
}
if (op_array->done_pass_two) {
- zend_llist_apply_with_argument(&zend_extensions, (void (*)(void *, void *)) zend_extension_op_array_dtor_handler, op_array);
+ zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_op_array_dtor_handler, op_array TSRMLS_CC);
}
}
-static void zend_extension_op_array_handler(zend_extension *extension, zend_op_array *op_array)
+static void zend_extension_op_array_handler(zend_extension *extension, zend_op_array *op_array TSRMLS_DC)
{
if (extension->op_array_handler) {
extension->op_array_handler(op_array);
}
-int pass_two(zend_op_array *op_array)
+int pass_two(zend_op_array *op_array TSRMLS_DC)
{
zend_op *opline, *end;
- TSRMLS_FETCH();
if (op_array->type!=ZEND_USER_FUNCTION && op_array->type!=ZEND_EVAL_CODE) {
return 0;
zend_update_extended_info(op_array TSRMLS_CC);
}
if (CG(handle_op_arrays)) {
- zend_llist_apply_with_argument(&zend_extensions, (void (*)(void *, void *)) zend_extension_op_array_handler, op_array);
+ zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_op_array_handler, op_array TSRMLS_CC);
}
opline = op_array->opcodes;
}
-int print_class(zend_class_entry *class_entry)
+int print_class(zend_class_entry *class_entry TSRMLS_DC)
{
printf("Class %s:\n", class_entry->name);
- zend_hash_apply(&class_entry->function_table, (apply_func_t) pass_two);
+ zend_hash_apply(&class_entry->function_table, (apply_func_t) pass_two TSRMLS_CC);
printf("End of class %s.\n\n", class_entry->name);
return 0;
}
{
PWDICT *pwdict;
long resource;
- TSRMLS_FETCH();
if (CRACKG(current_id) != -1) {
zend_error(E_WARNING, "Can not use more than one open dictionary with this implementation of libcrack");
return(wrapper);
}
-void *php_xpath_get_context(zval *wrapper, int rsrc_type1, int rsrc_type2)
+void *php_xpath_get_context(zval *wrapper, int rsrc_type1, int rsrc_type2 TSRMLS_DC)
{
void *obj;
zval **handle;
int type;
- TSRMLS_FETCH();
if (Z_TYPE_P(wrapper) != IS_OBJECT) {
php_error(E_ERROR, "Wrapper is not an object");
return(wrapper);
}
-void *php_dom_get_object(zval *wrapper, int rsrc_type1, int rsrc_type2)
+void *php_dom_get_object(zval *wrapper, int rsrc_type1, int rsrc_type2 TSRMLS_DC)
{
void *obj;
zval **handle;
int type;
- TSRMLS_FETCH();
if (Z_TYPE_P(wrapper) != IS_OBJECT) {
php_error(E_ERROR, "Wrapper is not an object");
xmlAttrPtr attrp;
id = getThis();
- attrp = php_dom_get_object(id, le_domxmlattrp, 0);
+ attrp = php_dom_get_object(id, le_domxmlattrp, 0 TSRMLS_CC);
RETURN_STRING((char *) (attrp->name), 1);
}
xmlAttrPtr attrp;
id = getThis();
- attrp = php_dom_get_object(id, le_domxmlattrp, 0);
+ attrp = php_dom_get_object(id, le_domxmlattrp, 0 TSRMLS_CC);
RETURN_STRING((char *) xmlNodeGetContent((xmlNodePtr) attrp), 1);
}
xmlAttrPtr attrp;
id = getThis();
- attrp = php_dom_get_object(id, le_domxmlattrp, 0);
+ attrp = php_dom_get_object(id, le_domxmlattrp, 0 TSRMLS_CC);
RETURN_TRUE;
}
xmlNodePtr nodep;
id = getThis();
- nodep = php_dom_get_object(id, le_domxmlpip, 0);
+ nodep = php_dom_get_object(id, le_domxmlpip, 0 TSRMLS_CC);
RETURN_STRING((char *)nodep->name, 1);
}
xmlNodePtr nodep;
id = getThis();
- nodep = php_dom_get_object(id, le_domxmlpip, 0);
+ nodep = php_dom_get_object(id, le_domxmlpip, 0 TSRMLS_CC);
RETURN_STRING(xmlNodeGetContent(nodep), 1);
}
xmlNodePtr nodep;
id = getThis();
- nodep = php_dom_get_object(id, le_domxmlcdatap, 0);
+ nodep = php_dom_get_object(id, le_domxmlcdatap, 0 TSRMLS_CC);
RETURN_LONG(1);
}
const char *str = NULL;
id = getThis();
- n = php_dom_get_object(id, le_domxmlnodep, 0);
+ n = php_dom_get_object(id, le_domxmlnodep, 0 TSRMLS_CC);
switch (n->type)
{
char *str = NULL;
id = getThis();
- n = php_dom_get_object(id, le_domxmlnodep, 0);
+ n = php_dom_get_object(id, le_domxmlnodep, 0 TSRMLS_CC);
if (!n) {
RETURN_FALSE;
xmlNode *n;
id = getThis();
- n = php_dom_get_object(id, le_domxmlnodep, 0);
+ n = php_dom_get_object(id, le_domxmlnodep, 0 TSRMLS_CC);
if (!n) {
RETURN_FALSE;
int ret;
id = getThis();
- nodep = php_dom_get_object(id, le_domxmlnodep, 0);
+ nodep = php_dom_get_object(id, le_domxmlnodep, 0 TSRMLS_CC);
first = nodep->children;
if (!first) {
int ret;
id = getThis();
- nodep = php_dom_get_object(id, le_domxmlnodep, 0);
+ nodep = php_dom_get_object(id, le_domxmlnodep, 0 TSRMLS_CC);
last = nodep->last;
if (!last) {
int ret;
id = getThis();
- if(NULL == (nodep = php_dom_get_object(id, le_domxmlnodep, 0)))
+ if(NULL == (nodep = php_dom_get_object(id, le_domxmlnodep, 0 TSRMLS_CC)))
RETURN_FALSE;
first = nodep->next;
int ret;
id = getThis();
- if(NULL == (nodep = php_dom_get_object(id, le_domxmlnodep, 0)))
+ if(NULL == (nodep = php_dom_get_object(id, le_domxmlnodep, 0 TSRMLS_CC)))
RETURN_FALSE;
first = nodep->prev;
int ret;
id = getThis();
- if(NULL == (nodep = php_dom_get_object(id, le_domxmlnodep, 0)))
+ if(NULL == (nodep = php_dom_get_object(id, le_domxmlnodep, 0 TSRMLS_CC)))
RETURN_FALSE;
docp = nodep->doc;
xmlNode *nodep;
id = getThis();
- if(NULL == (nodep = php_dom_get_object(id, le_domxmlnodep, 0)))
+ if(NULL == (nodep = php_dom_get_object(id, le_domxmlnodep, 0 TSRMLS_CC)))
RETURN_FALSE;
if (nodep->children) {
xmlNode *nodep;
id = getThis();
- if(NULL == (nodep = php_dom_get_object(id, le_domxmlnodep, 0)))
+ if(NULL == (nodep = php_dom_get_object(id, le_domxmlnodep, 0 TSRMLS_CC)))
RETURN_FALSE;
if(nodep->type != XML_ELEMENT_NODE)
xmlNsPtr ns;
id = getThis();
- if(NULL == (nodep = php_dom_get_object(id, le_domxmlnodep, 0)))
+ if(NULL == (nodep = php_dom_get_object(id, le_domxmlnodep, 0 TSRMLS_CC)))
RETURN_FALSE;
ns = nodep->ns;
int ret;
id = getThis();
- nodep = php_dom_get_object(id, le_domxmlnodep, 0);
+ nodep = php_dom_get_object(id, le_domxmlnodep, 0 TSRMLS_CC);
last = nodep->parent;
if (!last) {
int ret;
id = getThis();
- nodep = php_dom_get_object(id, le_domxmlnodep, le_domxmldocp);
+ nodep = php_dom_get_object(id, le_domxmlnodep, le_domxmldocp TSRMLS_CC);
/* Even if the nodep is a XML_DOCUMENT_NODE the type is at the
same position.
xmlNode *nodep;
id = getThis();
- nodep = php_dom_get_object(id, le_domxmlnodep, 0);
+ nodep = php_dom_get_object(id, le_domxmlnodep, 0 TSRMLS_CC);
xmlUnlinkNode(nodep);
xmlFreeNode(nodep);
WRONG_PARAM_COUNT;
}
id = getThis();
- nodep = php_dom_get_object(id, le_domxmlnodep, 0);
- child = php_dom_get_object(node, le_domxmlnodep, 0);
+ nodep = php_dom_get_object(id, le_domxmlnodep, 0 TSRMLS_CC);
+ child = php_dom_get_object(node, le_domxmlnodep, 0 TSRMLS_CC);
if (!child || !nodep) {
RETURN_FALSE;
WRONG_PARAM_COUNT;
}
id = getThis();
- nodep = php_dom_get_object(id, le_domxmlnodep, 0);
- child = php_dom_get_object(node, le_domxmlnodep, 0);
+ nodep = php_dom_get_object(id, le_domxmlnodep, 0 TSRMLS_CC);
+ child = php_dom_get_object(node, le_domxmlnodep, 0 TSRMLS_CC);
if (!child || !nodep) {
RETURN_FALSE;
WRONG_PARAM_COUNT;
}
id = getThis();
- nodep = php_dom_get_object(id, le_domxmlnodep, 0);
- child = php_dom_get_object(node, le_domxmlnodep, 0);
- refp = php_dom_get_object(ref, le_domxmlnodep, 0);
+ nodep = php_dom_get_object(id, le_domxmlnodep, 0 TSRMLS_CC);
+ child = php_dom_get_object(node, le_domxmlnodep, 0 TSRMLS_CC);
+ refp = php_dom_get_object(ref, le_domxmlnodep, 0 TSRMLS_CC);
if (!child || !nodep || !refp) {
RETURN_FALSE;
}
id = getThis();
- nodep = php_dom_get_object(id, le_domxmlnodep, 0);
+ nodep = php_dom_get_object(id, le_domxmlnodep, 0 TSRMLS_CC);
convert_to_string(name);
if(name->value.str.len)
#endif
id = getThis();
- nodep = php_dom_get_object(id, le_domxmlnodep, 0);
+ nodep = php_dom_get_object(id, le_domxmlnodep, 0 TSRMLS_CC);
if(node_attributes(&attrs, nodep) < 0)
RETURN_FALSE;
WRONG_PARAM_COUNT;
}
id = getThis();
- nodep = php_dom_get_object(id, le_domxmlnodep, 0);
+ nodep = php_dom_get_object(id, le_domxmlnodep, 0 TSRMLS_CC);
convert_to_string(name);
convert_to_string(content);
}
id = getThis();
- nodep = php_dom_get_object(id, le_domxmlnodep, 0);
+ nodep = php_dom_get_object(id, le_domxmlnodep, 0 TSRMLS_CC);
convert_to_string(content);
if(content->value.str.len)
xmlNotationPtr nodep;
id = getThis();
- nodep = (xmlNotationPtr) php_dom_get_object(id, le_domxmlnotationp, 0);
+ nodep = (xmlNotationPtr) php_dom_get_object(id, le_domxmlnotationp, 0 TSRMLS_CC);
RETURN_STRING((char *) (nodep->PublicID), 1);
}
xmlNotationPtr nodep;
id = getThis();
- nodep = (xmlNotationPtr) php_dom_get_object(id, le_domxmlnotationp, 0);
+ nodep = (xmlNotationPtr) php_dom_get_object(id, le_domxmlnotationp, 0 TSRMLS_CC);
RETURN_STRING((char *) (nodep->SystemID), 1);
}
xmlNode *nodep;
id = getThis();
- nodep = php_dom_get_object(id, le_domxmlelementp, 0);
+ nodep = php_dom_get_object(id, le_domxmlelementp, 0 TSRMLS_CC);
RETURN_STRING((char *) (nodep->name), 1);
}
if ((ZEND_NUM_ARGS() == 1) && getParameters(ht, 1, &arg1) == SUCCESS) {
id = getThis();
- nodep = php_dom_get_object(id, le_domxmlelementp, 0);
+ nodep = php_dom_get_object(id, le_domxmlelementp, 0 TSRMLS_CC);
} else {
WRONG_PARAM_COUNT;
}
if ((ZEND_NUM_ARGS() == 2) && getParameters(ht, 2, &arg1, &arg2) == SUCCESS) {
id = getThis();
- nodep = php_dom_get_object(id, le_domxmlelementp, 0);
+ nodep = php_dom_get_object(id, le_domxmlelementp, 0 TSRMLS_CC);
} else {
WRONG_PARAM_COUNT;
}
if ((ZEND_NUM_ARGS() == 1) && getParameters(ht, 1, &arg1) == SUCCESS) {
id = getThis();
- nodep = php_dom_get_object(id, le_domxmlelementp, 0);
+ nodep = php_dom_get_object(id, le_domxmlelementp, 0 TSRMLS_CC);
} else {
WRONG_PARAM_COUNT;
}
if ((ZEND_NUM_ARGS() == 1) && getParameters(ht, 1, &arg1) == SUCCESS) {
id = getThis();
- nodep = php_dom_get_object(id, le_domxmlelementp, 0);
+ nodep = php_dom_get_object(id, le_domxmlelementp, 0 TSRMLS_CC);
} else {
WRONG_PARAM_COUNT;
}
if ((ZEND_NUM_ARGS() == 1) && getParameters(ht, 1, &arg1) == SUCCESS) {
id = getThis();
- nodep = php_dom_get_object(id, le_domxmlelementp, 0);
- attrp = php_dom_get_object(arg1, le_domxmlattrp, 0);
+ nodep = php_dom_get_object(id, le_domxmlelementp, 0 TSRMLS_CC);
+ attrp = php_dom_get_object(arg1, le_domxmlattrp, 0 TSRMLS_CC);
} else {
WRONG_PARAM_COUNT;
}
if ((ZEND_NUM_ARGS() == 1) && getParameters(ht, 1, &arg1) == SUCCESS) {
id = getThis();
- nodep = php_dom_get_object(id, le_domxmlelementp, 0);
+ nodep = php_dom_get_object(id, le_domxmlelementp, 0 TSRMLS_CC);
} else {
WRONG_PARAM_COUNT;
}
xmlNodePtr attrp;
id = getThis();
- attrp = php_dom_get_object(id, le_domxmldoctypep, 0);
+ attrp = php_dom_get_object(id, le_domxmldoctypep, 0 TSRMLS_CC);
RETURN_STRING((char *) (attrp->name), 1);
}
int ret;
id = getThis();
- if(NULL == (docp = php_dom_get_object(id, le_domxmldocp, 0))) {
+ if(NULL == (docp = php_dom_get_object(id, le_domxmldocp, 0 TSRMLS_CC))) {
RETURN_FALSE;
}
xmlDocPtr docp;
id = getThis();
- if(NULL == (docp = php_dom_get_object(id, le_domxmldocp, 0))) {
+ if(NULL == (docp = php_dom_get_object(id, le_domxmldocp, 0 TSRMLS_CC))) {
RETURN_FALSE;
}
}
}
- docp = php_dom_get_object(id, le_domxmldocp, 0);
+ docp = php_dom_get_object(id, le_domxmldocp, 0 TSRMLS_CC);
node = docp->children;
if (!node) {
int ret;
id = getThis();
- if(NULL == (docp = php_dom_get_object(id, le_domxmldocp, 0))) {
+ if(NULL == (docp = php_dom_get_object(id, le_domxmldocp, 0 TSRMLS_CC))) {
RETURN_FALSE;
}
int ret;
id = getThis();
- if(NULL == (docp = php_dom_get_object(id, le_domxmldocp, 0))) {
+ if(NULL == (docp = php_dom_get_object(id, le_domxmldocp, 0 TSRMLS_CC))) {
RETURN_FALSE;
}
int ret;
id = getThis();
- if(NULL == (docp = php_dom_get_object(id, le_domxmldocp, 0))) {
+ if(NULL == (docp = php_dom_get_object(id, le_domxmldocp, 0 TSRMLS_CC))) {
RETURN_FALSE;
}
int ret;
id = getThis();
- if(NULL == (docp = php_dom_get_object(id, le_domxmldocp, 0))) {
+ if(NULL == (docp = php_dom_get_object(id, le_domxmldocp, 0 TSRMLS_CC))) {
RETURN_FALSE;
}
int ret;
id = getThis();
- if(NULL == (docp = php_dom_get_object(id, le_domxmldocp, 0))) {
+ if(NULL == (docp = php_dom_get_object(id, le_domxmldocp, 0 TSRMLS_CC))) {
RETURN_FALSE;
}
int ret;
id = getThis();
- if(NULL == (docp = php_dom_get_object(id, le_domxmldocp, 0))) {
+ if(NULL == (docp = php_dom_get_object(id, le_domxmldocp, 0 TSRMLS_CC))) {
RETURN_FALSE;
}
if (ZEND_NUM_ARGS() != 2 || getParameters(ht, 2, &arg1, &arg2) == FAILURE) {
WRONG_PARAM_COUNT;
}
- srcnode = php_dom_get_object(arg1, le_domxmlnodep, 0);
+ srcnode = php_dom_get_object(arg1, le_domxmlnodep, 0 TSRMLS_CC);
if(!srcnode)
RETURN_FALSE;
int ret;
id = getThis();
- docp = php_dom_get_object(id, le_domxmldocp, 0);
+ docp = php_dom_get_object(id, le_domxmldocp, 0 TSRMLS_CC);
dtd = xmlGetIntSubset(docp);
if (!dtd) {
int size;
id = getThis();
- if(NULL == (docp = php_dom_get_object(id, le_domxmldocp, 0))) {
+ if(NULL == (docp = php_dom_get_object(id, le_domxmldocp, 0 TSRMLS_CC))) {
RETURN_FALSE;
}
}
id = getThis();
- nodep = php_dom_get_object(id, le_domxmlnodep, 0);
+ nodep = php_dom_get_object(id, le_domxmlnodep, 0 TSRMLS_CC);
convert_to_string(content);
if(content->value.str.len)
}
id = getThis();
- docp = php_dom_get_object(id, le_domxmldocp, 0);
+ docp = php_dom_get_object(id, le_domxmldocp, 0 TSRMLS_CC);
convert_to_string(name);
nodep = xmlNewDocNode(docp, NULL, name->value.str.val, NULL);
int ret;
id = getThis();
- docp = php_dom_get_object(id, le_domxmldocp, 0);
+ docp = php_dom_get_object(id, le_domxmldocp, 0 TSRMLS_CC);
#if defined(LIBXML_XPTR_ENABLED)
if(mode == PHP_XPTR)
}
id = getThis();
- ctxp = php_xpath_get_context(id, le_xpathctxp, 0);
+ ctxp = php_xpath_get_context(id, le_xpathctxp, 0 TSRMLS_CC);
convert_to_string(str);
#if defined(LIBXML_XPTR_ENABLED)
}
}
-void php_register_DOTNET_class(void)
+void php_register_DOTNET_class(TSRMLS_D)
{
- TSRMLS_FETCH();
-
INIT_OVERLOADED_CLASS_ENTRY(dotnet_class_entry, "DOTNET", NULL,
php_DOTNET_call_function_handler,
php_COM_get_property_handler,
PHP_MINIT_FUNCTION(DOTNET)
{
HRESULT hr;
+
CoInitialize(0);
hr = dotnet_init();
- if (FAILED(hr)) return hr;
+ if (FAILED(hr)) {
+ return hr;
+ }
- php_register_DOTNET_class();
+ php_register_DOTNET_class(TSRMLS_C);
return SUCCESS;
}
FDFErc err;
ASInt32 nBytes;
zval *array_ptr = (zval *) arg;
- TSRMLS_FETCH();
fp=php_open_temporary_file(NULL,"fdfdata.",&filename);
if(!fp) {
#if !defined(COMPILE_DL_MBSTRING)
SAPI_POST_HANDLER_FUNC(php_mbstr_post_handler)
{
- TSRMLS_FETCH();
-
MBSTRG(http_input_identify_post) = mbfl_no_encoding_invalid;
php_mbstr_encoding_handler(arg, SG(request_info).post_data, "&");
return 0;
}
-static int _clean_invalid_results(list_entry *le)
+static int _clean_invalid_results(list_entry *le TSRMLS_DC)
{
- TSRMLS_FETCH();
-
if (le->type == le_result) {
mssql_link *mssql_ptr = ((mssql_result *) le->ptr)->mssql_ptr;
TSRMLS_FETCH();
mssql_ptr->valid = 0;
- zend_hash_apply(&EG(regular_list),(apply_func_t) _clean_invalid_results);
+ zend_hash_apply(&EG(regular_list),(apply_func_t) _clean_invalid_results TSRMLS_CC);
dbclose(mssql_ptr->link);
dbfreelogin(mssql_ptr->login);
efree(mssql_ptr);
return SUCCESS;
}
-static int _session_pcleanup(oci_session *session)
+static int _session_pcleanup(oci_session *session TSRMLS_DC)
{
_oci_close_session(session);
return 1;
}
-static int _server_pcleanup(oci_server *server)
+static int _server_pcleanup(oci_server *server TSRMLS_DC)
{
_oci_close_server(server);
oci_debug("START php_mshutdown_oci");
- zend_hash_apply(OCI(user), (apply_func_t)_session_pcleanup);
- zend_hash_apply(OCI(server), (apply_func_t)_server_pcleanup);
+ zend_hash_apply(OCI(user), (apply_func_t)_session_pcleanup TSRMLS_CC);
+ zend_hash_apply(OCI(server), (apply_func_t)_server_pcleanup TSRMLS_CC);
zend_hash_destroy(OCI(user));
zend_hash_destroy(OCI(server));
#if 0
/* XXX free all statements, rollback all outstanding transactions */
- zend_hash_apply(OCI(user), (apply_func_t) _session_cleanup);
- zend_hash_apply(OCI(server), (apply_func_t) _server_cleanup);
+ zend_hash_apply(OCI(user), (apply_func_t) _session_cleanup TSRMLS_CC);
+ zend_hash_apply(OCI(server), (apply_func_t) _server_cleanup TSRMLS_CC);
#endif
oci_debug("END php_rshutdown_oci");
/* {{{ _oci_bind_pre_exec() */
static int
-_oci_bind_pre_exec(void *data)
+_oci_bind_pre_exec(void *data TSRMLS_DC)
{
oci_bind *bind = (oci_bind *) data;
/* {{{ _oci_bind_post_exec() */
static int
-_oci_bind_post_exec(void *data)
+_oci_bind_post_exec(void *data TSRMLS_DC)
{
oci_bind *bind = (oci_bind *) data;
int dtype;
dvoid *buf;
oci_descriptor *descr;
+ TSRMLS_FETCH();
statement->error =
oci_error(statement->pError,
we don't want to execute!!! */
if (statement->binds) {
- zend_hash_apply(statement->binds, (apply_func_t) _oci_bind_pre_exec);
+ zend_hash_apply(statement->binds, (apply_func_t) _oci_bind_pre_exec TSRMLS_CC);
}
statement->error =
NULL,
mode));
if (statement->binds) {
- zend_hash_apply(statement->binds, (apply_func_t) _oci_bind_post_exec);
+ zend_hash_apply(statement->binds, (apply_func_t) _oci_bind_post_exec TSRMLS_CC);
}
oci_handle_error(statement->conn, statement->error);
/* {{{ oci_fetch() */
static int
-_oci_column_pre_fetch(void *data)
+_oci_column_pre_fetch(void *data TSRMLS_DC)
{
oci_out_column *col = (oci_out_column *) data;
oci_out_column *column;
if (statement->columns) {
- zend_hash_apply(statement->columns, (apply_func_t) _oci_column_pre_fetch);
+ zend_hash_apply(statement->columns, (apply_func_t) _oci_column_pre_fetch TSRMLS_CC);
}
statement->error =
/* {{{ _oci_close_server()
*/
-static int _oci_session_cleanup(void *data)
+static int _oci_session_cleanup(void *data TSRMLS_DC)
{
list_entry *le = (list_entry *) data;
if (le->type == le_session) {
char *dbname;
int oldopen;
TSRMLS_FETCH();
- TSRMLS_FETCH();
oldopen = server->is_open;
server->is_open = 2;
if (! OCI(shutdown)) {
- zend_hash_apply(&EG(regular_list), _oci_session_cleanup);
+ zend_hash_apply(&EG(regular_list), (apply_func_t) _oci_session_cleanup TSRMLS_CC);
}
server->is_open = oldopen;
connection->is_open = 0;
- zend_hash_apply(list, (apply_func_t) _stmt_cleanup);
+ zend_hash_apply(list, (apply_func_t) _stmt_cleanup TSRMLS_CC);
if (zend_list_delete(connection->id) == SUCCESS) {
RETURN_TRUE;
RETURN_TRUE;
}
-static int _close_pconn_with_id(list_entry *le, int *id)
+static int _close_pconn_with_id(list_entry *le, int *id TSRMLS_DC)
{
-
if(le->type == le_pconn && (((odbc_connection *)(le->ptr))->id == *id)){
return 1;
}else{
zend_list_delete(i);
/* Delete the persistent connection */
zend_hash_apply_with_argument(&EG(persistent_list),
- (int (*)(void *, void *)) _close_pconn_with_id, (void *) &i);
+ (apply_func_arg_t) _close_pconn_with_id, (void *) &i TSRMLS_CC);
}
}
}
if(is_pconn){
zend_hash_apply_with_argument(&EG(persistent_list),
- (int (*)(void *, void *)) _close_pconn_with_id, (void *) &((*pv_conn)->value.lval));
+ (apply_func_arg_t) _close_pconn_with_id, (void *) &((*pv_conn)->value.lval) TSRMLS_CC);
}
}
/* }}} */
/* {{{ _rollback_transactions
*/
-static int _rollback_transactions(zend_rsrc_list_entry *rsrc)
+static int _rollback_transactions(zend_rsrc_list_entry *rsrc TSRMLS_DC)
{
PGconn *link;
- TSRMLS_FETCH();
if (rsrc->type != le_plink)
return 0;
*/
PHP_RSHUTDOWN_FUNCTION(pgsql)
{
- zend_hash_apply(&EG(persistent_list), (apply_func_t) _rollback_transactions);
+ zend_hash_apply(&EG(persistent_list), (apply_func_t) _rollback_transactions TSRMLS_CC);
return SUCCESS;
}
/* }}} */
}
}
-void php_register_DOTNET_class(void)
+void php_register_DOTNET_class(TSRMLS_D)
{
- TSRMLS_FETCH();
-
INIT_OVERLOADED_CLASS_ENTRY(dotnet_class_entry, "DOTNET", NULL,
php_DOTNET_call_function_handler,
php_COM_get_property_handler,
PHP_MINIT_FUNCTION(DOTNET)
{
HRESULT hr;
+
CoInitialize(0);
hr = dotnet_init();
- if (FAILED(hr)) return hr;
+ if (FAILED(hr)) {
+ return hr;
+ }
- php_register_DOTNET_class();
+ php_register_DOTNET_class(TSRMLS_C);
return SUCCESS;
}
efree(tick_function_entry->arguments);
}
-static int user_shutdown_function_call(php_shutdown_function_entry *shutdown_function_entry)
+static int user_shutdown_function_call(php_shutdown_function_entry *shutdown_function_entry TSRMLS_DC)
{
zval retval;
- TSRMLS_FETCH();
if (call_user_function(EG(function_table), NULL, shutdown_function_entry->arguments[0], &retval, shutdown_function_entry->arg_count-1, shutdown_function_entry->arguments+1 TSRMLS_CC)==SUCCESS) {
zval_dtor(&retval);
return 0;
}
-static void user_tick_function_call(user_tick_function_entry *tick_fe)
+static void user_tick_function_call(user_tick_function_entry *tick_fe TSRMLS_DC)
{
zval retval;
zval *function = tick_fe->arguments[0];
- TSRMLS_FETCH();
if (call_user_function(EG(function_table), NULL, function, &retval,
tick_fe->arg_count - 1, tick_fe->arguments+1 TSRMLS_CC) == SUCCESS) {
{
TSRMLS_FETCH();
- zend_llist_apply(BG(user_tick_functions), (llist_apply_func_t)user_tick_function_call);
+ zend_llist_apply(BG(user_tick_functions), (llist_apply_func_t) user_tick_function_call TSRMLS_CC);
}
static int user_tick_function_compare(user_tick_function_entry *tick_fe1,
TSRMLS_FETCH();
if (BG(user_shutdown_function_names)) zend_try {
- zend_hash_apply(BG(user_shutdown_function_names), (apply_func_t) user_shutdown_function_call);
+ zend_hash_apply(BG(user_shutdown_function_names), (apply_func_t) user_shutdown_function_call TSRMLS_CC);
memcpy(&EG(bailout), &orig_bailout, sizeof(jmp_buf));
zend_hash_destroy(BG(user_shutdown_function_names));
efree(BG(user_shutdown_function_names));
/* {{{ _display_module_info
*/
-static int _display_module_info(zend_module_entry *module, void *arg)
+static int _display_module_info(zend_module_entry *module, void *arg TSRMLS_DC)
{
int show_info_func = *((int *) arg);
- TSRMLS_FETCH();
if (show_info_func && module->info_func) {
php_printf("<h2 align=\"center\"><a name=\"module_%s\">%s</a></h2>\n", module->name, module->name);
int show_info_func;
show_info_func = 1;
- zend_hash_apply_with_argument(&module_registry, (int (*)(void *, void *)) _display_module_info, &show_info_func);
+ zend_hash_apply_with_argument(&module_registry, (apply_func_arg_t) _display_module_info, &show_info_func TSRMLS_CC);
SECTION("Additional Modules");
php_info_print_table_start();
show_info_func = 0;
- zend_hash_apply_with_argument(&module_registry, (int (*)(void *, void *)) _display_module_info, &show_info_func);
+ zend_hash_apply_with_argument(&module_registry, (apply_func_arg_t) _display_module_info, &show_info_func TSRMLS_CC);
php_info_print_table_end();
}
}
-static int _clean_invalid_results(list_entry *le)
+static int _clean_invalid_results(list_entry *le TSRMLS_DC)
{
if (le->type == php_sybase_module.le_result) {
sybase_link *sybase_ptr = ((sybase_result *) le->ptr)->sybase_ptr;
will *not* be in a consistent state. thies@thieso.net
*/
- zend_hash_apply(&EG(regular_list), (apply_func_t) _clean_invalid_results);
+ zend_hash_apply(&EG(regular_list), (apply_func_t) _clean_invalid_results TSRMLS_CC);
dbclose(sybase_ptr->link);
dbloginfree(sybase_ptr->login);
efree(sybase_ptr);
#define CHECK_LINK(link) { if (link==-1) { php_error(E_WARNING, "Sybase: A link to the server could not be established"); RETURN_FALSE; } }
-static int _clean_invalid_results(list_entry *le)
+static int _clean_invalid_results(list_entry *le TSRMLS_DC)
{
- TSRMLS_FETCH();
-
if (le->type == le_result) {
sybase_link *sybase_ptr = ((sybase_result *) le->ptr)->sybase_ptr;
sybase_ptr->valid = 0;
- zend_hash_apply(&EG(regular_list), (apply_func_t) _clean_invalid_results);
+ zend_hash_apply(&EG(regular_list), (apply_func_t) _clean_invalid_results TSRMLS_CC);
/* Non-persistent connections will always be connected or we wouldn't
* get here, but since we want to check the death status anyway
http_status_line.header = SG(sapi_headers).http_status_line;
http_status_line.header_len = strlen(SG(sapi_headers).http_status_line);
- sapi_module.send_header(&http_status_line, SG(server_context));
+ sapi_module.send_header(&http_status_line, SG(server_context) TSRMLS_CC);
}
- zend_llist_apply_with_argument(&SG(sapi_headers).headers, (void (*)(void *, void *)) sapi_module.send_header, SG(server_context));
+ zend_llist_apply_with_argument(&SG(sapi_headers).headers, (llist_apply_with_arg_func_t) sapi_module.send_header, SG(server_context) TSRMLS_CC);
if(SG(sapi_headers).send_default_content_type) {
sapi_header_struct default_header;
sapi_get_default_content_type_header(&default_header TSRMLS_CC);
- sapi_module.send_header(&default_header, SG(server_context));
+ sapi_module.send_header(&default_header, SG(server_context) TSRMLS_CC);
sapi_free_header(&default_header);
}
- sapi_module.send_header(NULL, SG(server_context));
+ sapi_module.send_header(NULL, SG(server_context) TSRMLS_CC);
ret = SUCCESS;
break;
case SAPI_HEADER_SEND_FAILED:
int (*header_handler)(sapi_header_struct *sapi_header, sapi_headers_struct *sapi_headers TSRMLS_DC);
int (*send_headers)(sapi_headers_struct *sapi_headers TSRMLS_DC);
- void (*send_header)(sapi_header_struct *sapi_header, void *server_context);
+ void (*send_header)(sapi_header_struct *sapi_header, void *server_context TSRMLS_DC);
int (*read_post)(char *buffer, uint count_bytes TSRMLS_DC);
char *(*read_cookies)(TSRMLS_D);
/* {{{ php_disable_functions
*/
-static void php_disable_functions()
+static void php_disable_functions(TSRMLS_D)
{
char *func;
char *new_value_dup = strdup(INI_STR("disable_functions")); /* This is an intentional leak,
func = strtok(new_value_dup, ", ");
while (func) {
- zend_disable_function(func, strlen(func));
+ zend_disable_function(func, strlen(func) TSRMLS_CC);
func = strtok(NULL, ", ");
}
}
/* PG(during_request_startup) = 0; */
php_hash_environment(TSRMLS_C);
- zend_activate_modules();
+ zend_activate_modules(TSRMLS_C);
PG(modules_activated)=1;
} zend_catch {
retval = FAILURE;
which is always an internal extension and to be initialized
ahead of all other internals
*/
- php_ini_delayed_modules_startup();
+ php_ini_delayed_modules_startup(TSRMLS_C);
/* disable certain functions as requested by php.ini */
- php_disable_functions();
+ php_disable_functions(TSRMLS_C);
zend_startup_extensions();
php_shutdown_ticks(TSRMLS_C);
sapi_flush();
- zend_shutdown();
+ zend_shutdown(TSRMLS_C);
php_shutdown_fopen_wrappers();
php_shutdown_info_logos();
UNREGISTER_INI_ENTRIES();
/* {{{ php_ini_displayer
*/
-static int php_ini_displayer(zend_ini_entry *ini_entry, int module_number)
+static int php_ini_displayer(zend_ini_entry *ini_entry, int module_number TSRMLS_DC)
{
if (ini_entry->module_number != module_number) {
return 0;
}
php_info_print_table_start();
php_info_print_table_header(3, "Directive", "Local Value", "Master Value");
- zend_hash_apply_with_argument(&EG(ini_directives), (apply_func_arg_t) php_ini_displayer, (void *) (long) module_number);
+ zend_hash_apply_with_argument(&EG(ini_directives), (apply_func_arg_t) php_ini_displayer, (void *) (long) module_number TSRMLS_CC);
php_info_print_table_end();
}
/* }}} */
/* {{{ php_load_function_extension_cb
*/
-static void php_load_function_extension_cb(void *arg)
+static void php_load_function_extension_cb(void *arg TSRMLS_DC)
{
zval *extension = (zval *) arg;
zval zval;
/* {{{ php_load_zend_extension_cb
*/
-static void php_load_zend_extension_cb(void *arg)
+static void php_load_zend_extension_cb(void *arg TSRMLS_DC)
{
zend_load_extension(*((char **) arg));
}
/* {{{ php_ini_delayed_modules_startup
*/
-void php_ini_delayed_modules_startup(void)
+void php_ini_delayed_modules_startup(TSRMLS_D)
{
- zend_llist_apply(&extension_lists.engine, php_load_zend_extension_cb);
- zend_llist_apply(&extension_lists.functions, php_load_function_extension_cb);
+ zend_llist_apply(&extension_lists.engine, php_load_zend_extension_cb TSRMLS_CC);
+ zend_llist_apply(&extension_lists.functions, php_load_function_extension_cb TSRMLS_CC);
zend_llist_destroy(&extension_lists.engine);
zend_llist_destroy(&extension_lists.functions);
int php_init_config(char *php_ini_path_override);
int php_shutdown_config(void);
-void php_ini_delayed_modules_startup(void);
+void php_ini_delayed_modules_startup(TSRMLS_D);
zval *cfg_get_entry(char *name, uint name_length);
#define PHP_INI_USER ZEND_INI_USER
(int(*)(void*,void*))php_compare_tick_functions);
}
-static void php_tick_iterator(void *data, void *arg)
+static void php_tick_iterator(void *data, void *arg TSRMLS_DC)
{
void (*func)(int);
memcpy(&func, data, sizeof(void(*)(int)));
func(*((int *)arg));
+ return SUCCESS;
}
void php_run_ticks(int count)
{
TSRMLS_FETCH();
- zend_llist_apply_with_argument(&PG(tick_functions), (void(*)(void*,void*))php_tick_iterator, &count);
+ zend_llist_apply_with_argument(&PG(tick_functions), (llist_apply_with_arg_func_t) php_tick_iterator, &count TSRMLS_CC);
}
/*
}
-static int unlink_filename(char **filename)
+static int unlink_filename(char **filename TSRMLS_DC)
{
VCWD_UNLINK(*filename);
return 0;
void destroy_uploaded_files_hash(TSRMLS_D)
{
- zend_hash_apply(SG(rfc1867_uploaded_files), (apply_func_t) unlink_filename);
+ zend_hash_apply(SG(rfc1867_uploaded_files), (apply_func_t) unlink_filename TSRMLS_CC);
zend_hash_destroy(SG(rfc1867_uploaded_files));
FREE_HASHTABLE(SG(rfc1867_uploaded_files));
}
/* {{{ php_apache_alter_ini_entries
*/
-static int php_apache_alter_ini_entries(php_per_dir_entry *per_dir_entry)
+static int php_apache_alter_ini_entries(php_per_dir_entry *per_dir_entry TSRMLS_DC)
{
zend_alter_ini_entry(per_dir_entry->key, per_dir_entry->key_length+1, per_dir_entry->value, per_dir_entry->value_length, per_dir_entry->type, PHP_INI_STAGE_ACTIVATE);
return 0;
int retval;
HashTable *per_dir_conf;
TSRMLS_FETCH();
- TSRMLS_FETCH();
- TSRMLS_FETCH();
if (AP(in_request)) {
zend_file_handle fh;
per_dir_conf = (HashTable *) get_module_config(r->per_dir_config, &php4_module);
if (per_dir_conf) {
- zend_hash_apply((HashTable *) per_dir_conf, (apply_func_t) php_apache_alter_ini_entries);
+ zend_hash_apply((HashTable *) per_dir_conf, (apply_func_t) php_apache_alter_ini_entries TSRMLS_CC);
}
/* If PHP parser engine has been turned off with an "engine off"
#define OPTSTRING "aCc:d:ef:g:hilmnqs?vz:"
-static int _print_module_info ( zend_module_entry *module, void *arg ) {
+static int _print_module_info(zend_module_entry *module, void *arg TSRMLS_DC)
+{
php_printf("%s\n", module->name);
return 0;
}
}
-static void sapi_cgi_send_header(sapi_header_struct *sapi_header, void *server_context)
+static void sapi_cgi_send_header(sapi_header_struct *sapi_header, void *server_context TSRMLS_DC)
{
if (sapi_header) {
PHPWRITE_H(sapi_header->header, sapi_header->header_len);
}
-static void php_register_command_line_global_vars(char **arg)
+static void php_register_command_line_global_vars(char **arg TSRMLS_DC)
{
char *var, *val;
- TSRMLS_FETCH();
var = *arg;
val = strchr(var, '=');
SG(headers_sent) = 1;
php_printf("Running PHP %s\n%s\n", PHP_VERSION , get_zend_version());
php_printf("[PHP Modules]\n");
- zend_hash_apply_with_argument(&module_registry, (int (*)(void *, void *)) _print_module_info, NULL);
- php_printf("\n[Zend Modules]\n");
- zend_llist_apply_with_argument(&zend_extensions, (void (*)(void *, void *)) _print_module_info, NULL);
+ zend_hash_apply_with_argument(&module_registry, (apply_func_arg_t) _print_module_info, NULL TSRMLS_CC);
+ php_printf("\n[Zend Modules]\n");
+ /* zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) _print_module_info, NULL TSRMLS_CC); */
+ php_printf("Not Implemented\n");
php_printf("\n");
php_end_ob_buffers(1);
exit(1);
file_handle.free_filename = 0;
/* This actually destructs the elements of the list - ugly hack */
- zend_llist_apply(&global_vars, (llist_apply_func_t) php_register_command_line_global_vars);
+ zend_llist_apply(&global_vars, (llist_apply_func_t) php_register_command_line_global_vars TSRMLS_CC);
zend_llist_destroy(&global_vars);
if (!cgi) {
}
-static void sapi_fastcgi_send_header(sapi_header_struct *sapi_header, void *server_context)
+static void sapi_fastcgi_send_header(sapi_header_struct *sapi_header, void *server_context TSRMLS_DC)
{
if( sapi_header ) {
#ifdef DEBUG_FASTCGI
-static void accumulate_header_length(sapi_header_struct *sapi_header, uint *total_length)
+static void accumulate_header_length(sapi_header_struct *sapi_header, uint *total_length TSRMLS_DC)
{
*total_length += sapi_header->header_len+2;
}
-static void concat_header(sapi_header_struct *sapi_header, char **combined_headers_ptr)
+static void concat_header(sapi_header_struct *sapi_header, char **combined_headers_ptr TSRMLS_DC)
{
memcpy(*combined_headers_ptr, sapi_header->header, sapi_header->header_len);
*combined_headers_ptr += sapi_header->header_len;
/* Obtain headers length */
if (SG(sapi_headers).send_default_content_type) {
sapi_get_default_content_type_header(&default_content_type TSRMLS_CC);
- accumulate_header_length(&default_content_type, (void *) &total_length);
+ accumulate_header_length(&default_content_type, (void *) &total_length TSRMLS_CC);
}
- zend_llist_apply_with_argument(&SG(sapi_headers).headers, (void (*)(void *, void *)) accumulate_header_length, (void *) &total_length);
+ zend_llist_apply_with_argument(&SG(sapi_headers).headers, (llist_apply_with_arg_func_t) accumulate_header_length, (void *) &total_length TSRMLS_CC);
/* Generate headers */
combined_headers = (char *) emalloc(total_length+1);
combined_headers_ptr = combined_headers;
if (SG(sapi_headers).send_default_content_type) {
- concat_header(&default_content_type, (void *) &combined_headers_ptr);
+ concat_header(&default_content_type, (void *) &combined_headers_ptr TSRMLS_CC);
sapi_free_header(&default_content_type); /* we no longer need it */
}
- zend_llist_apply_with_argument(&SG(sapi_headers).headers, (void (*)(void *, void *)) concat_header, (void *) &combined_headers_ptr);
+ zend_llist_apply_with_argument(&SG(sapi_headers).headers, (llist_apply_with_arg_func_t) concat_header, (void *) &combined_headers_ptr TSRMLS_CC);
*combined_headers_ptr++ = '\r';
*combined_headers_ptr++ = '\n';
*combined_headers_ptr = 0;
-static void accumulate_header_length(sapi_header_struct *sapi_header, uint *total_length)
+static void accumulate_header_length(sapi_header_struct *sapi_header, uint *total_length TSRMLS_DC)
{
*total_length += sapi_header->header_len+2;
}
-static void concat_header(sapi_header_struct *sapi_header, char **combined_headers_ptr)
+static void concat_header(sapi_header_struct *sapi_header, char **combined_headers_ptr TSRMLS_DC)
{
memcpy(*combined_headers_ptr, sapi_header->header, sapi_header->header_len);
*combined_headers_ptr += sapi_header->header_len;
if (SG(sapi_headers).send_default_content_type) {
sapi_get_default_content_type_header(&default_content_type TSRMLS_CC);
- accumulate_header_length(&default_content_type, (void *) &total_length);
+ accumulate_header_length(&default_content_type, (void *) &total_length TSRMLS_CC);
}
- zend_llist_apply_with_argument(&SG(sapi_headers).headers, (void (*)(void *, void *)) accumulate_header_length, (void *) &total_length);
+ zend_llist_apply_with_argument(&SG(sapi_headers).headers, (llist_apply_with_arg_func_t) accumulate_header_length, (void *) &total_length TSRMLS_CC);
/* Generate headers */
combined_headers = (char *) emalloc(total_length+1);
concat_header(&default_content_type, (void *) &combined_headers_ptr);
sapi_free_header(&default_content_type); /* we no longer need it */
}
- zend_llist_apply_with_argument(&SG(sapi_headers).headers, (void (*)(void *, void *)) concat_header, (void *) &combined_headers_ptr);
+ zend_llist_apply_with_argument(&SG(sapi_headers).headers, (llist_apply_with_arg_func_t) concat_header, (void *) &combined_headers_ptr TSRMLS_CC);
*combined_headers_ptr++ = '\r';
*combined_headers_ptr++ = '\n';
*combined_headers_ptr = 0;
}
-static void sapi_servlet_send_header(sapi_header_struct *sapi_header, void *server_context)
+static void sapi_servlet_send_header(sapi_header_struct *sapi_header, void *server_context TSRMLS_DC)
{
- TSRMLS_FETCH();
if (!sapi_header) return;
if (!SG(server_context)) return;
projects / php / commitdiff