This patch is *bound* to break some files, as I must have had typos somewhere.
If you use any uncommon extension, please try to build it...
#ifdef ZTS
-static void compiler_globals_ctor(zend_compiler_globals *compiler_globals)
+static void compiler_globals_ctor(zend_compiler_globals *compiler_globals TSRMLS_DC)
{
zend_function tmp_func;
zend_class_entry tmp_class;
}
-static void compiler_globals_dtor(zend_compiler_globals *compiler_globals)
+static void compiler_globals_dtor(zend_compiler_globals *compiler_globals TSRMLS_DC)
{
if (compiler_globals->function_table != global_function_table) {
zend_hash_destroy(compiler_globals->function_table);
}
-static void executor_globals_ctor(zend_executor_globals *executor_globals)
+static void executor_globals_ctor(zend_executor_globals *executor_globals TSRMLS_DC)
{
if (global_constants_table) {
- zend_startup_constants(ELS_C);
- zend_copy_constants(executor_globals->zend_constants, global_constants_table);
+ zend_startup_constants(TSRMLS_C);
+ zend_copy_constants(EG(zend_constants), global_constants_table);
}
- zend_init_rsrc_plist(ELS_C);
+ zend_init_rsrc_plist(TSRMLS_C);
EG(lambda_count)=0;
EG(user_error_handler) = NULL;
EG(in_execution) = 0;
}
-static void executor_globals_dtor(zend_executor_globals *executor_globals)
+static void executor_globals_dtor(zend_executor_globals *executor_globals TSRMLS_DC)
{
- zend_shutdown_constants(ELS_C);
- zend_destroy_rsrc_plist(ELS_C);
- zend_ini_shutdown(ELS_C);
+ zend_shutdown_constants(TSRMLS_C);
+ zend_destroy_rsrc_plist(TSRMLS_C);
+ zend_ini_shutdown(TSRMLS_C);
}
-static void alloc_globals_ctor(zend_alloc_globals *alloc_globals)
+static void alloc_globals_ctor(zend_alloc_globals *alloc_globals TSRMLS_DC)
{
start_memory_manager(ALS_C);
}
#ifdef ZTS
static void zend_new_thread_end_handler(THREAD_T thread_id)
{
- ELS_FETCH();
+ TSRMLS_FETCH();
- zend_copy_ini_directives(ELS_C);
- zend_ini_refresh_caches(ZEND_INI_STAGE_STARTUP ELS_CC);
+ zend_copy_ini_directives(TSRMLS_C);
+ zend_ini_refresh_caches(ZEND_INI_STAGE_STARTUP TSRMLS_CC);
}
#endif
#ifdef ZTS
zend_compiler_globals *compiler_globals;
zend_executor_globals *executor_globals;
+ void ***tsrm_ls;
- alloc_globals_id = ts_allocate_id(sizeof(zend_alloc_globals), (ts_allocate_ctor) alloc_globals_ctor, NULL);
+ ts_allocate_id(&alloc_globals_id, sizeof(zend_alloc_globals), (ts_allocate_ctor) alloc_globals_ctor, NULL);
#else
start_memory_manager(ALS_C);
#endif
#ifdef ZTS
global_constants_table = NULL;
- compiler_globals_id = ts_allocate_id(sizeof(zend_compiler_globals), (void (*)(void *)) compiler_globals_ctor, (void (*)(void *)) compiler_globals_dtor);
- executor_globals_id = ts_allocate_id(sizeof(zend_executor_globals), (void (*)(void *)) executor_globals_ctor, (void (*)(void *)) executor_globals_dtor);
+ ts_allocate_id(&compiler_globals_id, sizeof(zend_compiler_globals), (ts_allocate_ctor) compiler_globals_ctor, (ts_allocate_dtor) compiler_globals_dtor);
+ ts_allocate_id(&executor_globals_id, sizeof(zend_executor_globals), (ts_allocate_ctor) executor_globals_ctor, (ts_allocate_dtor) executor_globals_dtor);
compiler_globals = ts_resource(compiler_globals_id);
executor_globals = ts_resource(executor_globals_id);
- compiler_globals_dtor(compiler_globals);
+ tsrm_ls = ts_resource_ex(0, NULL);
+ compiler_globals_dtor(compiler_globals, tsrm_ls);
compiler_globals->function_table = GLOBAL_FUNCTION_TABLE;
compiler_globals->class_table = GLOBAL_CLASS_TABLE;
- zend_startup_constants(executor_globals);
+ zend_startup_constants(tsrm_ls);
GLOBAL_CONSTANTS_TABLE = EG(zend_constants);
#else
zend_startup_constants();
zend_set_default_compile_time_values(CLS_C);
EG(user_error_handler) = NULL;
#endif
- zend_register_standard_constants(ELS_C);
+ zend_register_standard_constants(TSRMLS_C);
#ifndef ZTS
- zend_init_rsrc_plist(ELS_C);
+ zend_init_rsrc_plist(TSRMLS_C);
#endif
if (start_builtin_functions) {
zend_startup_builtin_functions();
}
- zend_ini_startup(ELS_C);
+ zend_ini_startup(TSRMLS_C);
#ifdef ZTS
tsrm_set_new_thread_end_handler(zend_new_thread_end_handler);
ZEND_API void _zend_bailout(char *filename, uint lineno)
{
CLS_FETCH();
- ELS_FETCH();
+ TSRMLS_FETCH();
if (!EG(bailout_set)) {
zend_output_debug_string(1, "%s(%d) : Bailed out without a bailout address!", filename, lineno);
}
-void zend_activate(CLS_D ELS_DC)
+void zend_activate(CLS_D TSRMLS_DC)
{
EG(bailout_set) = 0;
- init_compiler(CLS_C ELS_CC);
- init_executor(CLS_C ELS_CC);
+ init_compiler(CLS_C TSRMLS_CC);
+ init_executor(CLS_C TSRMLS_CC);
startup_scanner(CLS_C);
}
void zend_deactivate_modules()
{
- ELS_FETCH();
+ TSRMLS_FETCH();
EG(opline_ptr) = NULL; /* we're no longer executing anything */
zend_try {
} zend_end_try();
}
-void zend_deactivate(CLS_D ELS_DC)
+void zend_deactivate(CLS_D TSRMLS_DC)
{
/* we're no longer executing anything */
EG(opline_ptr) = NULL;
} zend_end_try();
/* shutdown_executor() takes care of its own bailout handling */
- shutdown_executor(ELS_C);
+ shutdown_executor(TSRMLS_C);
zend_try {
shutdown_compiler(CLS_C);
} zend_end_try();
zend_try {
- zend_ini_deactivate(ELS_C);
+ zend_ini_deactivate(TSRMLS_C);
} zend_end_try();
}
char *error_filename;
uint error_lineno;
zval *orig_user_error_handler;
- ELS_FETCH();
+ TSRMLS_FETCH();
CLS_FETCH();
/* Obtain relevant filename and lineno */
error_filename = zend_get_compiled_filename(CLS_C);
error_lineno = zend_get_compiled_lineno(CLS_C);
} else if (zend_is_executing()) {
- error_filename = zend_get_executed_filename(ELS_C);
- error_lineno = zend_get_executed_lineno(ELS_C);
+ error_filename = zend_get_executed_filename(TSRMLS_C);
+ error_lineno = zend_get_executed_lineno(TSRMLS_C);
} else {
error_filename = NULL;
error_lineno = 0;
}
-ZEND_API int zend_execute_scripts(int type CLS_DC ELS_DC, int file_count, ...)
+ZEND_API int zend_execute_scripts(int type CLS_DC TSRMLS_DC, int file_count, ...)
{
va_list files;
int i;
EG(active_op_array) = zend_compile_file(file_handle, ZEND_INCLUDE CLS_CC);
zend_destroy_file_handle(file_handle CLS_CC);
if (EG(active_op_array)) {
- zend_execute(EG(active_op_array) ELS_CC);
+ zend_execute(EG(active_op_array) TSRMLS_CC);
zval_ptr_dtor(EG(return_value_ptr_ptr));
EG(return_value_ptr_ptr) = &EG(global_return_value_ptr);
EG(global_return_value_ptr) = NULL;
int cur_lineno;
char *compiled_string_description;
CLS_FETCH();
- ELS_FETCH();
+ TSRMLS_FETCH();
if (zend_is_compiling()) {
cur_filename = zend_get_compiled_filename(CLS_C);
cur_lineno = zend_get_compiled_lineno(CLS_C);
} else if (zend_is_executing()) {
- cur_filename = zend_get_executed_filename(ELS_C);
- cur_lineno = zend_get_executed_lineno(ELS_C);
+ cur_filename = zend_get_executed_filename(TSRMLS_C);
+ cur_lineno = zend_get_executed_lineno(TSRMLS_C);
} else {
cur_filename = "Unknown";
cur_lineno = 0;
#include "zend_hash.h"
#include "zend_llist.h"
-#define INTERNAL_FUNCTION_PARAMETERS int ht, zval *return_value, zval *this_ptr, int return_value_used ELS_DC
-#define INTERNAL_FUNCTION_PARAM_PASSTHRU ht, return_value, this_ptr, return_value_used ELS_CC
+#define INTERNAL_FUNCTION_PARAMETERS int ht, zval *return_value, zval *this_ptr, int return_value_used TSRMLS_DC
+#define INTERNAL_FUNCTION_PARAM_PASSTHRU ht, return_value, this_ptr, return_value_used TSRMLS_CC
/*
* zval
int arg_count;
va_list ptr;
zval **param, *param_ptr;
- ELS_FETCH();
+ TSRMLS_FETCH();
p = EG(argument_stack).top_element-2;
arg_count = (ulong) *p;
void **p;
int arg_count;
zval *param_ptr;
- ELS_FETCH();
+ TSRMLS_FETCH();
p = EG(argument_stack).top_element-2;
arg_count = (ulong) *p;
int arg_count;
va_list ptr;
zval ***param;
- ELS_FETCH();
+ TSRMLS_FETCH();
p = EG(argument_stack).top_element-2;
arg_count = (ulong) *p;
{
void **p;
int arg_count;
- ELS_FETCH();
+ TSRMLS_FETCH();
p = EG(argument_stack).top_element-2;
arg_count = (ulong) *p;
void **p;
ulong arg_count;
zval *arg;
- ELS_FETCH();
+ TSRMLS_FETCH();
p = EG(argument_stack).elements+EG(argument_stack).top-2;
arg_count = (ulong) *p;
void **p;
int arg_count;
int quiet = flags & ZEND_PARSE_PARAMS_QUIET;
- ELS_FETCH();
+ TSRMLS_FETCH();
for (spec_walk = type_spec; *spec_walk; spec_walk++) {
c = *spec_walk;
if (module) {
module->module_number = zend_next_free_module();
if (module->module_startup_func) {
- ELS_FETCH();
+ TSRMLS_FETCH();
- if (module->module_startup_func(MODULE_PERSISTENT, module->module_number ELS_CC)==FAILURE) {
+ if (module->module_startup_func(MODULE_PERSISTENT, module->module_number TSRMLS_CC)==FAILURE) {
zend_error(E_CORE_ERROR,"Unable to start %s module",module->name);
return FAILURE;
}
int module_registry_request_startup(zend_module_entry *module)
{
if (module->request_startup_func) {
- ELS_FETCH();
+ TSRMLS_FETCH();
#if 0
zend_printf("%s: Request startup\n",module->name);
#endif
- if (module->request_startup_func(module->type, module->module_number ELS_CC)==FAILURE) {
+ if (module->request_startup_func(module->type, module->module_number TSRMLS_CC)==FAILURE) {
zend_error(E_WARNING, "request_startup() for %s module failed", module->name);
exit(1);
}
{
char *lcname;
int retval = 0;
- ELS_FETCH();
+ TSRMLS_FETCH();
switch (Z_TYPE_P(callable)) {
case IS_STRING:
#define ZEND_EXTERN_MODULE_GLOBALS(module_name) \
extern ts_rsrc_id module_name##_globals_id;
#define ZEND_INIT_MODULE_GLOBALS(module_name, globals_ctor, globals_dtor) \
- module_name##_globals_id = ts_allocate_id(sizeof(zend_##module_name##_globals), (ts_allocate_ctor) globals_ctor, (ts_allocate_dtor) globals_dtor);
+ ts_allocate_id(&module_name##_globals_id, sizeof(zend_##module_name##_globals), (ts_allocate_ctor) globals_ctor, (ts_allocate_dtor) globals_dtor);
#else
c.flags = case_sensitive; /* non persistent */
c.name = zend_strndup((*var)->value.str.val, (*var)->value.str.len);
c.name_len = (*var)->value.str.len+1;
- if (zend_register_constant(&c ELS_CC) == SUCCESS) {
+ if (zend_register_constant(&c TSRMLS_CC) == SUCCESS) {
RETURN_TRUE;
} else {
RETURN_FALSE;
sprintf(eval_code, "function " LAMBDA_TEMP_FUNCNAME "(%s){%s}", Z_STRVAL_PP(z_function_args), Z_STRVAL_PP(z_function_code));
eval_name = zend_make_compiled_string_description("runtime-created function");
- retval = zend_eval_string(eval_code, NULL, eval_name CLS_CC ELS_CC);
+ retval = zend_eval_string(eval_code, NULL, eval_name CLS_CC TSRMLS_CC);
efree(eval_code);
efree(eval_name);
}
-void init_compiler(CLS_D ELS_DC)
+void init_compiler(CLS_D TSRMLS_DC)
{
zend_init_compiler_data_structures(CLS_C);
- zend_init_rsrc_list(ELS_C);
+ zend_init_rsrc_list(TSRMLS_C);
zend_hash_init(&CG(filenames_table), 5, NULL, (dtor_func_t) free_estring, 0);
zend_llist_init(&CG(open_files), sizeof(zend_file_handle), (void (*)(void *)) zend_file_handle_dtor, 0);
CG(unclean_shutdown) = 0;
BEGIN_EXTERN_C()
-void init_compiler(CLS_D ELS_DC);
+void init_compiler(CLS_D TSRMLS_DC);
void shutdown_compiler(CLS_D);
void zend_init_compiler_data_structures(CLS_D);
extern ZEND_API zend_op_array *(*zend_compile_file)(zend_file_handle *file_handle, int type CLS_DC);
-void zend_activate(CLS_D ELS_DC);
-void zend_deactivate(CLS_D ELS_DC);
+void zend_activate(CLS_D TSRMLS_DC);
+void zend_deactivate(CLS_D TSRMLS_DC);
void zend_activate_modules(void);
void zend_deactivate_modules(void);
/* helper functions in zend_language_scanner.l */
ZEND_API zend_op_array *compile_file(zend_file_handle *file_handle, int type CLS_DC);
ZEND_API zend_op_array *compile_string(zval *source_string, char *filename CLS_DC);
-ZEND_API zend_op_array *compile_filename(int type, zval *filename CLS_DC ELS_DC);
-ZEND_API int zend_execute_scripts(int type CLS_DC ELS_DC, int file_count, ...);
+ZEND_API zend_op_array *compile_filename(int type, zval *filename CLS_DC TSRMLS_DC);
+ZEND_API int zend_execute_scripts(int type CLS_DC TSRMLS_DC, int file_count, ...);
ZEND_API int open_file_for_scanning(zend_file_handle *file_handle CLS_DC);
ZEND_API void init_op_array(zend_op_array *op_array, int type, int initial_ops_size CLS_DC);
ZEND_API void destroy_op_array(zend_op_array *op_array);
void clean_module_constants(int module_number)
{
- ELS_FETCH();
+ TSRMLS_FETCH();
zend_hash_apply_with_argument(EG(zend_constants), (int (*)(void *,void *)) clean_module_constant, (void *) &module_number);
}
-int zend_startup_constants(ELS_D)
+int zend_startup_constants(TSRMLS_D)
{
#ifdef ZEND_WIN32
DWORD dwBuild=0;
-void zend_register_standard_constants(ELS_D)
+void zend_register_standard_constants(TSRMLS_D)
{
REGISTER_MAIN_LONG_CONSTANT("E_ERROR", E_ERROR, CONST_PERSISTENT | CONST_CS);
REGISTER_MAIN_LONG_CONSTANT("E_WARNING", E_WARNING, CONST_PERSISTENT | CONST_CS);
c.name_len = sizeof("TRUE");
c.value.value.lval = 1;
c.value.type = IS_BOOL;
- zend_register_constant(&c ELS_CC);
+ zend_register_constant(&c TSRMLS_CC);
c.name = zend_strndup(ZEND_STRL("FALSE"));
c.name_len = sizeof("FALSE");
c.value.value.lval = 0;
c.value.type = IS_BOOL;
- zend_register_constant(&c ELS_CC);
+ zend_register_constant(&c TSRMLS_CC);
c.name = zend_strndup(ZEND_STRL("ZEND_THREAD_SAFE"));
c.name_len = sizeof("ZEND_THREAD_SAFE");
c.value.value.lval = ZTS_V;
c.value.type = IS_BOOL;
- zend_register_constant(&c ELS_CC);
+ zend_register_constant(&c TSRMLS_CC);
c.name = zend_strndup(ZEND_STRL("NULL"));
c.name_len = sizeof("NULL");
c.value.type = IS_NULL;
- zend_register_constant(&c ELS_CC);
+ zend_register_constant(&c TSRMLS_CC);
}
}
-int zend_shutdown_constants(ELS_D)
+int zend_shutdown_constants(TSRMLS_D)
{
zend_hash_destroy(EG(zend_constants));
free(EG(zend_constants));
void clean_non_persistent_constants(void)
{
- ELS_FETCH();
+ TSRMLS_FETCH();
zend_hash_apply(EG(zend_constants), (int (*)(void *)) clean_non_persistent_constant);
}
-ZEND_API void zend_register_long_constant(char *name, uint name_len, long lval, int flags, int module_number ELS_DC)
+ZEND_API void zend_register_long_constant(char *name, uint name_len, long lval, int flags, int module_number TSRMLS_DC)
{
zend_constant c;
c.name = zend_strndup(name,name_len);
c.name_len = name_len;
c.module_number = module_number;
- zend_register_constant(&c ELS_CC);
+ zend_register_constant(&c TSRMLS_CC);
}
-ZEND_API void zend_register_double_constant(char *name, uint name_len, double dval, int flags, int module_number ELS_DC)
+ZEND_API void zend_register_double_constant(char *name, uint name_len, double dval, int flags, int module_number TSRMLS_DC)
{
zend_constant c;
c.name = zend_strndup(name,name_len);
c.name_len = name_len;
c.module_number = module_number;
- zend_register_constant(&c ELS_CC);
+ zend_register_constant(&c TSRMLS_CC);
}
-ZEND_API void zend_register_stringl_constant(char *name, uint name_len, char *strval, uint strlen, int flags, int module_number ELS_DC)
+ZEND_API void zend_register_stringl_constant(char *name, uint name_len, char *strval, uint strlen, int flags, int module_number TSRMLS_DC)
{
zend_constant c;
c.name = zend_strndup(name,name_len);
c.name_len = name_len;
c.module_number = module_number;
- zend_register_constant(&c ELS_CC);
+ zend_register_constant(&c TSRMLS_CC);
}
-ZEND_API void zend_register_string_constant(char *name, uint name_len, char *strval, int flags, int module_number ELS_DC)
+ZEND_API void zend_register_string_constant(char *name, uint name_len, char *strval, int flags, int module_number TSRMLS_DC)
{
- zend_register_stringl_constant(name, name_len, strval, strlen(strval), flags, module_number ELS_CC);
+ zend_register_stringl_constant(name, name_len, strval, strlen(strval), flags, module_number TSRMLS_CC);
}
zend_constant *c;
char *lookup_name = estrndup(name,name_len);
int retval;
- ELS_FETCH();
+ TSRMLS_FETCH();
zend_str_tolower(lookup_name, name_len);
}
-ZEND_API int zend_register_constant(zend_constant *c ELS_DC)
+ZEND_API int zend_register_constant(zend_constant *c TSRMLS_DC)
{
char *lowercase_name = zend_strndup(c->name, c->name_len);
int ret = SUCCESS;
int module_number;
} zend_constant;
-#define REGISTER_LONG_CONSTANT(name,lval,flags) zend_register_long_constant((name),sizeof(name),(lval),(flags),module_number ELS_CC)
-#define REGISTER_DOUBLE_CONSTANT(name,dval,flags) zend_register_double_constant((name),sizeof(name),(dval),(flags),module_number ELS_CC)
-#define REGISTER_STRING_CONSTANT(name,str,flags) zend_register_string_constant((name),sizeof(name),(str),(flags),module_number ELS_CC)
-#define REGISTER_STRINGL_CONSTANT(name,str,len,flags) zend_register_stringl_constant((name),sizeof(name),(str),(len),(flags),module_number ELS_CC)
+#define REGISTER_LONG_CONSTANT(name,lval,flags) zend_register_long_constant((name),sizeof(name),(lval),(flags),module_number TSRMLS_CC)
+#define REGISTER_DOUBLE_CONSTANT(name,dval,flags) zend_register_double_constant((name),sizeof(name),(dval),(flags),module_number TSRMLS_CC)
+#define REGISTER_STRING_CONSTANT(name,str,flags) zend_register_string_constant((name),sizeof(name),(str),(flags),module_number TSRMLS_CC)
+#define REGISTER_STRINGL_CONSTANT(name,str,len,flags) zend_register_stringl_constant((name),sizeof(name),(str),(len),(flags),module_number TSRMLS_CC)
-#define REGISTER_MAIN_LONG_CONSTANT(name,lval,flags) zend_register_long_constant((name),sizeof(name),(lval),(flags),0 ELS_CC)
-#define REGISTER_MAIN_DOUBLE_CONSTANT(name,dval,flags) zend_register_double_constant((name),sizeof(name),(dval),(flags),0 ELS_CC)
-#define REGISTER_MAIN_STRING_CONSTANT(name,str,flags) zend_register_string_constant((name),sizeof(name),(str),(flags),0 ELS_CC)
-#define REGISTER_MAIN_STRINGL_CONSTANT(name,str,len,flags) zend_register_stringl_constant((name),sizeof(name),(str),(len),(flags),0 ELS_CC)
+#define REGISTER_MAIN_LONG_CONSTANT(name,lval,flags) zend_register_long_constant((name),sizeof(name),(lval),(flags),0 TSRMLS_CC)
+#define REGISTER_MAIN_DOUBLE_CONSTANT(name,dval,flags) zend_register_double_constant((name),sizeof(name),(dval),(flags),0 TSRMLS_CC)
+#define REGISTER_MAIN_STRING_CONSTANT(name,str,flags) zend_register_string_constant((name),sizeof(name),(str),(flags),0 TSRMLS_CC)
+#define REGISTER_MAIN_STRINGL_CONSTANT(name,str,len,flags) zend_register_stringl_constant((name),sizeof(name),(str),(len),(flags),0 TSRMLS_CC)
void clean_module_constants(int module_number);
void free_zend_constant(zend_constant *c);
-int zend_startup_constants(ELS_D);
-int zend_shutdown_constants(ELS_D);
-void zend_register_standard_constants(ELS_D);
+int zend_startup_constants(TSRMLS_D);
+int zend_shutdown_constants(TSRMLS_D);
+void zend_register_standard_constants(TSRMLS_D);
void clean_non_persistent_constants(void);
ZEND_API int zend_get_constant(char *name, uint name_len, zval *result);
-ZEND_API void zend_register_long_constant(char *name, uint name_len, long lval, int flags, int module_number ELS_DC);
-ZEND_API void zend_register_double_constant(char *name, uint name_len, double dval, int flags, int module_number ELS_DC);
-ZEND_API void zend_register_string_constant(char *name, uint name_len, char *strval, int flags, int module_number ELS_DC);
-ZEND_API void zend_register_stringl_constant(char *name, uint name_len, char *strval, uint strlen, int flags, int module_number ELS_DC);
-ZEND_API int zend_register_constant(zend_constant *c ELS_DC);
+ZEND_API void zend_register_long_constant(char *name, uint name_len, long lval, int flags, int module_number TSRMLS_DC);
+ZEND_API void zend_register_double_constant(char *name, uint name_len, double dval, int flags, int module_number TSRMLS_DC);
+ZEND_API void zend_register_string_constant(char *name, uint name_len, char *strval, int flags, int module_number TSRMLS_DC);
+ZEND_API void zend_register_stringl_constant(char *name, uint name_len, char *strval, uint strlen, int flags, int module_number TSRMLS_DC);
+ZEND_API int zend_register_constant(zend_constant *c TSRMLS_DC);
void zend_copy_constants(HashTable *target, HashTable *sourc);
void copy_zend_constant(zend_constant *c);
#include "zend_fast_cache.h"
#include "zend_execute_locks.h"
-#define get_zval_ptr(node, Ts, should_free, type) _get_zval_ptr(node, Ts, should_free ELS_CC)
-#define get_zval_ptr_ptr(node, Ts, type) _get_zval_ptr_ptr(node, Ts ELS_CC)
+#define get_zval_ptr(node, Ts, should_free, type) _get_zval_ptr(node, Ts, should_free TSRMLS_CC)
+#define get_zval_ptr_ptr(node, Ts, type) _get_zval_ptr_ptr(node, Ts TSRMLS_CC)
#define get_incdec_op(op, opcode) \
switch (opcode) { \
/* Prototypes */
-static zval get_overloaded_property(temp_variable *T ELS_DC);
-static void set_overloaded_property(temp_variable *T, zval *value ELS_DC);
-static void call_overloaded_function(temp_variable *T, int arg_count, zval *return_value ELS_DC);
-static void zend_fetch_var_address(znode *result, znode *op1, znode *op2, temp_variable *Ts, int type ELS_DC);
-static void zend_fetch_dimension_address(znode *result, znode *op1, znode *op2, temp_variable *Ts, int type ELS_DC);
-static void zend_fetch_property_address(znode *result, znode *op1, znode *op2, temp_variable *Ts, int type ELS_DC);
-static void zend_fetch_dimension_address_from_tmp_var(znode *result, znode *op1, znode *op2, temp_variable *Ts ELS_DC);
+static zval get_overloaded_property(temp_variable *T TSRMLS_DC);
+static void set_overloaded_property(temp_variable *T, zval *value TSRMLS_DC);
+static void call_overloaded_function(temp_variable *T, int arg_count, zval *return_value TSRMLS_DC);
+static void zend_fetch_var_address(znode *result, znode *op1, znode *op2, temp_variable *Ts, int type TSRMLS_DC);
+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);
#define RETURN_VALUE_USED(opline) (!((opline)->result.u.EA.type & EXT_TYPE_UNUSED))
-static inline zval *_get_zval_ptr(znode *node, temp_variable *Ts, int *should_free ELS_DC)
+static inline zval *_get_zval_ptr(znode *node, temp_variable *Ts, int *should_free TSRMLS_DC)
{
switch(node->op_type) {
case IS_CONST:
switch (Ts[node->u.var].EA.type) {
case IS_OVERLOADED_OBJECT:
- Ts[node->u.var].tmp_var = get_overloaded_property(&Ts[node->u.var] ELS_CC);
+ Ts[node->u.var].tmp_var = get_overloaded_property(&Ts[node->u.var] TSRMLS_CC);
Ts[node->u.var].tmp_var.refcount=1;
Ts[node->u.var].tmp_var.is_ref=1;
return &Ts[node->u.var].tmp_var;
return NULL;
}
-static inline zval *_get_object_zval_ptr(znode *node, temp_variable *Ts, int *should_free ELS_DC)
+static inline zval *_get_object_zval_ptr(znode *node, temp_variable *Ts, int *should_free TSRMLS_DC)
{
switch(node->op_type) {
case IS_TMP_VAR:
}
-static inline zval **_get_zval_ptr_ptr(znode *node, temp_variable *Ts ELS_DC)
+static inline zval **_get_zval_ptr_ptr(znode *node, temp_variable *Ts TSRMLS_DC)
{
if (node->op_type==IS_VAR) {
if (Ts[node->u.var].var.ptr_ptr) {
}
-static inline zval **zend_fetch_property_address_inner(HashTable *ht, znode *op2, temp_variable *Ts, int type ELS_DC)
+static inline zval **zend_fetch_property_address_inner(HashTable *ht, znode *op2, temp_variable *Ts, int type TSRMLS_DC)
{
zval *prop_ptr = get_zval_ptr(op2, Ts, &EG(free_op2), BP_VAR_R);
zval **retval;
-static inline void zend_switch_free(zend_op *opline, temp_variable *Ts ELS_DC)
+static inline void zend_switch_free(zend_op *opline, temp_variable *Ts TSRMLS_DC)
{
switch (opline->op1.op_type) {
case IS_VAR:
}
}
-void zend_assign_to_variable_reference(znode *result, zval **variable_ptr_ptr, zval **value_ptr_ptr, temp_variable *Ts ELS_DC)
+void zend_assign_to_variable_reference(znode *result, zval **variable_ptr_ptr, zval **value_ptr_ptr, temp_variable *Ts TSRMLS_DC)
{
zval *variable_ptr;
zval *value_ptr;
}
-static inline void zend_assign_to_variable(znode *result, znode *op1, znode *op2, zval *value, int type, temp_variable *Ts ELS_DC)
+static inline void zend_assign_to_variable(znode *result, znode *op1, znode *op2, zval *value, int type, temp_variable *Ts TSRMLS_DC)
{
zval **variable_ptr_ptr = get_zval_ptr_ptr(op1, Ts, BP_VAR_W);
zval *variable_ptr;
if (!variable_ptr_ptr) {
switch (Ts[op1->u.var].EA.type) {
case IS_OVERLOADED_OBJECT:
- set_overloaded_property(&Ts[op1->u.var], value ELS_CC);
+ set_overloaded_property(&Ts[op1->u.var], value TSRMLS_CC);
if (type == IS_TMP_VAR) {
zval_dtor(value);
}
}
-static void zend_fetch_var_address(znode *result, znode *op1, znode *op2, temp_variable *Ts, int type ELS_DC)
+static void zend_fetch_var_address(znode *result, znode *op1, znode *op2, temp_variable *Ts, int type TSRMLS_DC)
{
int free_op1;
zval *varname = get_zval_ptr(op1, Ts, &free_op1, BP_VAR_R);
}
-static inline zval **zend_fetch_dimension_address_inner(HashTable *ht, znode *op2, temp_variable *Ts, int type ELS_DC)
+static inline zval **zend_fetch_dimension_address_inner(HashTable *ht, znode *op2, temp_variable *Ts, int type TSRMLS_DC)
{
zval *dim = get_zval_ptr(op2, Ts, &EG(free_op2), BP_VAR_R);
zval **retval;
return retval;
}
-static void fetch_overloaded_element(znode *result, znode *op1, znode *op2, temp_variable *Ts, int type, zval ***retval, int overloaded_element_type ELS_DC)
+static void fetch_overloaded_element(znode *result, znode *op1, znode *op2, temp_variable *Ts, int type, zval ***retval, int overloaded_element_type TSRMLS_DC)
{
zend_overloaded_element overloaded_element;
}
-static void zend_fetch_dimension_address(znode *result, znode *op1, znode *op2, temp_variable *Ts, int type ELS_DC)
+static void zend_fetch_dimension_address(znode *result, znode *op1, znode *op2, temp_variable *Ts, int type TSRMLS_DC)
{
zval **container_ptr = get_zval_ptr_ptr(op1, Ts, type);
zval *container;
if (container_ptr == NULL) {
- fetch_overloaded_element(result, op1, op2, Ts, type, retval, OE_IS_ARRAY ELS_CC);
+ fetch_overloaded_element(result, op1, op2, Ts, type, retval, OE_IS_ARRAY TSRMLS_CC);
return;
}
new_zval->refcount++;
zend_hash_next_index_insert(container->value.ht, &new_zval, sizeof(zval *), (void **) retval);
} else {
- *retval = zend_fetch_dimension_address_inner(container->value.ht, op2, Ts, type ELS_CC);
+ *retval = zend_fetch_dimension_address_inner(container->value.ht, op2, Ts, type TSRMLS_CC);
}
SELECTIVE_PZVAL_LOCK(**retval, result);
break;
}
-static void zend_fetch_dimension_address_from_tmp_var(znode *result, znode *op1, znode *op2, temp_variable *Ts ELS_DC)
+static void zend_fetch_dimension_address_from_tmp_var(znode *result, znode *op1, znode *op2, temp_variable *Ts TSRMLS_DC)
{
int free_op1;
zval *container = get_zval_ptr(op1, Ts, &free_op1, BP_VAR_R);
return;
}
- Ts[result->u.var].var.ptr_ptr = zend_fetch_dimension_address_inner(container->value.ht, op2, Ts, BP_VAR_R ELS_CC);
+ Ts[result->u.var].var.ptr_ptr = zend_fetch_dimension_address_inner(container->value.ht, op2, Ts, BP_VAR_R TSRMLS_CC);
SELECTIVE_PZVAL_LOCK(*Ts[result->u.var].var.ptr_ptr, result);
}
-static void zend_fetch_property_address(znode *result, znode *op1, znode *op2, temp_variable *Ts, int type ELS_DC)
+static void zend_fetch_property_address(znode *result, znode *op1, znode *op2, temp_variable *Ts, int type TSRMLS_DC)
{
zval **container_ptr = get_zval_ptr_ptr(op1, Ts, type);
zval *container;
if (container_ptr == NULL) {
- fetch_overloaded_element(result, op1, op2, Ts, type, retval, OE_IS_OBJECT ELS_CC);
+ fetch_overloaded_element(result, op1, op2, Ts, type, retval, OE_IS_OBJECT TSRMLS_CC);
return;
}
SEPARATE_ZVAL(container_ptr);
container = *container_ptr;
}
- *retval = zend_fetch_property_address_inner(container->value.obj.properties, op2, Ts, type ELS_CC);
+ *retval = zend_fetch_property_address_inner(container->value.obj.properties, op2, Ts, type TSRMLS_CC);
SELECTIVE_PZVAL_LOCK(**retval, result);
}
-static zval get_overloaded_property(temp_variable *T ELS_DC)
+static zval get_overloaded_property(temp_variable *T TSRMLS_DC)
{
zval result;
}
-static void set_overloaded_property(temp_variable *T, zval *value ELS_DC)
+static void set_overloaded_property(temp_variable *T, zval *value TSRMLS_DC)
{
if ((T->EA.data.overloaded_element.object)->value.obj.ce->handle_property_set) {
(T->EA.data.overloaded_element.object)->value.obj.ce->handle_property_set(&T->EA.data.overloaded_element, value);
}
-static void call_overloaded_function(temp_variable *T, int arg_count, zval *return_value ELS_DC)
+static void call_overloaded_function(temp_variable *T, int arg_count, zval *return_value TSRMLS_DC)
{
if ((T->EA.data.overloaded_element.object)->value.obj.ce->handle_function_call) {
- (T->EA.data.overloaded_element.object)->value.obj.ce->handle_function_call(arg_count, return_value, T->EA.data.overloaded_element.object, 1 ELS_CC, &T->EA.data.overloaded_element);
+ (T->EA.data.overloaded_element.object)->value.obj.ce->handle_function_call(arg_count, return_value, T->EA.data.overloaded_element.object, 1 TSRMLS_CC, &T->EA.data.overloaded_element);
} else {
zend_error(E_ERROR, "Class '%s' does not support overloaded method calls",
(T->EA.data.overloaded_element.object)->value.obj.ce->name);
zval *ptr;
} object_info;
-ZEND_API void execute(zend_op_array *op_array ELS_DC)
+ZEND_API void execute(zend_op_array *op_array TSRMLS_DC)
{
zend_op *opline;
zend_function_state function_state;
}
#endif
- zend_clean_garbage(ELS_C);
+ zend_clean_garbage(TSRMLS_C);
switch(opline->opcode) {
case ZEND_ADD:
FREE_OP(&opline->op1, EG(free_op1));
NEXT_OPCODE();
case ZEND_FETCH_R:
- zend_fetch_var_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_R ELS_CC);
+ zend_fetch_var_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_R TSRMLS_CC);
AI_USE_PTR(Ts[opline->result.u.var].var);
NEXT_OPCODE();
case ZEND_FETCH_W:
- zend_fetch_var_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_W ELS_CC);
+ zend_fetch_var_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_W TSRMLS_CC);
NEXT_OPCODE();
case ZEND_FETCH_RW:
- zend_fetch_var_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_RW ELS_CC);
+ zend_fetch_var_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_RW TSRMLS_CC);
NEXT_OPCODE();
case ZEND_FETCH_FUNC_ARG:
if (ARG_SHOULD_BE_SENT_BY_REF(opline->extended_value, fbc, fbc->common.arg_types)) {
/* Behave like FETCH_W */
- zend_fetch_var_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_W ELS_CC);
+ zend_fetch_var_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_W TSRMLS_CC);
} else {
/* Behave like FETCH_R */
- zend_fetch_var_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_R ELS_CC);
+ zend_fetch_var_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_R TSRMLS_CC);
AI_USE_PTR(Ts[opline->result.u.var].var);
}
NEXT_OPCODE();
case ZEND_FETCH_UNSET:
- zend_fetch_var_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_R ELS_CC);
+ zend_fetch_var_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_R TSRMLS_CC);
PZVAL_UNLOCK(*Ts[opline->result.u.var].var.ptr_ptr);
if (Ts[opline->result.u.var].var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
SEPARATE_ZVAL_IF_NOT_REF(Ts[opline->result.u.var].var.ptr_ptr);
PZVAL_LOCK(*Ts[opline->result.u.var].var.ptr_ptr);
NEXT_OPCODE();
case ZEND_FETCH_IS:
- zend_fetch_var_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_IS ELS_CC);
+ zend_fetch_var_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_IS TSRMLS_CC);
AI_USE_PTR(Ts[opline->result.u.var].var);
NEXT_OPCODE();
case ZEND_FETCH_DIM_R:
if (opline->extended_value == ZEND_FETCH_ADD_LOCK) {
PZVAL_LOCK(*Ts[opline->op1.u.var].var.ptr_ptr);
}
- zend_fetch_dimension_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_R ELS_CC);
+ zend_fetch_dimension_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_R TSRMLS_CC);
AI_USE_PTR(Ts[opline->result.u.var].var);
NEXT_OPCODE();
case ZEND_FETCH_DIM_W:
- zend_fetch_dimension_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_W ELS_CC);
+ zend_fetch_dimension_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_W TSRMLS_CC);
NEXT_OPCODE();
case ZEND_FETCH_DIM_RW:
- zend_fetch_dimension_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_RW ELS_CC);
+ zend_fetch_dimension_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_RW TSRMLS_CC);
NEXT_OPCODE();
case ZEND_FETCH_DIM_IS:
- zend_fetch_dimension_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_IS ELS_CC);
+ zend_fetch_dimension_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_IS TSRMLS_CC);
AI_USE_PTR(Ts[opline->result.u.var].var);
NEXT_OPCODE();
case ZEND_FETCH_DIM_FUNC_ARG:
if (ARG_SHOULD_BE_SENT_BY_REF(opline->extended_value, fbc, fbc->common.arg_types)) {
/* Behave like FETCH_DIM_W */
- zend_fetch_dimension_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_W ELS_CC);
+ zend_fetch_dimension_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_W TSRMLS_CC);
} else {
/* Behave like FETCH_DIM_R, except for locking used for list() */
- zend_fetch_dimension_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_R ELS_CC);
+ zend_fetch_dimension_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_R TSRMLS_CC);
AI_USE_PTR(Ts[opline->result.u.var].var);
}
NEXT_OPCODE();
PZVAL_LOCK(*Ts[opline->op1.u.var].var.ptr_ptr);
}
*/
- zend_fetch_dimension_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_R ELS_CC);
+ zend_fetch_dimension_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_R TSRMLS_CC);
PZVAL_UNLOCK(*Ts[opline->result.u.var].var.ptr_ptr);
if (Ts[opline->result.u.var].var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
SEPARATE_ZVAL_IF_NOT_REF(Ts[opline->result.u.var].var.ptr_ptr);
PZVAL_LOCK(*Ts[opline->result.u.var].var.ptr_ptr);
NEXT_OPCODE();
case ZEND_FETCH_OBJ_R:
- zend_fetch_property_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_R ELS_CC);
+ zend_fetch_property_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_R TSRMLS_CC);
AI_USE_PTR(Ts[opline->result.u.var].var);
NEXT_OPCODE();
case ZEND_FETCH_OBJ_W:
- zend_fetch_property_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_W ELS_CC);
+ zend_fetch_property_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_W TSRMLS_CC);
NEXT_OPCODE();
case ZEND_FETCH_OBJ_RW:
- zend_fetch_property_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_RW ELS_CC);
+ zend_fetch_property_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_RW TSRMLS_CC);
NEXT_OPCODE();
case ZEND_FETCH_OBJ_IS:
- zend_fetch_property_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_IS ELS_CC);
+ zend_fetch_property_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_IS TSRMLS_CC);
AI_USE_PTR(Ts[opline->result.u.var].var);
NEXT_OPCODE();
case ZEND_FETCH_OBJ_FUNC_ARG:
if (ARG_SHOULD_BE_SENT_BY_REF(opline->extended_value, fbc, fbc->common.arg_types)) {
/* Behave like FETCH_OBJ_W */
- zend_fetch_property_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_W ELS_CC);
+ zend_fetch_property_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_W TSRMLS_CC);
} else {
- zend_fetch_property_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_R ELS_CC);
+ zend_fetch_property_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_R TSRMLS_CC);
AI_USE_PTR(Ts[opline->result.u.var].var);
}
NEXT_OPCODE();
case ZEND_FETCH_OBJ_UNSET:
- zend_fetch_property_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_R ELS_CC);
+ zend_fetch_property_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_R TSRMLS_CC);
PZVAL_UNLOCK(*Ts[opline->result.u.var].var.ptr_ptr);
if (Ts[opline->result.u.var].var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
PZVAL_LOCK(*Ts[opline->result.u.var].var.ptr_ptr);
NEXT_OPCODE();
case ZEND_FETCH_DIM_TMP_VAR:
- zend_fetch_dimension_address_from_tmp_var(&opline->result, &opline->op1, &opline->op2, Ts ELS_CC);
+ zend_fetch_dimension_address_from_tmp_var(&opline->result, &opline->op1, &opline->op2, Ts TSRMLS_CC);
AI_USE_PTR(Ts[opline->result.u.var].var);
NEXT_OPCODE();
case ZEND_ASSIGN: {
zval *value;
value = get_zval_ptr(&opline->op2, Ts, &EG(free_op2), BP_VAR_R);
- zend_assign_to_variable(&opline->result, &opline->op1, &opline->op2, value, (EG(free_op2)?IS_TMP_VAR:opline->op2.op_type), Ts ELS_CC);
+ zend_assign_to_variable(&opline->result, &opline->op1, &opline->op2, value, (EG(free_op2)?IS_TMP_VAR:opline->op2.op_type), Ts TSRMLS_CC);
/* zend_assign_to_variable() always takes care of op2, never free it! */
}
NEXT_OPCODE();
case ZEND_ASSIGN_REF:
- zend_assign_to_variable_reference(&opline->result, get_zval_ptr_ptr(&opline->op1, Ts, BP_VAR_W), get_zval_ptr_ptr(&opline->op2, Ts, BP_VAR_W), Ts ELS_CC);
+ zend_assign_to_variable_reference(&opline->result, get_zval_ptr_ptr(&opline->op1, Ts, BP_VAR_W), get_zval_ptr_ptr(&opline->op2, Ts, BP_VAR_W), Ts TSRMLS_CC);
NEXT_OPCODE();
case ZEND_JMP:
#if DEBUG_ZEND>=2
}
active_function_table = &ce->function_table;
} else { /* used for member function calls */
- object.ptr = _get_object_zval_ptr(&opline->op1, Ts, &EG(free_op1) ELS_CC);
+ object.ptr = _get_object_zval_ptr(&opline->op1, Ts, &EG(free_op1) TSRMLS_CC);
if ((!object.ptr && Ts[opline->op1.u.var].EA.type==IS_OVERLOADED_OBJECT)
|| ((object.ptr && object.ptr->type==IS_OBJECT) && (object.ptr->value.obj.ce->handle_function_call))) { /* overloaded function call */
if (function_state.function->type==ZEND_INTERNAL_FUNCTION) {
ALLOC_ZVAL(Ts[opline->result.u.var].var.ptr);
INIT_ZVAL(*(Ts[opline->result.u.var].var.ptr));
- ((zend_internal_function *) function_state.function)->handler(opline->extended_value, Ts[opline->result.u.var].var.ptr, object.ptr, return_value_used ELS_CC);
+ ((zend_internal_function *) function_state.function)->handler(opline->extended_value, Ts[opline->result.u.var].var.ptr, object.ptr, return_value_used TSRMLS_CC);
if (object.ptr) {
object.ptr->refcount--;
}
EG(return_value_ptr_ptr) = Ts[opline->result.u.var].var.ptr_ptr;
EG(active_op_array) = (zend_op_array *) function_state.function;
- zend_execute(EG(active_op_array) ELS_CC);
+ zend_execute(EG(active_op_array) TSRMLS_CC);
if (return_value_used && !Ts[opline->result.u.var].var.ptr) {
ALLOC_ZVAL(Ts[opline->result.u.var].var.ptr);
} else { /* ZEND_OVERLOADED_FUNCTION */
ALLOC_ZVAL(Ts[opline->result.u.var].var.ptr);
INIT_ZVAL(*(Ts[opline->result.u.var].var.ptr));
- call_overloaded_function(&Ts[fbc->overloaded_function.var], opline->extended_value, Ts[opline->result.u.var].var.ptr ELS_CC);
+ call_overloaded_function(&Ts[fbc->overloaded_function.var], opline->extended_value, Ts[opline->result.u.var].var.ptr TSRMLS_CC);
efree(fbc);
if (!return_value_used) {
zval_ptr_dtor(&Ts[opline->result.u.var].var.ptr);
}
function_state.function = (zend_function *) op_array;
EG(function_state_ptr) = &function_state;
- zend_ptr_stack_clear_multiple(ELS_C);
+ zend_ptr_stack_clear_multiple(TSRMLS_C);
}
NEXT_OPCODE();
case ZEND_RETURN: {
case ZEND_RECV: {
zval **param;
- if (zend_ptr_stack_get_arg(opline->op1.u.constant.value.lval, (void **) ¶m ELS_CC)==FAILURE) {
+ if (zend_ptr_stack_get_arg(opline->op1.u.constant.value.lval, (void **) ¶m TSRMLS_CC)==FAILURE) {
zend_error(E_WARNING, "Missing argument %d for %s()\n", opline->op1.u.constant.value.lval, get_active_function_name());
if (opline->result.op_type == IS_VAR) {
PZVAL_UNLOCK(*Ts[opline->result.u.var].var.ptr_ptr);
}
} else if (PZVAL_IS_REF(*param)) {
- zend_assign_to_variable_reference(NULL, get_zval_ptr_ptr(&opline->result, Ts, BP_VAR_W), param, NULL ELS_CC);
+ zend_assign_to_variable_reference(NULL, get_zval_ptr_ptr(&opline->result, Ts, BP_VAR_W), param, NULL TSRMLS_CC);
} else {
- zend_assign_to_variable(NULL, &opline->result, NULL, *param, IS_VAR, Ts ELS_CC);
+ zend_assign_to_variable(NULL, &opline->result, NULL, *param, IS_VAR, Ts TSRMLS_CC);
}
}
NEXT_OPCODE();
case ZEND_RECV_INIT: {
zval **param, *assignment_value;
- if (zend_ptr_stack_get_arg(opline->op1.u.constant.value.lval, (void **) ¶m ELS_CC)==FAILURE) {
+ if (zend_ptr_stack_get_arg(opline->op1.u.constant.value.lval, (void **) ¶m TSRMLS_CC)==FAILURE) {
if (opline->op2.u.constant.type == IS_CONSTANT || opline->op2.u.constant.type==IS_CONSTANT_ARRAY) {
zval *default_value;
}
if (PZVAL_IS_REF(assignment_value) && param) {
- zend_assign_to_variable_reference(NULL, get_zval_ptr_ptr(&opline->result, Ts, BP_VAR_W), param, NULL ELS_CC);
+ zend_assign_to_variable_reference(NULL, get_zval_ptr_ptr(&opline->result, Ts, BP_VAR_W), param, NULL TSRMLS_CC);
} else {
- zend_assign_to_variable(NULL, &opline->result, NULL, assignment_value, IS_VAR, Ts ELS_CC);
+ zend_assign_to_variable(NULL, &opline->result, NULL, assignment_value, IS_VAR, Ts TSRMLS_CC);
}
}
NEXT_OPCODE();
switch (brk_opline->opcode) {
case ZEND_SWITCH_FREE:
- zend_switch_free(brk_opline, Ts ELS_CC);
+ zend_switch_free(brk_opline, Ts TSRMLS_CC);
break;
case ZEND_FREE:
zendi_zval_dtor(Ts[brk_opline->op1.u.var].tmp_var);
}
NEXT_OPCODE();
case ZEND_SWITCH_FREE:
- zend_switch_free(opline, Ts ELS_CC);
+ zend_switch_free(opline, Ts TSRMLS_CC);
NEXT_OPCODE();
case ZEND_NEW: {
zval *tmp = get_zval_ptr(&opline->op1, Ts, &EG(free_op1), BP_VAR_R);
break;
case ZEND_INCLUDE:
case ZEND_REQUIRE:
- new_op_array = compile_filename(opline->op2.u.constant.value.lval, inc_filename CLS_CC ELS_CC);
+ new_op_array = compile_filename(opline->op2.u.constant.value.lval, inc_filename CLS_CC TSRMLS_CC);
break;
case ZEND_EVAL: {
char *eval_desc = zend_make_compiled_string_description("eval()'d code");
EG(return_value_ptr_ptr) = Ts[opline->result.u.var].var.ptr_ptr;
EG(active_op_array) = new_op_array;
- zend_execute(new_op_array ELS_CC);
+ zend_execute(new_op_array TSRMLS_CC);
if (!return_value_used) {
if (Ts[opline->result.u.var].var.ptr) {
} temp_variable;
-ZEND_API extern void (*zend_execute)(zend_op_array *op_array ELS_DC);
+ZEND_API extern void (*zend_execute)(zend_op_array *op_array TSRMLS_DC);
-void init_executor(CLS_D ELS_DC);
-void shutdown_executor(ELS_D);
-ZEND_API void execute(zend_op_array *op_array ELS_DC);
+void init_executor(CLS_D TSRMLS_DC);
+void shutdown_executor(TSRMLS_D);
+ZEND_API void execute(zend_op_array *op_array TSRMLS_DC);
ZEND_API int zend_is_true(zval *op);
static inline void safe_free_zval_ptr(zval *p)
{
- ELS_FETCH();
+ TSRMLS_FETCH();
if (p!=EG(uninitialized_zval_ptr)) {
FREE_ZVAL(p);
}
}
-ZEND_API int zend_eval_string(char *str, zval *retval_ptr, char *string_name CLS_DC ELS_DC);
+ZEND_API int zend_eval_string(char *str, zval *retval_ptr, char *string_name CLS_DC TSRMLS_DC);
static inline int i_zend_is_true(zval *op)
{
int result;
ZEND_API int zval_update_constant(zval **pp, void *arg);
/* dedicated Zend executor functions - do not use! */
-static inline void zend_ptr_stack_clear_multiple(ELS_D)
+static inline void zend_ptr_stack_clear_multiple(TSRMLS_D)
{
void **p = EG(argument_stack).top_element-2;
int delete_count = (ulong) *p;
EG(argument_stack).top_element = p;
}
-static inline int zend_ptr_stack_get_arg(int requested_arg, void **data ELS_DC)
+static inline int zend_ptr_stack_get_arg(int requested_arg, void **data TSRMLS_DC)
{
void **p = EG(argument_stack).top_element-2;
int arg_count = (ulong) *p;
/* services */
ZEND_API char *get_active_function_name(void);
-ZEND_API char *zend_get_executed_filename(ELS_D);
-ZEND_API uint zend_get_executed_lineno(ELS_D);
+ZEND_API char *zend_get_executed_filename(TSRMLS_D);
+ZEND_API uint zend_get_executed_lineno(TSRMLS_D);
ZEND_API zend_bool zend_is_executing(void);
ZEND_API void zend_set_timeout(long seconds);
#define active_opline (*EG(opline_ptr))
-void zend_assign_to_variable_reference(znode *result, zval **variable_ptr_ptr, zval **value_ptr_ptr, temp_variable *Ts ELS_DC);
+void zend_assign_to_variable_reference(znode *result, zval **variable_ptr_ptr, zval **value_ptr_ptr, temp_variable *Ts TSRMLS_DC);
#define IS_OVERLOADED_OBJECT 1
#define IS_STRING_OFFSET 2
#endif
-ZEND_API void (*zend_execute)(zend_op_array *op_array ELS_DC);
+ZEND_API void (*zend_execute)(zend_op_array *op_array TSRMLS_DC);
#ifdef ZEND_WIN32
#include <process.h>
signal(SIGSEGV, SIG_DFL);
}
{
- ELS_FETCH();
+ TSRMLS_FETCH();
fprintf(stderr, "SIGSEGV caught on opcode %d on opline %d of %s() at %s:%d\n\n",
active_opline->opcode,
active_opline-EG(active_op_array)->opcodes,
get_active_function_name(),
- zend_get_executed_filename(ELS_C),
- zend_get_executed_lineno(ELS_C));
+ zend_get_executed_filename(TSRMLS_C),
+ zend_get_executed_lineno(TSRMLS_C));
}
if (original_sigsegv_handler!=zend_handle_sigsegv) {
original_sigsegv_handler(dummy);
}
-void init_executor(CLS_D ELS_DC)
+void init_executor(CLS_D TSRMLS_DC)
{
INIT_ZVAL(EG(uninitialized_zval));
INIT_ZVAL(EG(error_zval));
}
-void shutdown_executor(ELS_D)
+void shutdown_executor(TSRMLS_D)
{
zend_try {
zend_ptr_stack_destroy(&EG(arg_types_stack));
zend_hash_apply(EG(class_table), (int (*)(void *)) is_not_internal_class);
} zend_end_try();
- zend_destroy_rsrc_list(ELS_C); /* must be destroyed after the main symbol table and
+ zend_destroy_rsrc_list(TSRMLS_C); /* must be destroyed after the main symbol table and
* op arrays are destroyed.
*/
ZEND_API char *get_active_function_name()
{
- ELS_FETCH();
+ TSRMLS_FETCH();
switch(EG(function_state_ptr)->function->type) {
case ZEND_USER_FUNCTION: {
}
-ZEND_API char *zend_get_executed_filename(ELS_D)
+ZEND_API char *zend_get_executed_filename(TSRMLS_D)
{
if (EG(active_op_array)) {
return EG(active_op_array)->filename;
}
-ZEND_API uint zend_get_executed_lineno(ELS_D)
+ZEND_API uint zend_get_executed_lineno(TSRMLS_D)
{
if (EG(opline_ptr)) {
return active_opline->lineno;
ZEND_API zend_bool zend_is_executing()
{
- ELS_FETCH();
+ TSRMLS_FETCH();
return EG(in_execution);
}
int (*orig_unary_op)(zval *result, zval *op1);
int (*orig_binary_op)(zval *result, zval *op1, zval *op2);
zval function_name_copy;
- ELS_FETCH();
+ TSRMLS_FETCH();
*retval_ptr_ptr = NULL;
ALLOC_ZVAL(dummy);
INIT_ZVAL(*dummy);
zend_hash_update(EG(active_symbol_table), "this", sizeof("this"), &dummy, sizeof(zval *), (void **) &this_ptr);
- zend_assign_to_variable_reference(NULL, this_ptr, object_pp, NULL ELS_CC);
+ zend_assign_to_variable_reference(NULL, this_ptr, object_pp, NULL TSRMLS_CC);
}
original_return_value = EG(return_value_ptr_ptr);
original_op_array = EG(active_op_array);
orig_free_op2 = EG(free_op2);
orig_unary_op = EG(unary_op);
orig_binary_op = EG(binary_op);
- zend_execute(EG(active_op_array) ELS_CC);
+ zend_execute(EG(active_op_array) TSRMLS_CC);
if (!symbol_table) {
zend_hash_destroy(EG(active_symbol_table));
FREE_HASHTABLE(EG(active_symbol_table));
EG(binary_op) = orig_binary_op;
} else {
ALLOC_INIT_ZVAL(*retval_ptr_ptr);
- ((zend_internal_function *) function_state.function)->handler(param_count, *retval_ptr_ptr, (object_pp?*object_pp:NULL), 1 ELS_CC);
+ ((zend_internal_function *) function_state.function)->handler(param_count, *retval_ptr_ptr, (object_pp?*object_pp:NULL), 1 TSRMLS_CC);
INIT_PZVAL(*retval_ptr_ptr);
}
- zend_ptr_stack_clear_multiple(ELS_C);
+ zend_ptr_stack_clear_multiple(TSRMLS_C);
EG(function_state_ptr) = original_function_state_ptr;
return SUCCESS;
}
-ZEND_API int zend_eval_string(char *str, zval *retval_ptr, char *string_name CLS_DC ELS_DC)
+ZEND_API int zend_eval_string(char *str, zval *retval_ptr, char *string_name CLS_DC TSRMLS_DC)
{
zval pv;
zend_op_array *new_op_array;
EG(active_op_array) = new_op_array;
EG(no_extensions)=1;
- zend_execute(new_op_array ELS_CC);
+ zend_execute(new_op_array TSRMLS_CC);
if (local_retval_ptr) {
if (retval_ptr) {
{
zend_op *opline, *end;
zend_op *ret_opline;
- ELS_FETCH();
+ TSRMLS_FETCH();
if (!CG(interactive)
|| CG(active_op_array)->backpatch_count>0
}
EG(active_op_array) = CG(active_op_array);
- zend_execute(CG(active_op_array) ELS_CC);
+ zend_execute(CG(active_op_array) TSRMLS_CC);
zval_ptr_dtor(EG(return_value_ptr_ptr));
CG(active_op_array)->last--; /* get rid of that ZEND_RETURN */
CG(active_op_array)->start_op = CG(active_op_array)->opcodes+CG(active_op_array)->last;
ZEND_API void zend_timeout(int dummy)
{
- ELS_FETCH();
+ TSRMLS_FETCH();
/* is there any point in this? we're terminating the request anyway...
PLS_FETCH();
}
#endif
KillTimer(timeout_window, wParam);
- EG(timed_out) = 1;
+ executor_globals->timed_out = 1;
}
break;
default:
void zend_set_timeout(long seconds)
{
- ELS_FETCH();
+ TSRMLS_FETCH();
EG(timeout_seconds) = seconds;
#ifdef ZEND_WIN32
void zend_unset_timeout(void)
{
- ELS_FETCH();
+ TSRMLS_FETCH();
#ifdef ZEND_WIN32
PostThreadMessage(timeout_thread_id, WM_UNREGISTER_ZEND_TIMEOUT, (WPARAM) GetCurrentThreadId(), (LPARAM) 0);
((z)->refcount++);
}
-#define PZVAL_UNLOCK(z) zend_pzval_unlock_func(z ELS_CC)
+#define PZVAL_UNLOCK(z) zend_pzval_unlock_func(z TSRMLS_CC)
-static inline void zend_pzval_unlock_func(zval *z ELS_DC)
+static inline void zend_pzval_unlock_func(zval *z TSRMLS_DC)
{
((z)->refcount--);
if (!(z)->refcount) {
}
}
-static inline void zend_clean_garbage(ELS_D)
+static inline void zend_clean_garbage(TSRMLS_D)
{
while (EG(garbage_ptr)) {
zval_ptr_dtor(&EG(garbage)[--EG(garbage_ptr)]);
/* Executor */
#ifdef ZTS
-# define ELS_D zend_executor_globals *executor_globals
-# define ELS_DC , ELS_D
-# define ELS_C executor_globals
-# define ELS_CC , ELS_C
-# define EG(v) (executor_globals->v)
-# define ELS_FETCH() zend_executor_globals *executor_globals = (zend_executor_globals *) ts_resource(executor_globals_id)
+# define EG(v) TSRMG(executor_globals_id, zend_executor_globals *, v)
#else
-# define ELS_D void
-# define ELS_DC
-# define ELS_C
-# define ELS_CC
# define EG(v) (executor_globals.v)
-# define ELS_FETCH()
extern ZEND_API zend_executor_globals executor_globals;
#endif
/*
* Startup / shutdown
*/
-ZEND_API int zend_ini_startup(ELS_D)
+ZEND_API int zend_ini_startup(TSRMLS_D)
{
registered_zend_ini_directives = &EG(ini_directives);
if (zend_hash_init_ex(registered_zend_ini_directives, 100, NULL, NULL, 1, 0)==FAILURE) {
}
-ZEND_API int zend_ini_shutdown(ELS_D)
+ZEND_API int zend_ini_shutdown(TSRMLS_D)
{
zend_hash_destroy(&EG(ini_directives));
return SUCCESS;
}
-ZEND_API int zend_ini_deactivate(ELS_D)
+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);
return SUCCESS;
}
-ZEND_API int zend_copy_ini_directives(ELS_D)
+ZEND_API int zend_copy_ini_directives(TSRMLS_D)
{
zend_ini_entry ini_entry;
return FAILURE;
}
zend_hash_copy(&EG(ini_directives), registered_zend_ini_directives, NULL, &ini_entry, sizeof(zend_ini_entry));
- zend_ini_refresh_caches(ZEND_INI_STAGE_STARTUP ELS_CC);
+ zend_ini_refresh_caches(ZEND_INI_STAGE_STARTUP TSRMLS_CC);
return SUCCESS;
}
}
-ZEND_API void zend_ini_sort_entries(ELS_D)
+ZEND_API void zend_ini_sort_entries(TSRMLS_D)
{
zend_hash_sort(&EG(ini_directives), qsort, ini_key_compare, 0);
}
}
-ZEND_API void zend_ini_refresh_caches(int stage ELS_DC)
+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_ini_entry *ini_entry;
char *duplicate;
- ELS_FETCH();
+ TSRMLS_FETCH();
if (zend_hash_find(&EG(ini_directives), name, name_length, (void **) &ini_entry)==FAILURE) {
return FAILURE;
ZEND_API int zend_restore_ini_entry(char *name, uint name_length, int stage)
{
zend_ini_entry *ini_entry;
- ELS_FETCH();
+ TSRMLS_FETCH();
if (zend_hash_find(&EG(ini_directives), name, name_length, (void **) &ini_entry)==FAILURE) {
return FAILURE;
ZEND_API long zend_ini_long(char *name, uint name_length, int orig)
{
zend_ini_entry *ini_entry;
- ELS_FETCH();
+ TSRMLS_FETCH();
if (zend_hash_find(&EG(ini_directives), name, name_length, (void **) &ini_entry)==SUCCESS) {
if (orig && ini_entry->modified) {
ZEND_API double zend_ini_double(char *name, uint name_length, int orig)
{
zend_ini_entry *ini_entry;
- ELS_FETCH();
+ TSRMLS_FETCH();
if (zend_hash_find(&EG(ini_directives), name, name_length, (void **) &ini_entry)==SUCCESS) {
if (orig && ini_entry->modified) {
ZEND_API char *zend_ini_string(char *name, uint name_length, int orig)
{
zend_ini_entry *ini_entry;
- ELS_FETCH();
+ TSRMLS_FETCH();
if (zend_hash_find(&EG(ini_directives), name, name_length, (void **) &ini_entry)==SUCCESS) {
if (orig && ini_entry->modified) {
zend_ini_entry *get_ini_entry(char *name, uint name_length)
{
zend_ini_entry *ini_entry;
- ELS_FETCH();
+ TSRMLS_FETCH();
if (zend_hash_find(&EG(ini_directives), name, name_length, (void **) &ini_entry)==SUCCESS) {
return ini_entry;
};
-ZEND_API int zend_ini_startup(ELS_D);
-ZEND_API int zend_ini_shutdown(ELS_D);
-ZEND_API int zend_ini_deactivate(ELS_D);
+ZEND_API int zend_ini_startup(TSRMLS_D);
+ZEND_API int zend_ini_shutdown(TSRMLS_D);
+ZEND_API int zend_ini_deactivate(TSRMLS_D);
-ZEND_API int zend_copy_ini_directives(ELS_D);
+ZEND_API int zend_copy_ini_directives(TSRMLS_D);
-ZEND_API void zend_ini_sort_entries(ELS_D);
+ZEND_API void zend_ini_sort_entries(TSRMLS_D);
ZEND_API int zend_register_ini_entries(zend_ini_entry *ini_entry, int module_number);
ZEND_API void zend_unregister_ini_entries(int module_number);
-ZEND_API void zend_ini_refresh_caches(int stage ELS_DC);
+ZEND_API void zend_ini_refresh_caches(int stage TSRMLS_DC);
ZEND_API int zend_alter_ini_entry(char *name, uint name_length, char *new_value, uint new_value_length, int modify_type, int stage);
ZEND_API int zend_restore_ini_entry(char *name, uint name_length, int stage);
ZEND_API void display_ini_entries(zend_module_entry *module);
;
top_statement_list:
- top_statement_list { zend_do_extended_info(CLS_C); } top_statement { ELS_FETCH(); HANDLE_INTERACTIVE(); }
+ top_statement_list { zend_do_extended_info(CLS_C); } top_statement { TSRMLS_FETCH(); HANDLE_INTERACTIVE(); }
| /* empty */
;
inner_statement_list:
- inner_statement_list { zend_do_extended_info(CLS_C); } inner_statement { ELS_FETCH(); HANDLE_INTERACTIVE(); }
+ inner_statement_list { zend_do_extended_info(CLS_C); } inner_statement { TSRMLS_FETCH(); HANDLE_INTERACTIVE(); }
| /* empty */
;
}
-zend_op_array *compile_filename(int type, zval *filename CLS_DC ELS_DC)
+zend_op_array *compile_filename(int type, zval *filename CLS_DC TSRMLS_DC)
{
zend_file_handle file_handle;
zval tmp;
{
int index;
zend_rsrc_list_entry le;
- ELS_FETCH();
+ TSRMLS_FETCH();
le.ptr=ptr;
le.type=type;
ZEND_API int zend_list_delete(int id)
{
zend_rsrc_list_entry *le;
- ELS_FETCH();
+ TSRMLS_FETCH();
if (zend_hash_index_find(&EG(regular_list), id, (void **) &le)==SUCCESS) {
/* printf("del(%d): %d->%d\n", id, le->refcount, le->refcount-1); */
ZEND_API void *zend_list_find(int id, int *type)
{
zend_rsrc_list_entry *le;
- ELS_FETCH();
+ TSRMLS_FETCH();
if (zend_hash_index_find(&EG(regular_list), id, (void **) &le)==SUCCESS) {
*type = le->type;
ZEND_API int zend_list_addref(int id)
{
zend_rsrc_list_entry *le;
- ELS_FETCH();
+ TSRMLS_FETCH();
if (zend_hash_index_find(&EG(regular_list), id, (void **) &le)==SUCCESS) {
/* printf("add(%d): %d->%d\n", id, le->refcount, le->refcount+1); */
}
-int zend_init_rsrc_list(ELS_D)
+int zend_init_rsrc_list(TSRMLS_D)
{
if (zend_hash_init(&EG(regular_list), 0, NULL, list_entry_destructor, 0)==SUCCESS) {
EG(regular_list).nNextFreeElement=1; /* we don't want resource id 0 */
}
-int zend_init_rsrc_plist(ELS_D)
+int zend_init_rsrc_plist(TSRMLS_D)
{
return zend_hash_init_ex(&EG(persistent_list), 0, NULL, plist_entry_destructor, 1, 0);
}
-void zend_destroy_rsrc_list(ELS_D)
+void zend_destroy_rsrc_list(TSRMLS_D)
{
Bucket *p, *q;
HashTable *ht = &EG(regular_list);
-void zend_destroy_rsrc_plist(ELS_D)
+void zend_destroy_rsrc_plist(TSRMLS_D)
{
zend_hash_reverse_destroy(&EG(persistent_list));
}
static int zend_clean_module_rsrc_dtors_cb(zend_rsrc_list_dtors_entry *ld, int *module_number)
{
if (ld->module_number == *module_number) {
- ELS_FETCH();
+ 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));
void plist_entry_destructor(void *ptr);
void zend_clean_module_rsrc_dtors(int module_number);
-int zend_init_rsrc_list(ELS_D);
-int zend_init_rsrc_plist(ELS_D);
-void zend_destroy_rsrc_list(ELS_D);
-void zend_destroy_rsrc_plist(ELS_D);
+int zend_init_rsrc_list(TSRMLS_D);
+int zend_init_rsrc_plist(TSRMLS_D);
+void zend_destroy_rsrc_list(TSRMLS_D);
+void zend_destroy_rsrc_plist(TSRMLS_D);
int zend_init_rsrc_list_dtors(void);
void zend_destroy_rsrc_list_dtors(void);
#include "zend.h"
-#define INIT_FUNC_ARGS int type, int module_number ELS_DC
-#define INIT_FUNC_ARGS_PASSTHRU type, module_number ELS_CC
+#define INIT_FUNC_ARGS int type, int module_number TSRMLS_DC
+#define INIT_FUNC_ARGS_PASSTHRU type, module_number TSRMLS_CC
#define SHUTDOWN_FUNC_ARGS int type, int module_number
#define SHUTDOWN_FUNC_ARGS_PASSTHRU type, module_number
#define ZEND_MODULE_INFO_FUNC_ARGS zend_module_entry *zend_module
{
long lval;
double dval;
- ELS_FETCH();
+ TSRMLS_FETCH();
switch (op->type) {
case IS_NULL:
break;
case IS_ARRAY:
case IS_CONSTANT_ARRAY: {
- ELS_FETCH();
+ TSRMLS_FETCH();
if (zvalue->value.ht && (zvalue->value.ht != &EG(symbol_table))) {
zend_hash_destroy(zvalue->value.ht);
case IS_CONSTANT_ARRAY: {
zval *tmp;
HashTable *original_ht = zvalue->value.ht;
- ELS_FETCH();
+ TSRMLS_FETCH();
if (zvalue->value.ht == &EG(symbol_table)) {
return SUCCESS; /* do nothing */
projects / php / commitdiff