Redesigned thread safety mechanism - nua nua

23 files changed, 699 insertions, 741 deletions

diff --git a/Zend/Zend.dsp b/Zend/Zend.dsp
index eae7f9042c..e2a8fe6611 100644
--- a/Zend/Zend.dsp
+++ b/Zend/Zend.dsp
@@ -215,10 +215,6 @@ SOURCE=.\FlexLexer.h
 # End Source File

 # Begin Source File

 

-SOURCE=.\zend_modules.h

-# End Source File

-# Begin Source File

-

 SOURCE=.\zend.h

 # End Source File

 # Begin Source File

@@ -299,6 +295,10 @@ SOURCE=.\zend_llist.h
 # End Source File

 # Begin Source File

 

+SOURCE=.\zend_modules.h

+# End Source File

+# Begin Source File

+

 SOURCE=.\zend_operators.h

 # End Source File

 # Begin Source File

@@ -330,8 +330,7 @@ InputDir=.
 InputPath=.\zend_ini_parser.y

 

 BuildCmds= \

-	bison --output=zend_ini_parser.c -v -d -p ini_ zend_ini_parser.y \

-	

+	bison --output=zend_ini_parser.c -v -d -p ini_ zend_ini_parser.y

 

 "$(InputDir)\zend_ini_parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

    $(BuildCmds)

@@ -356,8 +355,7 @@ InputDir=.
 InputPath=".\zend_language_parser.y"

 

 BuildCmds= \

-	bison --output=zend_language_parser.c -v -d -p zend zend_language_parser.y \

-	

+	bison --output=zend_language_parser.c -v -d -p zend zend_language_parser.y

 

 "$(InputDir)\zend_language_parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

    $(BuildCmds)

@@ -373,8 +371,7 @@ InputDir=.
 InputPath=".\zend_language_parser.y"

 

 BuildCmds= \

-	bison --output=zend_language_parser.c -v -d -p zend zend_language_parser.y \

-	

+	bison --output=zend_language_parser.c -v -d -p zend zend_language_parser.y

 

 "$(InputDir)\zend_language_parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

    $(BuildCmds)

@@ -390,8 +387,7 @@ InputDir=.
 InputPath=".\zend_language_parser.y"

 

 BuildCmds= \

-	bison --output=zend_language_parser.c -v -d -p zend zend_language_parser.y \

-	

+	bison --output=zend_language_parser.c -v -d -p zend zend_language_parser.y

 

 "$(InputDir)\zend_language_parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

    $(BuildCmds)

diff --git a/Zend/ZendTS.dsp b/Zend/ZendTS.dsp
index bee0e0cae9..0a1bfdd446 100644
--- a/Zend/ZendTS.dsp
+++ b/Zend/ZendTS.dsp
@@ -244,10 +244,6 @@ SOURCE=.\FlexLexer.h
 # End Source File

 # Begin Source File

 

-SOURCE=.\zend_modules.h

-# End Source File

-# Begin Source File

-

 SOURCE=.\zend.h

 # End Source File

 # Begin Source File

@@ -352,6 +348,10 @@ SOURCE=.\zend_llist.h
 # End Source File

 # Begin Source File

 

+SOURCE=.\zend_modules.h

+# End Source File

+# Begin Source File

+

 SOURCE=.\zend_operators.h

 # End Source File

 # Begin Source File

@@ -381,8 +381,7 @@ InputDir=.
 InputPath=.\zend_ini_parser.y

 

 BuildCmds= \

-	bison --output=zend_ini_parser.c -v -d -p ini_ zend_ini_parser.y \

-	

+	bison --output=zend_ini_parser.c -v -d -p ini_ zend_ini_parser.y

 

 "$(InputDir)\zend_ini_parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

    $(BuildCmds)

@@ -398,8 +397,7 @@ InputDir=.
 InputPath=.\zend_ini_parser.y

 

 BuildCmds= \

-	bison --output=zend_ini_parser.c -v -d -p ini_ zend_ini_parser.y \

-	

+	bison --output=zend_ini_parser.c -v -d -p ini_ zend_ini_parser.y

 

 "$(InputDir)\zend_ini_parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

    $(BuildCmds)

@@ -415,8 +413,7 @@ InputDir=.
 InputPath=.\zend_ini_parser.y

 

 BuildCmds= \

-	bison --output=zend_ini_parser.c -v -d -p ini_ zend_ini_parser.y \

-	

+	bison --output=zend_ini_parser.c -v -d -p ini_ zend_ini_parser.y

 

 "$(InputDir)\zend_ini_parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

    $(BuildCmds)

@@ -455,8 +452,7 @@ InputDir=.
 InputPath=".\zend_language_parser.y"

 

 BuildCmds= \

-	bison --output=zend_language_parser.c -v -d -p zend zend_language_parser.y \

-	

+	bison --output=zend_language_parser.c -v -d -p zend zend_language_parser.y

 

 "$(InputDir)\zend_language_parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

    $(BuildCmds)

@@ -472,8 +468,7 @@ InputDir=.
 InputPath=".\zend_language_parser.y"

 

 BuildCmds= \

-	bison --output=zend_language_parser.c -v -d -p zend zend_language_parser.y \

-	

+	bison --output=zend_language_parser.c -v -d -p zend zend_language_parser.y

 

 "$(InputDir)\zend_language_parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

    $(BuildCmds)

@@ -489,8 +484,7 @@ InputDir=.
 InputPath=".\zend_language_parser.y"

 

 BuildCmds= \

-	bison --output=zend_language_parser.c -v -d -p zend zend_language_parser.y \

-	

+	bison --output=zend_language_parser.c -v -d -p zend zend_language_parser.y

 

 "$(InputDir)\zend_language_parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"

    $(BuildCmds)

diff --git a/Zend/zend.c b/Zend/zend.c
index 1d962f227a..09b14723e1 100644
--- a/Zend/zend.c
+++ b/Zend/zend.c
@@ -250,7 +250,7 @@ static void register_standard_class(void)
 }
 
 
-static void zend_set_default_compile_time_values(CLS_D)
+static void zend_set_default_compile_time_values(TSRMLS_D)
 {
 	/* default compile-time values */
 	CG(asp_tags) = 0;
@@ -276,7 +276,7 @@ static void compiler_globals_ctor(zend_compiler_globals *compiler_globals TSRMLS
 	zend_hash_init_ex(compiler_globals->class_table, 10, NULL, ZEND_CLASS_DTOR, 1, 0);
 	zend_hash_copy(compiler_globals->class_table, global_class_table, (copy_ctor_func_t) zend_class_add_ref, &tmp_class, sizeof(zend_class_entry));
 
-	zend_set_default_compile_time_values(CLS_C);
+	zend_set_default_compile_time_values(TSRMLS_C);
 
 	CG(interactive) = 0;
 }
@@ -316,9 +316,9 @@ static void executor_globals_dtor(zend_executor_globals *executor_globals TSRMLS
 }
 
 
-static void alloc_globals_ctor(zend_alloc_globals *alloc_globals TSRMLS_DC)
+static void alloc_globals_ctor(zend_alloc_globals *alloc_globals_p TSRMLS_DC)
 {
-	start_memory_manager(ALS_C);
+	start_memory_manager(TSRMLS_C);
 }
 
 #endif
@@ -348,7 +348,7 @@ int zend_startup(zend_utility_functions *utility_functions, char **extensions, i
 
 	ts_allocate_id(&alloc_globals_id, sizeof(zend_alloc_globals), (ts_allocate_ctor) alloc_globals_ctor, NULL);
 #else
-	start_memory_manager(ALS_C);
+	start_memory_manager(TSRMLS_C);
 #endif
 
 #ifdef __FreeBSD__
@@ -406,7 +406,7 @@ int zend_startup(zend_utility_functions *utility_functions, char **extensions, i
 	GLOBAL_CONSTANTS_TABLE = EG(zend_constants);
 #else
 	zend_startup_constants();
-	zend_set_default_compile_time_values(CLS_C);
+	zend_set_default_compile_time_values(TSRMLS_C);
 	EG(user_error_handler) = NULL;
 #endif
 	zend_register_standard_constants(TSRMLS_C);
@@ -468,7 +468,6 @@ void zenderror(char *error)
 BEGIN_EXTERN_C()
 ZEND_API void _zend_bailout(char *filename, uint lineno)
 {
-	CLS_FETCH();
 	TSRMLS_FETCH();
 
 	if (!EG(bailout_set)) {
@@ -510,12 +509,12 @@ ZEND_API char *get_zend_version()
 }
 
 
-void zend_activate(CLS_D TSRMLS_DC)
+void zend_activate(TSRMLS_D)
 {
 	EG(bailout_set) = 0;
-	init_compiler(CLS_C TSRMLS_CC);
-	init_executor(CLS_C TSRMLS_CC);
-	startup_scanner(CLS_C);
+	init_compiler(TSRMLS_C);
+	init_executor(TSRMLS_C);
+	startup_scanner(TSRMLS_C);
 }
 
 
@@ -534,21 +533,21 @@ void zend_deactivate_modules()
 	} zend_end_try();
 }
 
-void zend_deactivate(CLS_D TSRMLS_DC)
+void zend_deactivate(TSRMLS_D)
 {
 	/* we're no longer executing anything */
 	EG(opline_ptr) = NULL; 
 	EG(active_symbol_table) = NULL;
 
 	zend_try {
-		shutdown_scanner(CLS_C);
+		shutdown_scanner(TSRMLS_C);
 	} zend_end_try();
 
 	/* shutdown_executor() takes care of its own bailout handling */
 	shutdown_executor(TSRMLS_C);
 
 	zend_try {
-		shutdown_compiler(CLS_C);
+		shutdown_compiler(TSRMLS_C);
 	} zend_end_try();
 
 	zend_try {
@@ -589,7 +588,6 @@ ZEND_API void zend_error(int type, const char *format, ...)
 	uint error_lineno;
 	zval *orig_user_error_handler;
 	TSRMLS_FETCH();
-	CLS_FETCH();
 
 	/* Obtain relevant filename and lineno */
 	switch (type) {
@@ -608,8 +606,8 @@ ZEND_API void zend_error(int type, const char *format, ...)
 		case E_USER_WARNING:
 		case E_USER_NOTICE:
 			if (zend_is_compiling()) {
-				error_filename = zend_get_compiled_filename(CLS_C);
-				error_lineno = zend_get_compiled_lineno(CLS_C);
+				error_filename = zend_get_compiled_filename(TSRMLS_C);
+				error_lineno = zend_get_compiled_lineno(TSRMLS_C);
 			} else if (zend_is_executing()) {
 				error_filename = zend_get_executed_filename(TSRMLS_C);
 				error_lineno = zend_get_executed_lineno(TSRMLS_C);
@@ -711,7 +709,7 @@ ZEND_API void zend_error(int type, const char *format, ...)
 	va_end(args);
 
 	if (type==E_PARSE) {
-		zend_init_compiler_data_structures(CLS_C);
+		zend_init_compiler_data_structures(TSRMLS_C);
 	}
 }
 
@@ -742,7 +740,7 @@ ZEND_API void zend_output_debug_string(zend_bool trigger_break, char *format, ..
 }
 
 
-ZEND_API int zend_execute_scripts(int type CLS_DC TSRMLS_DC, int file_count, ...)
+ZEND_API int zend_execute_scripts(int type TSRMLS_DC, int file_count, ...)
 {
 	va_list files;
 	int i;
@@ -755,8 +753,8 @@ ZEND_API int zend_execute_scripts(int type CLS_DC TSRMLS_DC, int file_count, ...
 		if (!file_handle) {
 			continue;
 		}
-		EG(active_op_array) = zend_compile_file(file_handle, ZEND_INCLUDE CLS_CC);
-		zend_destroy_file_handle(file_handle CLS_CC);
+		EG(active_op_array) = zend_compile_file(file_handle, ZEND_INCLUDE TSRMLS_CC);
+		zend_destroy_file_handle(file_handle TSRMLS_CC);
 		if (EG(active_op_array)) {
 			zend_execute(EG(active_op_array) TSRMLS_CC);
 			zval_ptr_dtor(EG(return_value_ptr_ptr));
@@ -783,12 +781,11 @@ ZEND_API char *zend_make_compiled_string_description(char *name)
 	char *cur_filename;
 	int cur_lineno;
 	char *compiled_string_description;
-	CLS_FETCH();
 	TSRMLS_FETCH();
 
 	if (zend_is_compiling()) {
-		cur_filename = zend_get_compiled_filename(CLS_C);
-		cur_lineno = zend_get_compiled_lineno(CLS_C);
+		cur_filename = zend_get_compiled_filename(TSRMLS_C);
+		cur_lineno = zend_get_compiled_lineno(TSRMLS_C);
 	} else if (zend_is_executing()) {
 		cur_filename = zend_get_executed_filename(TSRMLS_C);
 		cur_lineno = zend_get_executed_lineno(TSRMLS_C);
diff --git a/Zend/zend.h b/Zend/zend.h
index 89bebbcbaa..579813d351 100644
--- a/Zend/zend.h
+++ b/Zend/zend.h
@@ -23,8 +23,6 @@
 
 #define ZEND_VERSION "1.0.7"
 
-#include "../TSRM/TSRM.h"
-
 #ifdef __cplusplus
 #define BEGIN_EXTERN_C() extern "C" {
 #define END_EXTERN_C() }
diff --git a/Zend/zend_API.c b/Zend/zend_API.c
index f7db730588..6305346ecd 100644
--- a/Zend/zend_API.c
+++ b/Zend/zend_API.c
@@ -1033,7 +1033,7 @@ int zend_register_functions(zend_function_entry *functions, HashTable *function_
 	int count=0,unload=0;
 	HashTable *target_function_table = function_table;
 	int error_type;
-	CLS_FETCH();
+	TSRMLS_FETCH();
 
 	if (type==MODULE_PERSISTENT) {
 		error_type = E_CORE_WARNING;
@@ -1083,7 +1083,7 @@ void zend_unregister_functions(zend_function_entry *functions, int count, HashTa
 	zend_function_entry *ptr = functions;
 	int i=0;
 	HashTable *target_function_table = function_table;
-	CLS_FETCH();
+	TSRMLS_FETCH();
 
 	if (!target_function_table) {
 		target_function_table = CG(function_table);
@@ -1199,7 +1199,7 @@ int zend_next_free_module(void)
 ZEND_API zend_class_entry *zend_register_internal_class_ex(zend_class_entry *class_entry, zend_class_entry *parent_ce, char *parent_name)
 {
 	zend_class_entry *register_class;
-	CLS_FETCH();
+	TSRMLS_FETCH();
 
 	if (!parent_ce && parent_name) {
 			if (zend_hash_find(CG(class_table), parent_name, strlen(parent_name)+1, (void **) &parent_ce)==FAILURE) {
@@ -1219,7 +1219,7 @@ ZEND_API zend_class_entry *zend_register_internal_class(zend_class_entry *class_
 {
 	zend_class_entry *register_class;
 	char *lowercase_name = zend_strndup(class_entry->name, class_entry->name_length);
-	CLS_FETCH();
+	TSRMLS_FETCH();
 
 	zend_str_tolower(lowercase_name, class_entry->name_length);
 
@@ -1292,7 +1292,7 @@ static zend_function_entry disabled_function[] =  {
 
 ZEND_API int zend_disable_function(char *function_name, uint function_name_length)
 {
-	CLS_FETCH();
+	TSRMLS_FETCH();
 
 	if (zend_hash_del(CG(function_table), function_name, function_name_length+1)==FAILURE) {
 		return FAILURE;
diff --git a/Zend/zend_alloc.c b/Zend/zend_alloc.c
index 42bc335a9b..98b4442446 100644
--- a/Zend/zend_alloc.c
+++ b/Zend/zend_alloc.c
@@ -123,7 +123,7 @@ ZEND_API void *_emalloc(size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
 {
 	zend_mem_header *p;
 	DECLARE_CACHE_VARS();
-	ALS_FETCH();
+	TSRMLS_FETCH();
 
 	CALCULATE_REAL_SIZE_AND_CACHE_INDEX(size);
 
@@ -198,7 +198,7 @@ ZEND_API void _efree(void *ptr ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
 {
 	zend_mem_header *p = (zend_mem_header *) ((char *)ptr - sizeof(zend_mem_header) - MEM_HEADER_PADDING);
 	DECLARE_CACHE_VARS();
-	ALS_FETCH();
+	TSRMLS_FETCH();
 
 #if defined(ZTS) && TSRM_DEBUG
 	if (p->thread_id != tsrm_thread_id()) {
@@ -260,7 +260,7 @@ ZEND_API void *_erealloc(void *ptr, size_t size, int allow_failure ZEND_FILE_LIN
 	zend_mem_header *p;
 	zend_mem_header *orig;
 	DECLARE_CACHE_VARS();
-	ALS_FETCH();
+	TSRMLS_FETCH();
 
 	if (!ptr) {
 		return _emalloc(size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
@@ -374,7 +374,7 @@ ZEND_API char *zend_strndup(const char *s, uint length)
 ZEND_API int zend_set_memory_limit(unsigned int memory_limit)
 {
 #if MEMORY_LIMIT
-	ALS_FETCH();
+	TSRMLS_FETCH();
 
 	AG(memory_limit) = memory_limit;
 	return SUCCESS;
@@ -384,7 +384,7 @@ ZEND_API int zend_set_memory_limit(unsigned int memory_limit)
 }
 
 
-ZEND_API void start_memory_manager(ALS_D)
+ZEND_API void start_memory_manager(TSRMLS_D)
 {
 #if 0
 #ifndef ZTS
@@ -439,7 +439,7 @@ ZEND_API void shutdown_memory_manager(int silent, int clean_cache)
 	int had_leaks = 0;
 #endif
 	zend_fast_cache_list_entry *fast_cache_list_entry, *next_fast_cache_list_entry;
-	ALS_FETCH();
+	TSRMLS_FETCH();
 
 	for (fci=0; fci<MAX_FAST_CACHE_TYPES; fci++) {
 		fast_cache_list_entry = AG(fast_cache_list_head)[fci];
@@ -690,7 +690,7 @@ ZEND_API void _full_mem_check(int silent ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_D
 {
 	zend_mem_header *p;
 	int errors=0;
-	ALS_FETCH();
+	TSRMLS_FETCH();
 
 	p = AG(head);
 	
@@ -713,7 +713,7 @@ ZEND_API void _full_mem_check(int silent ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_D
 ZEND_API int _persist_alloc(void *ptr ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
 {
 	zend_mem_header *p = (zend_mem_header *) ((char *)ptr-sizeof(zend_mem_header)-MEM_HEADER_PADDING);
-	ALS_FETCH();
+	TSRMLS_FETCH();
 
 #if ZEND_DEBUG
 	_mem_block_check(ptr, 1 ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
diff --git a/Zend/zend_alloc.h b/Zend/zend_alloc.h
index 964e2e4ce2..7afda73737 100644
--- a/Zend/zend_alloc.h
+++ b/Zend/zend_alloc.h
@@ -23,10 +23,7 @@
 
 #include <stdio.h>
 
-#ifdef ZTS
 #include "../TSRM/TSRM.h"
-#endif
-
 #include "zend_globals_macros.h"
 
 #define MEM_BLOCK_START_MAGIC	0x7312F8DCL
@@ -117,7 +114,7 @@ ZEND_API int _persist_alloc(void *ptr ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC);
 
 ZEND_API int zend_set_memory_limit(unsigned int memory_limit);
 
-ZEND_API void start_memory_manager(ALS_D);
+ZEND_API void start_memory_manager(TSRMLS_D);
 ZEND_API void shutdown_memory_manager(int silent, int clean_cache);
 
 #if ZEND_DEBUG
diff --git a/Zend/zend_builtin_functions.c b/Zend/zend_builtin_functions.c
index cdcaab0ce4..5185115548 100644
--- a/Zend/zend_builtin_functions.c
+++ b/Zend/zend_builtin_functions.c
@@ -926,7 +926,6 @@ ZEND_FUNCTION(create_function)
 	zval **z_function_args, **z_function_code;
 	int retval;
 	char *eval_name;
-	CLS_FETCH();
 
 	if (ZEND_NUM_ARGS()!=2 || zend_get_parameters_ex(2, &z_function_args, &z_function_code)==FAILURE) {
 		ZEND_WRONG_PARAM_COUNT();
@@ -945,7 +944,7 @@ ZEND_FUNCTION(create_function)
 	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 TSRMLS_CC);
+	retval = zend_eval_string(eval_code, NULL, eval_name TSRMLS_CC);
 	efree(eval_code);
 	efree(eval_name);
 
diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
index 8b53efbed0..c7e9ef3925 100644
--- a/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@ -26,7 +26,7 @@
 #include "zend_fast_cache.h"
 
 
-ZEND_API zend_op_array *(*zend_compile_file)(zend_file_handle *file_handle, int type CLS_DC);
+ZEND_API zend_op_array *(*zend_compile_file)(zend_file_handle *file_handle, int type TSRMLS_DC);
 
 
 #ifndef ZTS
@@ -35,7 +35,7 @@ ZEND_API zend_executor_globals executor_globals;
 #endif
 
 
-static void build_runtime_defined_function_key(zval *result, zval *name, zend_op *opline CLS_DC)
+static void build_runtime_defined_function_key(zval *result, zval *name, zend_op *opline TSRMLS_DC)
 {
 	char lineno_buf[32];
 	uint lineno_len;
@@ -57,7 +57,7 @@ static void build_runtime_defined_function_key(zval *result, zval *name, zend_op
 }
 
 
-static void init_compiler_declarables(CLS_D)
+static void init_compiler_declarables(TSRMLS_D)
 {
 	CG(declarables).ticks.type = IS_LONG;
 	CG(declarables).ticks.value.lval = 0;
@@ -65,7 +65,7 @@ static void init_compiler_declarables(CLS_D)
 
 
 
-void zend_init_compiler_data_structures(CLS_D)
+void zend_init_compiler_data_structures(TSRMLS_D)
 {
 	zend_stack_init(&CG(bp_stack));
 	zend_stack_init(&CG(function_call_stack));
@@ -80,13 +80,13 @@ void zend_init_compiler_data_structures(CLS_D)
 	zend_stack_init(&CG(list_stack));
 	CG(handle_op_arrays) = 1;
 	CG(in_compilation) = 0;
-	init_compiler_declarables(CLS_C);
+	init_compiler_declarables(TSRMLS_C);
 }
 
 
-void init_compiler(CLS_D TSRMLS_DC)
+void init_compiler(TSRMLS_D)
 {
-	zend_init_compiler_data_structures(CLS_C);
+	zend_init_compiler_data_structures(TSRMLS_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);
@@ -94,7 +94,7 @@ void init_compiler(CLS_D TSRMLS_DC)
 }
 
 
-void shutdown_compiler(CLS_D)
+void shutdown_compiler(TSRMLS_D)
 {
 	zend_stack_destroy(&CG(bp_stack));
 	zend_stack_destroy(&CG(function_call_stack));
@@ -112,7 +112,7 @@ ZEND_API char *zend_set_compiled_filename(char *new_compiled_filename)
 {
 	char **pp, *p;
 	int length = strlen(new_compiled_filename);
-	CLS_FETCH();
+	TSRMLS_FETCH();
 
 	if (zend_hash_find(&CG(filenames_table), new_compiled_filename, length+1, (void **) &pp)==SUCCESS) {
 		CG(compiled_filename) = *pp;
@@ -127,19 +127,19 @@ ZEND_API char *zend_set_compiled_filename(char *new_compiled_filename)
 
 ZEND_API void zend_restore_compiled_filename(char *original_compiled_filename)
 {
-	CLS_FETCH();
+	TSRMLS_FETCH();
 
 	CG(compiled_filename) = original_compiled_filename;
 }
 
 
-ZEND_API char *zend_get_compiled_filename(CLS_D)
+ZEND_API char *zend_get_compiled_filename(TSRMLS_D)
 {
 	return CG(compiled_filename);
 }
 
 
-ZEND_API int zend_get_compiled_lineno(CLS_D)
+ZEND_API int zend_get_compiled_lineno(TSRMLS_D)
 {
 	return CG(zend_lineno);
 }
@@ -147,7 +147,7 @@ ZEND_API int zend_get_compiled_lineno(CLS_D)
 
 ZEND_API zend_bool zend_is_compiling()
 {
-	CLS_FETCH();
+	TSRMLS_FETCH();
 
 	return CG(in_compilation);
 }
@@ -159,9 +159,9 @@ static zend_uint get_temporary_variable(zend_op_array *op_array)
 }
 
 
-void zend_do_binary_op(int op, znode *result, znode *op1, znode *op2 CLS_DC)
+void zend_do_binary_op(int op, znode *result, znode *op1, znode *op2 TSRMLS_DC)
 {
-	zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	opline->opcode = op;
 	opline->result.op_type = IS_TMP_VAR;
@@ -172,9 +172,9 @@ void zend_do_binary_op(int op, znode *result, znode *op1, znode *op2 CLS_DC)
 }
 
 
-void zend_do_unary_op(int op, znode *result, znode *op1 CLS_DC)
+void zend_do_unary_op(int op, znode *result, znode *op1 TSRMLS_DC)
 {
-	zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	opline->opcode = op;
 	opline->result.op_type = IS_TMP_VAR;
@@ -185,9 +185,9 @@ void zend_do_unary_op(int op, znode *result, znode *op1 CLS_DC)
 }
 
 
-void zend_do_binary_assign_op(int op, znode *result, znode *op1, znode *op2 CLS_DC)
+void zend_do_binary_assign_op(int op, znode *result, znode *op1, znode *op2 TSRMLS_DC)
 {
-	zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	opline->opcode = op;
 	opline->result.op_type = IS_VAR;
@@ -200,7 +200,7 @@ void zend_do_binary_assign_op(int op, znode *result, znode *op1, znode *op2 CLS_
 
 
 
-void zend_do_fetch_globals(znode *varname CLS_DC)
+void zend_do_fetch_globals(znode *varname TSRMLS_DC)
 {
 	if (!CG(active_op_array)->uses_globals
 		&& varname->op_type == IS_CONST
@@ -211,7 +211,7 @@ void zend_do_fetch_globals(znode *varname CLS_DC)
 	}
 }
 
-void fetch_simple_variable_ex(znode *result, znode *varname, int bp, int op CLS_DC)
+void fetch_simple_variable_ex(znode *result, znode *varname, int bp, int op TSRMLS_DC)
 {
 	zend_op opline;
 	zend_op *opline_ptr;
@@ -219,9 +219,9 @@ void fetch_simple_variable_ex(znode *result, znode *varname, int bp, int op CLS_
 
 	if (bp) {
 		opline_ptr = &opline;
-		init_op(opline_ptr CLS_CC);
+		init_op(opline_ptr TSRMLS_CC);
 	} else {
-		opline_ptr = get_next_op(CG(active_op_array) CLS_CC);
+		opline_ptr = get_next_op(CG(active_op_array) TSRMLS_CC);
 	}
 
 	opline_ptr->opcode = op;
@@ -239,27 +239,27 @@ void fetch_simple_variable_ex(znode *result, znode *varname, int bp, int op CLS_
 	}
 }
 
-void fetch_simple_variable(znode *result, znode *varname, int bp CLS_DC)
+void fetch_simple_variable(znode *result, znode *varname, int bp TSRMLS_DC)
 {
 	/* the default mode must be Write, since fetch_simple_variable() is used to define function arguments */
-	fetch_simple_variable_ex(result, varname, bp, ZEND_FETCH_W CLS_CC);
+	fetch_simple_variable_ex(result, varname, bp, ZEND_FETCH_W TSRMLS_CC);
 }
 
 
-void fetch_array_begin(znode *result, znode *varname, znode *first_dim CLS_DC)
+void fetch_array_begin(znode *result, znode *varname, znode *first_dim TSRMLS_DC)
 {
-	fetch_simple_variable(result, varname, 1 CLS_CC);
+	fetch_simple_variable(result, varname, 1 TSRMLS_CC);
 
-	fetch_array_dim(result, result, first_dim CLS_CC);
+	fetch_array_dim(result, result, first_dim TSRMLS_CC);
 }
 
 
-void fetch_array_dim(znode *result, znode *parent, znode *dim CLS_DC)
+void fetch_array_dim(znode *result, znode *parent, znode *dim TSRMLS_DC)
 {
 	zend_op opline;
 	zend_llist *fetch_list_ptr;
 
-	init_op(&opline CLS_CC);
+	init_op(&opline TSRMLS_CC);
 	opline.opcode = ZEND_FETCH_DIM_W;	/* the backpatching routine assumes W */
 	opline.result.op_type = IS_VAR;
 	opline.result.u.EA.type = 0;
@@ -274,15 +274,15 @@ void fetch_array_dim(znode *result, znode *parent, znode *dim CLS_DC)
 }
 
 
-void fetch_string_offset(znode *result, znode *parent, znode *offset CLS_DC)
+void fetch_string_offset(znode *result, znode *parent, znode *offset TSRMLS_DC)
 {
-	fetch_array_dim(result, parent, offset CLS_CC);
+	fetch_array_dim(result, parent, offset TSRMLS_CC);
 }
 
 
-void zend_do_print(znode *result, znode *arg CLS_DC)
+void zend_do_print(znode *result, znode *arg TSRMLS_DC)
 {
-	zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	opline->result.op_type = IS_TMP_VAR;
 	opline->result.u.var = get_temporary_variable(CG(active_op_array));
@@ -293,9 +293,9 @@ void zend_do_print(znode *result, znode *arg CLS_DC)
 }
 
 
-void zend_do_echo(znode *arg CLS_DC)
+void zend_do_echo(znode *arg TSRMLS_DC)
 {
-	zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	opline->opcode = ZEND_ECHO;
 	opline->op1 = *arg;
@@ -303,9 +303,9 @@ void zend_do_echo(znode *arg CLS_DC)
 }
 
 
-void zend_do_assign(znode *result, znode *variable, znode *value CLS_DC)
+void zend_do_assign(znode *result, znode *variable, znode *value TSRMLS_DC)
 {
-	zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	opline->opcode = ZEND_ASSIGN;
 	opline->result.op_type = IS_VAR;
@@ -317,9 +317,9 @@ void zend_do_assign(znode *result, znode *variable, znode *value CLS_DC)
 }
 
 
-void zend_do_assign_ref(znode *result, znode *lvar, znode *rvar CLS_DC)
+void zend_do_assign_ref(znode *result, znode *lvar, znode *rvar TSRMLS_DC)
 {
-	zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	opline->opcode = ZEND_ASSIGN_REF;
 	if (result) {
@@ -336,7 +336,7 @@ void zend_do_assign_ref(znode *result, znode *lvar, znode *rvar CLS_DC)
 }
 
 
-static inline void do_begin_loop(CLS_D)
+static inline void do_begin_loop(TSRMLS_D)
 {
 	zend_brk_cont_element *brk_cont_element;
 	int parent;
@@ -348,7 +348,7 @@ static inline void do_begin_loop(CLS_D)
 }
 
 
-static inline void do_end_loop(int cont_addr CLS_DC)
+static inline void do_end_loop(int cont_addr TSRMLS_DC)
 {
 	CG(active_op_array)->brk_cont_array[CG(active_op_array)->current_brk_cont].cont = cont_addr;
 	CG(active_op_array)->brk_cont_array[CG(active_op_array)->current_brk_cont].brk = get_next_op_number(CG(active_op_array));
@@ -356,24 +356,24 @@ static inline void do_end_loop(int cont_addr CLS_DC)
 }
 
 
-void zend_do_while_cond(znode *expr, znode *close_bracket_token CLS_DC)
+void zend_do_while_cond(znode *expr, znode *close_bracket_token TSRMLS_DC)
 {
 	int while_cond_op_number = get_next_op_number(CG(active_op_array));
-	zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	opline->opcode = ZEND_JMPZ;
 	opline->op1 = *expr;
 	close_bracket_token->u.opline_num = while_cond_op_number;
 	SET_UNUSED(opline->op2);
 
-	do_begin_loop(CLS_C);
+	do_begin_loop(TSRMLS_C);
 	INC_BPC(CG(active_op_array));
 }
 
 
-void zend_do_while_end(znode *while_token, znode *close_bracket_token CLS_DC)
+void zend_do_while_end(znode *while_token, znode *close_bracket_token TSRMLS_DC)
 {
-	zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	/* add unconditional jump */
 	opline->opcode = ZEND_JMP;
@@ -384,16 +384,16 @@ void zend_do_while_end(znode *while_token, znode *close_bracket_token CLS_DC)
 	/* update while's conditional jmp */
 	CG(active_op_array)->opcodes[close_bracket_token->u.opline_num].op2.u.opline_num = get_next_op_number(CG(active_op_array));
 
-	do_end_loop(while_token->u.opline_num CLS_CC);
+	do_end_loop(while_token->u.opline_num TSRMLS_CC);
 
 	DEC_BPC(CG(active_op_array));
 }
 
 
-void zend_do_for_cond(znode *expr, znode *second_semicolon_token CLS_DC)
+void zend_do_for_cond(znode *expr, znode *second_semicolon_token TSRMLS_DC)
 {
 	int for_cond_op_number = get_next_op_number(CG(active_op_array));
-	zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	opline->opcode = ZEND_JMPZNZ;
 	opline->op1 = *expr;  /* the conditional expression */
@@ -402,9 +402,9 @@ void zend_do_for_cond(znode *expr, znode *second_semicolon_token CLS_DC)
 }
 
 
-void zend_do_for_before_statement(znode *cond_start, znode *second_semicolon_token CLS_DC)
+void zend_do_for_before_statement(znode *cond_start, znode *second_semicolon_token TSRMLS_DC)
 {
-	zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	opline->opcode = ZEND_JMP;
 	opline->op1.u.opline_num = cond_start->u.opline_num;
@@ -412,15 +412,15 @@ void zend_do_for_before_statement(znode *cond_start, znode *second_semicolon_tok
 	SET_UNUSED(opline->op1);
 	SET_UNUSED(opline->op2);
 
-	do_begin_loop(CLS_C);
+	do_begin_loop(TSRMLS_C);
 
 	INC_BPC(CG(active_op_array));
 }
 
 
-void zend_do_for_end(znode *second_semicolon_token CLS_DC)
+void zend_do_for_end(znode *second_semicolon_token TSRMLS_DC)
 {
-	zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	opline->opcode = ZEND_JMP;
 	opline->op1.u.opline_num = second_semicolon_token->u.opline_num+1;
@@ -428,15 +428,15 @@ void zend_do_for_end(znode *second_semicolon_token CLS_DC)
 	SET_UNUSED(opline->op1);
 	SET_UNUSED(opline->op2);
 
-	do_end_loop(second_semicolon_token->u.opline_num+1 CLS_CC);
+	do_end_loop(second_semicolon_token->u.opline_num+1 TSRMLS_CC);
 
 	DEC_BPC(CG(active_op_array));
 }
 
 
-void zend_do_pre_incdec(znode *result, znode *op1, int op CLS_DC)
+void zend_do_pre_incdec(znode *result, znode *op1, int op TSRMLS_DC)
 {
-	zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	opline->opcode = op;
 	opline->result.op_type = IS_VAR;
@@ -448,9 +448,9 @@ void zend_do_pre_incdec(znode *result, znode *op1, int op CLS_DC)
 }
 
 
-void zend_do_post_incdec(znode *result, znode *op1, int op CLS_DC)
+void zend_do_post_incdec(znode *result, znode *op1, int op TSRMLS_DC)
 {
-	zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	opline->opcode = op;
 	opline->result.op_type = IS_TMP_VAR;
@@ -461,10 +461,10 @@ void zend_do_post_incdec(znode *result, znode *op1, int op CLS_DC)
 }
 
 
-void zend_do_if_cond(znode *cond, znode *closing_bracket_token CLS_DC)
+void zend_do_if_cond(znode *cond, znode *closing_bracket_token TSRMLS_DC)
 {
 	int if_cond_op_number = get_next_op_number(CG(active_op_array));
-	zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	opline->opcode = ZEND_JMPZ;
 	opline->op1 = *cond;
@@ -474,10 +474,10 @@ void zend_do_if_cond(znode *cond, znode *closing_bracket_token CLS_DC)
 }
 
 
-void zend_do_if_after_statement(znode *closing_bracket_token, unsigned char initialize CLS_DC)
+void zend_do_if_after_statement(znode *closing_bracket_token, unsigned char initialize TSRMLS_DC)
 {
 	int if_end_op_number = get_next_op_number(CG(active_op_array));
-	zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 	zend_llist *jmp_list_ptr;
 
 	opline->opcode = ZEND_JMP;
@@ -497,7 +497,7 @@ void zend_do_if_after_statement(znode *closing_bracket_token, unsigned char init
 }
 
 
-void zend_do_if_end(CLS_D)
+void zend_do_if_end(TSRMLS_D)
 {
 	int next_op_number = get_next_op_number(CG(active_op_array));
 	zend_llist *jmp_list_ptr;
@@ -513,7 +513,7 @@ void zend_do_if_end(CLS_D)
 }
 
 
-void zend_do_begin_variable_parse(CLS_D)
+void zend_do_begin_variable_parse(TSRMLS_D)
 {
 	zend_llist fetch_list;
 
@@ -522,7 +522,7 @@ void zend_do_begin_variable_parse(CLS_D)
 }
 
 
-void zend_do_end_variable_parse(int type, int arg_offset CLS_DC)
+void zend_do_end_variable_parse(int type, int arg_offset TSRMLS_DC)
 {
 	zend_llist *fetch_list_ptr;
 	zend_llist_element *le;
@@ -534,7 +534,7 @@ void zend_do_end_variable_parse(int type, int arg_offset CLS_DC)
 
 	while (le) {
 		opline_ptr = (zend_op *)le->data;
-		opline = get_next_op(CG(active_op_array) CLS_CC);
+		opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 		memcpy(opline, opline_ptr, sizeof(zend_op));
 		switch (type) {
 			case BP_VAR_R:
@@ -566,7 +566,7 @@ void zend_do_end_variable_parse(int type, int arg_offset CLS_DC)
 }
 
 
-static zend_bool is_method_call(CLS_D)
+static zend_bool is_method_call(TSRMLS_D)
 {
 	zend_llist *fetch_list_ptr;
 	zend_llist_element *cur;
@@ -587,9 +587,9 @@ static zend_bool is_method_call(CLS_D)
 }
 
 
-void zend_do_init_string(znode *result CLS_DC)
+void zend_do_init_string(znode *result TSRMLS_DC)
 {
-	zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	opline->opcode = ZEND_INIT_STRING;
 	opline->result.op_type = IS_TMP_VAR;
@@ -600,9 +600,9 @@ void zend_do_init_string(znode *result CLS_DC)
 }
 
 
-void zend_do_add_char(znode *result, znode *op1, znode *op2 CLS_DC)
+void zend_do_add_char(znode *result, znode *op1, znode *op2 TSRMLS_DC)
 {
-	zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	opline->opcode = ZEND_ADD_CHAR;
 	opline->op1 = *op1;
@@ -613,9 +613,9 @@ void zend_do_add_char(znode *result, znode *op1, znode *op2 CLS_DC)
 }
 
 
-void zend_do_add_string(znode *result, znode *op1, znode *op2 CLS_DC)
+void zend_do_add_string(znode *result, znode *op1, znode *op2 TSRMLS_DC)
 {
-	zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	opline->opcode = ZEND_ADD_STRING;
 	opline->op1 = *op1;
@@ -626,12 +626,12 @@ void zend_do_add_string(znode *result, znode *op1, znode *op2 CLS_DC)
 }
 
 
-void zend_do_add_variable(znode *result, znode *op1, znode *op2 CLS_DC)
+void zend_do_add_variable(znode *result, znode *op1, znode *op2 TSRMLS_DC)
 {
 	zend_op *opline;
 
 	if (op1->op_type == IS_CONST) {
-		opline = get_next_op(CG(active_op_array) CLS_CC);
+		opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 		opline->opcode = ZEND_INIT_STRING;
 		opline->result.op_type = IS_TMP_VAR;
 		opline->result.u.var = get_temporary_variable(CG(active_op_array));
@@ -640,7 +640,7 @@ void zend_do_add_variable(znode *result, znode *op1, znode *op2 CLS_DC)
 		SET_UNUSED(opline->op2);
 
 		if (op1->u.constant.value.str.len>0) {
-			opline = get_next_op(CG(active_op_array) CLS_CC);
+			opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 			opline->opcode = ZEND_ADD_STRING;
 			opline->result = *result;
 			opline->op1 = *result;
@@ -653,7 +653,7 @@ void zend_do_add_variable(znode *result, znode *op1, znode *op2 CLS_DC)
 		*result = *op1;
 	}
 
-	opline = get_next_op(CG(active_op_array) CLS_CC);
+	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 	opline->opcode = ZEND_ADD_VAR;
 	opline->result = *result;
 	opline->op1 = *result;
@@ -662,10 +662,10 @@ void zend_do_add_variable(znode *result, znode *op1, znode *op2 CLS_DC)
 }
 
 	
-void zend_do_free(znode *op1 CLS_DC)
+void zend_do_free(znode *op1 TSRMLS_DC)
 {
 	if (op1->op_type==IS_TMP_VAR) {
-		zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+		zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 		opline->opcode = ZEND_FREE;
 		opline->op1 = *op1;
@@ -710,7 +710,7 @@ void zend_do_free(znode *op1 CLS_DC)
 }
 
 
-void zend_do_begin_function_declaration(znode *function_token, znode *function_name, int is_method, int return_reference  CLS_DC)
+void zend_do_begin_function_declaration(znode *function_token, znode *function_name, int is_method, int return_reference  TSRMLS_DC)
 {
 	zend_op_array op_array;
 	char *name = function_name->u.constant.value.str.val;
@@ -720,7 +720,7 @@ void zend_do_begin_function_declaration(znode *function_token, znode *function_n
 	function_token->u.op_array = CG(active_op_array);
 	zend_str_tolower(name, name_len);
 
-	init_op_array(&op_array, ZEND_USER_FUNCTION, INITIAL_OP_ARRAY_SIZE CLS_CC);
+	init_op_array(&op_array, ZEND_USER_FUNCTION, INITIAL_OP_ARRAY_SIZE TSRMLS_CC);
 
 	op_array.function_name = name;
 	op_array.arg_types = NULL;
@@ -729,11 +729,11 @@ void zend_do_begin_function_declaration(znode *function_token, znode *function_n
 	if (is_method) {
 		zend_hash_update(&CG(active_class_entry)->function_table, name, name_len+1, &op_array, sizeof(zend_op_array), (void **) &CG(active_op_array));
 	} else {
-		zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+		zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 		opline->opcode = ZEND_DECLARE_FUNCTION_OR_CLASS;
 		opline->op1.op_type = IS_CONST;
-		build_runtime_defined_function_key(&opline->op1.u.constant, &function_name->u.constant, opline CLS_CC);
+		build_runtime_defined_function_key(&opline->op1.u.constant, &function_name->u.constant, opline TSRMLS_CC);
 		opline->op2.op_type = IS_CONST;
 		opline->op2.u.constant.type = IS_STRING;
 		opline->op2.u.constant.value.str.val = estrndup(name, name_len);
@@ -744,7 +744,7 @@ void zend_do_begin_function_declaration(znode *function_token, znode *function_n
 	}
 
 	if (CG(extended_info)) {
-		zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+		zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 		opline->opcode = ZEND_EXT_NOP;
 		opline->lineno = function_begin_line;
@@ -767,10 +767,10 @@ void zend_do_begin_function_declaration(znode *function_token, znode *function_n
 }
 
 
-void zend_do_end_function_declaration(znode *function_token CLS_DC)
+void zend_do_end_function_declaration(znode *function_token TSRMLS_DC)
 {
-	zend_do_extended_info(CLS_C);
-	zend_do_return(NULL, 0 CLS_CC);
+	zend_do_extended_info(TSRMLS_C);
+	zend_do_return(NULL, 0 TSRMLS_CC);
 	pass_two(CG(active_op_array));
 	CG(active_op_array) = function_token->u.op_array;
 
@@ -780,9 +780,9 @@ void zend_do_end_function_declaration(znode *function_token CLS_DC)
 }
 
 
-void zend_do_receive_arg(int op, znode *var, znode *offset, znode *initialization, unsigned char pass_type CLS_DC)
+void zend_do_receive_arg(int op, znode *var, znode *offset, znode *initialization, unsigned char pass_type TSRMLS_DC)
 {
-	zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	opline->opcode = op;
 	opline->result = *var;
@@ -811,7 +811,7 @@ void zend_do_receive_arg(int op, znode *var, znode *offset, znode *initializatio
 }
 
 
-int zend_do_begin_function_call(znode *function_name CLS_DC)
+int zend_do_begin_function_call(znode *function_name TSRMLS_DC)
 {
 	zend_function *function;
 	
@@ -820,7 +820,7 @@ int zend_do_begin_function_call(znode *function_name CLS_DC)
 		znode tmp = *function_name;
 
 		zval_copy_ctor(&tmp.u.constant);
-		zend_do_begin_dynamic_function_call(&tmp CLS_CC);
+		zend_do_begin_dynamic_function_call(&tmp TSRMLS_CC);
 		return 1; /* Dynamic */
 	}
 	
@@ -838,19 +838,19 @@ int zend_do_begin_function_call(znode *function_name CLS_DC)
 			}
 			break;
 	}
-	zend_do_extended_fcall_begin(CLS_C); 
+	zend_do_extended_fcall_begin(TSRMLS_C); 
 	return 0;
 }
 
 
-void zend_do_begin_dynamic_function_call(znode *function_name CLS_DC)
+void zend_do_begin_dynamic_function_call(znode *function_name TSRMLS_DC)
 {
 	unsigned char *ptr = NULL;
 	int last_op_number;
 	zend_op *last_op;
 
-	if (function_name->op_type != IS_CONST && is_method_call(CLS_C)) {
-		zend_do_end_variable_parse(BP_VAR_W, 0 CLS_CC);
+	if (function_name->op_type != IS_CONST && is_method_call(TSRMLS_C)) {
+		zend_do_end_variable_parse(BP_VAR_W, 0 TSRMLS_CC);
 		last_op_number = get_next_op_number(CG(active_op_array))-1;
 		last_op = &CG(active_op_array)->opcodes[last_op_number];
 		last_op->opcode = ZEND_INIT_FCALL_BY_NAME;
@@ -859,24 +859,24 @@ void zend_do_begin_dynamic_function_call(znode *function_name CLS_DC)
 		zend_op *opline;
 
 		if (function_name->op_type != IS_CONST) {
-			zend_do_end_variable_parse(BP_VAR_R, 0 CLS_CC);
+			zend_do_end_variable_parse(BP_VAR_R, 0 TSRMLS_CC);
 		}
 
-		opline = get_next_op(CG(active_op_array) CLS_CC);
+		opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 		opline->opcode = ZEND_INIT_FCALL_BY_NAME;
 		opline->op2 = *function_name;
 		opline->extended_value = 0;
 		SET_UNUSED(opline->op1);
 	}
 	zend_stack_push(&CG(function_call_stack), (void *) &ptr, sizeof(zend_function *));
-	zend_do_extended_fcall_begin(CLS_C); 
+	zend_do_extended_fcall_begin(TSRMLS_C); 
 }
 
 
-void zend_do_begin_class_member_function_call(znode *class_name, znode *function_name CLS_DC)
+void zend_do_begin_class_member_function_call(znode *class_name, znode *function_name TSRMLS_DC)
 {
 	unsigned char *ptr = NULL;
-	zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	opline->opcode = ZEND_INIT_FCALL_BY_NAME;
 	zend_str_tolower(class_name->u.constant.value.str.val, class_name->u.constant.value.str.len);
@@ -895,9 +895,9 @@ void zend_do_begin_class_member_function_call(znode *class_name, znode *function
 }
 
 
-void zend_do_end_function_call(znode *function_name, znode *result, znode *argument_list, int is_method, int is_dynamic_fcall CLS_DC)
+void zend_do_end_function_call(znode *function_name, znode *result, znode *argument_list, int is_method, int is_dynamic_fcall TSRMLS_DC)
 {
-	zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 	
 	if (function_name->op_type==IS_CONST && !is_method && !is_dynamic_fcall) {
 		opline->opcode = ZEND_DO_FCALL;
@@ -915,7 +915,7 @@ void zend_do_end_function_call(znode *function_name, znode *result, znode *argum
 }
 
 
-void zend_do_pass_param(znode *param, int op, int offset CLS_DC)
+void zend_do_pass_param(znode *param, int op, int offset TSRMLS_DC)
 {
 	zend_op *opline;
 	unsigned char *arg_types;
@@ -966,22 +966,22 @@ void zend_do_pass_param(znode *param, int op, int offset CLS_DC)
 	if (original_op == ZEND_SEND_VAR) {
 		switch(op) {
 			case ZEND_SEND_VAR_NO_REF:
-				zend_do_end_variable_parse(BP_VAR_R, 0 CLS_CC);
+				zend_do_end_variable_parse(BP_VAR_R, 0 TSRMLS_CC);
 				break;
 			case ZEND_SEND_VAR:
 				if (function_ptr) {
-					zend_do_end_variable_parse(BP_VAR_R, 0 CLS_CC);
+					zend_do_end_variable_parse(BP_VAR_R, 0 TSRMLS_CC);
 				} else {
-					zend_do_end_variable_parse(BP_VAR_FUNC_ARG, offset CLS_CC);
+					zend_do_end_variable_parse(BP_VAR_FUNC_ARG, offset TSRMLS_CC);
 				}
 				break;
 			case ZEND_SEND_REF:
-				zend_do_end_variable_parse(BP_VAR_W, 0 CLS_CC);
+				zend_do_end_variable_parse(BP_VAR_W, 0 TSRMLS_CC);
 				break;
 		}
 	}
 
-	opline = get_next_op(CG(active_op_array) CLS_CC);
+	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	if (op == ZEND_SEND_VAR_NO_REF) {
 		if (function_ptr) {
@@ -1003,7 +1003,7 @@ void zend_do_pass_param(znode *param, int op, int offset CLS_DC)
 }
 
 
-static int generate_free_switch_expr(zend_switch_entry *switch_entry CLS_DC)
+static int generate_free_switch_expr(zend_switch_entry *switch_entry TSRMLS_DC)
 {
 	zend_op *opline;
 	
@@ -1011,7 +1011,7 @@ static int generate_free_switch_expr(zend_switch_entry *switch_entry CLS_DC)
 		return 1;
 	}
 	
-	opline = get_next_op(CG(active_op_array) CLS_CC);
+	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	opline->opcode = ZEND_SWITCH_FREE;
 	opline->op1 = switch_entry->cond;
@@ -1020,7 +1020,7 @@ static int generate_free_switch_expr(zend_switch_entry *switch_entry CLS_DC)
 	return 0;
 }
 
-static int generate_free_foreach_copy(znode *foreach_copy CLS_DC)
+static int generate_free_foreach_copy(znode *foreach_copy TSRMLS_DC)
 {
 	zend_op *opline;
 	
@@ -1028,7 +1028,7 @@ static int generate_free_foreach_copy(znode *foreach_copy CLS_DC)
 		return 1;
 	}
 
-	opline = get_next_op(CG(active_op_array) CLS_CC);
+	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	opline->opcode = ZEND_SWITCH_FREE;
 	opline->op1 = *foreach_copy;
@@ -1037,15 +1037,15 @@ static int generate_free_foreach_copy(znode *foreach_copy CLS_DC)
 	return 0;
 }
 
-void zend_do_return(znode *expr, int do_end_vparse CLS_DC)
+void zend_do_return(znode *expr, int do_end_vparse TSRMLS_DC)
 {
 	zend_op *opline;
 	
 	if (do_end_vparse) {
 		if (CG(active_op_array)->return_reference) {
-			zend_do_end_variable_parse(BP_VAR_W, 0 CLS_CC);
+			zend_do_end_variable_parse(BP_VAR_W, 0 TSRMLS_CC);
 		} else {
-			zend_do_end_variable_parse(BP_VAR_R, 0 CLS_CC);
+			zend_do_end_variable_parse(BP_VAR_R, 0 TSRMLS_CC);
 		}
 #if 0
 	} else if (expr && CG(active_op_array)->return_reference) {
@@ -1054,14 +1054,14 @@ void zend_do_return(znode *expr, int do_end_vparse CLS_DC)
 	}
 
 #ifdef ZTS
-	zend_stack_apply_with_argument(&CG(switch_cond_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element, void *)) generate_free_switch_expr CLS_CC);
-	zend_stack_apply_with_argument(&CG(foreach_copy_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element, void *)) generate_free_foreach_copy CLS_CC);
+	zend_stack_apply_with_argument(&CG(switch_cond_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element, void *)) generate_free_switch_expr TSRMLS_CC);
+	zend_stack_apply_with_argument(&CG(foreach_copy_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element, void *)) generate_free_foreach_copy TSRMLS_CC);
 #else
 	zend_stack_apply(&CG(switch_cond_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element)) generate_free_switch_expr);
 	zend_stack_apply(&CG(foreach_copy_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element)) generate_free_foreach_copy);
 #endif
 
-	opline = get_next_op(CG(active_op_array) CLS_CC);
+	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	opline->opcode = ZEND_RETURN;
 	
@@ -1220,7 +1220,7 @@ ZEND_API int do_bind_function_or_class(zend_op *opline, HashTable *function_tabl
 }
 
 
-void zend_do_early_binding(CLS_D)
+void zend_do_early_binding(TSRMLS_D)
 {
 	zend_op *opline = &CG(active_op_array)->opcodes[CG(active_op_array)->last-1];
 	HashTable *table;
@@ -1250,10 +1250,10 @@ void zend_do_early_binding(CLS_D)
 }
 
 
-void zend_do_boolean_or_begin(znode *expr1, znode *op_token CLS_DC)
+void zend_do_boolean_or_begin(znode *expr1, znode *op_token TSRMLS_DC)
 {
 	int next_op_number = get_next_op_number(CG(active_op_array));
-	zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	opline->opcode = ZEND_JMPNZ_EX;
 	if (expr1->op_type == IS_TMP_VAR) {
@@ -1271,9 +1271,9 @@ void zend_do_boolean_or_begin(znode *expr1, znode *op_token CLS_DC)
 }
 
 
-void zend_do_boolean_or_end(znode *result, znode *expr1, znode *expr2, znode *op_token CLS_DC)
+void zend_do_boolean_or_end(znode *result, znode *expr1, znode *expr2, znode *op_token TSRMLS_DC)
 {
-	zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	*result = *expr1; /* we saved the original result in expr1 */
 	opline->opcode = ZEND_BOOL;
@@ -1285,10 +1285,10 @@ void zend_do_boolean_or_end(znode *result, znode *expr1, znode *expr2, znode *op
 }
 
 
-void zend_do_boolean_and_begin(znode *expr1, znode *op_token CLS_DC)
+void zend_do_boolean_and_begin(znode *expr1, znode *op_token TSRMLS_DC)
 {
 	int next_op_number = get_next_op_number(CG(active_op_array));
-	zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	opline->opcode = ZEND_JMPZ_EX;
 	if (expr1->op_type == IS_TMP_VAR) {
@@ -1306,9 +1306,9 @@ void zend_do_boolean_and_begin(znode *expr1, znode *op_token CLS_DC)
 }
 
 
-void zend_do_boolean_and_end(znode *result, znode *expr1, znode *expr2, znode *op_token CLS_DC)
+void zend_do_boolean_and_end(znode *result, znode *expr1, znode *expr2, znode *op_token TSRMLS_DC)
 {
-	zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	*result = *expr1; /* we saved the original result in expr1 */
 	opline->opcode = ZEND_BOOL;
@@ -1320,31 +1320,31 @@ void zend_do_boolean_and_end(znode *result, znode *expr1, znode *expr2, znode *o
 }
 
 
-void zend_do_do_while_begin(CLS_D)
+void zend_do_do_while_begin(TSRMLS_D)
 {
-	do_begin_loop(CLS_C);
+	do_begin_loop(TSRMLS_C);
 	INC_BPC(CG(active_op_array));
 }
 
 
-void zend_do_do_while_end(znode *do_token, znode *expr_open_bracket, znode *expr CLS_DC)
+void zend_do_do_while_end(znode *do_token, znode *expr_open_bracket, znode *expr TSRMLS_DC)
 {
-	zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	opline->opcode = ZEND_JMPNZ;
 	opline->op1 = *expr;
 	opline->op2.u.opline_num = do_token->u.opline_num;
 	SET_UNUSED(opline->op2);
 
-	do_end_loop(expr_open_bracket->u.opline_num CLS_CC);
+	do_end_loop(expr_open_bracket->u.opline_num TSRMLS_CC);
 
 	DEC_BPC(CG(active_op_array));
 }
 
 
-void zend_do_brk_cont(int op, znode *expr CLS_DC)
+void zend_do_brk_cont(int op, znode *expr TSRMLS_DC)
 {
-	zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	opline->opcode = op;
 	opline->op1.u.opline_num = CG(active_op_array)->current_brk_cont;
@@ -1360,13 +1360,13 @@ void zend_do_brk_cont(int op, znode *expr CLS_DC)
 }
 
 
-void zend_do_switch_cond(znode *cond CLS_DC)
+void zend_do_switch_cond(znode *cond TSRMLS_DC)
 {
 	zend_switch_entry switch_entry;
 	zend_op *opline;
 
 	/* Initialize the conditional value */
-	opline = get_next_op(CG(active_op_array) CLS_CC);
+	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 	opline->opcode = ZEND_BOOL;
 	opline->result.u.var = get_temporary_variable(CG(active_op_array));
 	opline->result.op_type = IS_TMP_VAR;
@@ -1381,14 +1381,14 @@ void zend_do_switch_cond(znode *cond CLS_DC)
 	switch_entry.control_var = opline->result.u.var;
 	zend_stack_push(&CG(switch_cond_stack), (void *) &switch_entry, sizeof(switch_entry));
 
-	do_begin_loop(CLS_C);
+	do_begin_loop(TSRMLS_C);
 
 	INC_BPC(CG(active_op_array));
 }
 
 
 
-void zend_do_switch_end(znode *case_list CLS_DC)
+void zend_do_switch_end(znode *case_list TSRMLS_DC)
 {
 	zend_op *opline;
 	zend_switch_entry *switch_entry_ptr;
@@ -1403,7 +1403,7 @@ void zend_do_switch_end(znode *case_list CLS_DC)
 
 	/* add code to jmp to default case */
 	if (switch_entry_ptr->default_case != -1) {
-		opline = get_next_op(CG(active_op_array) CLS_CC);
+		opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 		opline->opcode = ZEND_JMPZ;
 		opline->op1.op_type = IS_TMP_VAR;
 		opline->op1.u.var = switch_entry_ptr->control_var;
@@ -1418,7 +1418,7 @@ void zend_do_switch_end(znode *case_list CLS_DC)
 
 	if (switch_entry_ptr->cond.op_type==IS_VAR || switch_entry_ptr->cond.op_type==IS_TMP_VAR) {
 		/* emit free for the switch condition*/
-		opline = get_next_op(CG(active_op_array) CLS_CC);
+		opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 		opline->opcode = ZEND_SWITCH_FREE;
 		opline->op1 = switch_entry_ptr->cond;
 		SET_UNUSED(opline->op2);
@@ -1433,9 +1433,9 @@ void zend_do_switch_end(znode *case_list CLS_DC)
 }
 
 
-void zend_do_case_before_statement(znode *case_list, znode *case_token, znode *case_expr CLS_DC)
+void zend_do_case_before_statement(znode *case_list, znode *case_token, znode *case_expr TSRMLS_DC)
 {
-	zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 	int next_op_number;
 	zend_switch_entry *switch_entry_ptr;
 	znode result;
@@ -1453,7 +1453,7 @@ void zend_do_case_before_statement(znode *case_list, znode *case_token, znode *c
 	result = opline->result;
 	
 	next_op_number = get_next_op_number(CG(active_op_array));
-	opline = get_next_op(CG(active_op_array) CLS_CC);
+	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 	opline->opcode = ZEND_JMPZ;
 	opline->op1 = result;
 	SET_UNUSED(opline->op2);
@@ -1467,10 +1467,10 @@ void zend_do_case_before_statement(znode *case_list, znode *case_token, znode *c
 }
 
 
-void zend_do_case_after_statement(znode *result, znode *case_token CLS_DC)
+void zend_do_case_after_statement(znode *result, znode *case_token TSRMLS_DC)
 {
 	int next_op_number = get_next_op_number(CG(active_op_array));
-	zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	opline->opcode = ZEND_JMP;
 	SET_UNUSED(opline->op1);
@@ -1489,10 +1489,10 @@ void zend_do_case_after_statement(znode *result, znode *case_token CLS_DC)
 
 
 
-void zend_do_default_before_statement(znode *case_list, znode *default_token CLS_DC)
+void zend_do_default_before_statement(znode *case_list, znode *default_token TSRMLS_DC)
 {
 	int next_op_number = get_next_op_number(CG(active_op_array));
-	zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 	zend_switch_entry *switch_entry_ptr;
 
 	zend_stack_top(&CG(switch_cond_stack), (void **) &switch_entry_ptr);
@@ -1503,7 +1503,7 @@ void zend_do_default_before_statement(znode *case_list, znode *default_token CLS
 	default_token->u.opline_num = next_op_number;
 
 	next_op_number = get_next_op_number(CG(active_op_array));
-	opline = get_next_op(CG(active_op_array) CLS_CC);
+	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 	opline->opcode = ZEND_BOOL;
 	opline->result.u.var = switch_entry_ptr->control_var;
 	opline->result.op_type = IS_TMP_VAR;
@@ -1522,9 +1522,9 @@ void zend_do_default_before_statement(znode *case_list, znode *default_token CLS
 }
 
 
-void zend_do_begin_class_declaration(znode *class_name, znode *parent_class_name CLS_DC)
+void zend_do_begin_class_declaration(znode *class_name, znode *parent_class_name TSRMLS_DC)
 {
-	zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 	int runtime_inheritance = 0;
 
 	if (CG(active_class_entry)) {
@@ -1582,7 +1582,7 @@ void zend_do_begin_class_declaration(znode *class_name, znode *parent_class_name
 
 	opline->opcode = ZEND_DECLARE_FUNCTION_OR_CLASS;
 	opline->op1.op_type = IS_CONST;
-	build_runtime_defined_function_key(&opline->op1.u.constant, &class_name->u.constant, opline CLS_CC);
+	build_runtime_defined_function_key(&opline->op1.u.constant, &class_name->u.constant, opline TSRMLS_CC);
 	opline->op2.op_type = IS_CONST;
 	opline->op2.u.constant.type = IS_STRING;
 	opline->op2.u.constant.refcount = 1;
@@ -1611,7 +1611,7 @@ void zend_do_begin_class_declaration(znode *class_name, znode *parent_class_name
 }
 
 
-void zend_do_end_class_declaration(CLS_D)
+void zend_do_end_class_declaration(TSRMLS_D)
 {
 	do_inherit_parent_constructor(CG(active_class_entry));
 	CG(active_class_entry) = NULL;
@@ -1622,7 +1622,7 @@ void zend_do_end_class_declaration(CLS_D)
 }
 
 
-void zend_do_declare_property(znode *var_name, znode *value CLS_DC)
+void zend_do_declare_property(znode *var_name, znode *value TSRMLS_DC)
 {
 	if (value) {
 		zval *property;
@@ -1636,12 +1636,12 @@ void zend_do_declare_property(znode *var_name, znode *value CLS_DC)
 }
 
 
-void zend_do_fetch_property(znode *result, znode *object, znode *property CLS_DC)
+void zend_do_fetch_property(znode *result, znode *object, znode *property TSRMLS_DC)
 {
 	zend_op opline;
 	zend_llist *fetch_list_ptr;
 
-	init_op(&opline CLS_CC);
+	init_op(&opline TSRMLS_CC);
 	opline.opcode = ZEND_FETCH_OBJ_W;	/* the backpatching routine assumes W */
 	opline.result.op_type = IS_VAR;
 	opline.result.u.EA.type = 0;
@@ -1655,13 +1655,13 @@ void zend_do_fetch_property(znode *result, znode *object, znode *property CLS_DC
 }
 
 
-void zend_do_push_object(znode *object CLS_DC)
+void zend_do_push_object(znode *object TSRMLS_DC)
 {
 	zend_stack_push(&CG(object_stack), object, sizeof(znode));
 }
 
 
-void zend_do_pop_object(znode *object CLS_DC)
+void zend_do_pop_object(znode *object TSRMLS_DC)
 {
 	znode *tmp;
 
@@ -1671,9 +1671,9 @@ void zend_do_pop_object(znode *object CLS_DC)
 }
 
 
-void zend_do_begin_new_object(znode *new_token, znode *class_name CLS_DC)
+void zend_do_begin_new_object(znode *new_token, znode *class_name TSRMLS_DC)
 {
-	zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 	unsigned char *ptr = NULL;
 	
 	opline->opcode = ZEND_NEW;
@@ -1683,7 +1683,7 @@ void zend_do_begin_new_object(znode *new_token, znode *class_name CLS_DC)
 	SET_UNUSED(opline->op2);
 
 	new_token->u.opline_num = get_next_op_number(CG(active_op_array));
-	opline = get_next_op(CG(active_op_array) CLS_CC);
+	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 	opline->opcode = ZEND_JMP_NO_CTOR;
 	opline->op1 = (opline-1)->result;
 	SET_UNUSED(opline->op2);
@@ -1691,7 +1691,7 @@ void zend_do_begin_new_object(znode *new_token, znode *class_name CLS_DC)
 	if (class_name->op_type == IS_CONST) {
 		zval_copy_ctor(&class_name->u.constant);
 	}
-	opline = get_next_op(CG(active_op_array) CLS_CC);
+	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 	opline->opcode = ZEND_INIT_FCALL_BY_NAME;
 	opline->op1 = (opline-2)->result;
 	opline->op2 = *class_name;
@@ -1700,22 +1700,22 @@ void zend_do_begin_new_object(znode *new_token, znode *class_name CLS_DC)
 }
 
 
-void zend_do_end_new_object(znode *result, znode *class_name, znode *new_token, znode *argument_list CLS_DC)
+void zend_do_end_new_object(znode *result, znode *class_name, znode *new_token, znode *argument_list TSRMLS_DC)
 {
 	znode ctor_result;
 
 	if (class_name->op_type == IS_CONST) {
 		zval_copy_ctor(&class_name->u.constant);
 	}
-	zend_do_end_function_call(class_name, &ctor_result, argument_list, 1, 0 CLS_CC);
-	zend_do_free(&ctor_result CLS_CC);
+	zend_do_end_function_call(class_name, &ctor_result, argument_list, 1, 0 TSRMLS_CC);
+	zend_do_free(&ctor_result TSRMLS_CC);
 
 	CG(active_op_array)->opcodes[new_token->u.opline_num].op2.u.opline_num = get_next_op_number(CG(active_op_array));
 	*result = CG(active_op_array)->opcodes[new_token->u.opline_num].op1;
 }
 
 
-void zend_do_fetch_constant(znode *result, znode *constant_name, int mode CLS_DC)
+void zend_do_fetch_constant(znode *result, znode *constant_name, int mode TSRMLS_DC)
 {
 	switch (mode) {
 		case ZEND_CT:
@@ -1723,7 +1723,7 @@ void zend_do_fetch_constant(znode *result, znode *constant_name, int mode CLS_DC
 			result->u.constant.type = IS_CONSTANT;
 			break;
 		case ZEND_RT: {
-				zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+				zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 	
 				opline->opcode = ZEND_FETCH_CONSTANT;
 				opline->result.op_type = IS_TMP_VAR;
@@ -1737,9 +1737,9 @@ void zend_do_fetch_constant(znode *result, znode *constant_name, int mode CLS_DC
 }
 
 
-void zend_do_shell_exec(znode *result, znode *cmd CLS_DC)
+void zend_do_shell_exec(znode *result, znode *cmd TSRMLS_DC)
 {
-	zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	switch (cmd->op_type) {
 		case IS_TMP_VAR:
@@ -1754,7 +1754,7 @@ void zend_do_shell_exec(znode *result, znode *cmd CLS_DC)
 	opline->extended_value = ZEND_DO_FCALL;
 	SET_UNUSED(opline->op2);
 
-	opline = get_next_op(CG(active_op_array) CLS_CC);
+	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 	opline->opcode = ZEND_DO_FCALL;
 	opline->result.u.var = get_temporary_variable(CG(active_op_array));
 	opline->result.op_type = IS_VAR;
@@ -1770,9 +1770,9 @@ void zend_do_shell_exec(znode *result, znode *cmd CLS_DC)
 
 
 
-void zend_do_init_array(znode *result, znode *expr, znode *offset, int is_ref CLS_DC)
+void zend_do_init_array(znode *result, znode *expr, znode *offset, int is_ref TSRMLS_DC)
 {
-	zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	opline->opcode = ZEND_INIT_ARRAY;
 	opline->result.u.var = get_temporary_variable(CG(active_op_array));
@@ -1793,9 +1793,9 @@ void zend_do_init_array(znode *result, znode *expr, znode *offset, int is_ref CL
 }
 
 
-void zend_do_add_array_element(znode *result, znode *expr, znode *offset, int is_ref CLS_DC)
+void zend_do_add_array_element(znode *result, znode *expr, znode *offset, int is_ref TSRMLS_DC)
 {
-	zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	opline->opcode = ZEND_ADD_ARRAY_ELEMENT;
 	opline->result = *result;
@@ -1836,7 +1836,7 @@ void zend_do_add_static_array_element(znode *result, znode *offset, znode *expr)
 }
 
 
-void zend_do_add_list_element(znode *element CLS_DC)
+void zend_do_add_list_element(znode *element TSRMLS_DC)
 {
 	list_llist_element lle;
 
@@ -1849,31 +1849,31 @@ void zend_do_add_list_element(znode *element CLS_DC)
 }
 
 
-void zend_do_new_list_begin(CLS_D)
+void zend_do_new_list_begin(TSRMLS_D)
 {
 	int current_dimension = 0;
 	zend_llist_add_element(&CG(dimension_llist), &current_dimension);
 }
 
 
-void zend_do_new_list_end(CLS_D)
+void zend_do_new_list_end(TSRMLS_D)
 {
 	zend_llist_remove_tail(&CG(dimension_llist));
 	(*((int *)CG(dimension_llist).tail->data))++;
 }
 
 
-void zend_do_list_init(CLS_D)
+void zend_do_list_init(TSRMLS_D)
 {
 	zend_stack_push(&CG(list_stack), &CG(list_llist), sizeof(zend_llist));
 	zend_stack_push(&CG(list_stack), &CG(dimension_llist), sizeof(zend_llist));
 	zend_llist_init(&CG(list_llist), sizeof(list_llist_element), NULL, 0);
 	zend_llist_init(&CG(dimension_llist), sizeof(int), NULL, 0);
-	zend_do_new_list_begin(CLS_C);
+	zend_do_new_list_begin(TSRMLS_C);
 }
 
 
-void zend_do_list_end(znode *result, znode *expr CLS_DC)
+void zend_do_list_end(znode *result, znode *expr TSRMLS_DC)
 {
 	zend_llist_element *le;
 	zend_llist_element *dimension;
@@ -1885,7 +1885,7 @@ void zend_do_list_end(znode *result, znode *expr CLS_DC)
 		zend_llist *tmp_dimension_llist = &((list_llist_element *)le->data)->dimensions;
 		dimension = tmp_dimension_llist->head;
 		while (dimension) {
-			opline = get_next_op(CG(active_op_array) CLS_CC);
+			opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 			if (dimension == tmp_dimension_llist->head) { /* first */
 				last_container = *expr;
 				switch(expr->op_type) {
@@ -1917,8 +1917,8 @@ void zend_do_list_end(znode *result, znode *expr CLS_DC)
 		}
 		((list_llist_element *) le->data)->value = last_container;
 		zend_llist_destroy(&((list_llist_element *) le->data)->dimensions);
-		zend_do_end_variable_parse(BP_VAR_W, 0 CLS_CC);
-		zend_do_assign(result, &((list_llist_element *) le->data)->var, &((list_llist_element *) le->data)->value CLS_CC);
+		zend_do_end_variable_parse(BP_VAR_W, 0 TSRMLS_CC);
+		zend_do_assign(result, &((list_llist_element *) le->data)->var, &((list_llist_element *) le->data)->value TSRMLS_CC);
 		CG(active_op_array)->opcodes[CG(active_op_array)->last-1].result.u.EA.type |= EXT_TYPE_UNUSED;
 		le = le->next;
 	}
@@ -1939,9 +1939,9 @@ void zend_do_list_end(znode *result, znode *expr CLS_DC)
 }
 
 
-void zend_do_fetch_global_or_static_variable(znode *varname, znode *static_assignment, int fetch_type CLS_DC)
+void zend_do_fetch_global_or_static_variable(znode *varname, znode *static_assignment, int fetch_type TSRMLS_DC)
 {
-	zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 	znode lval;
 	znode result;
 
@@ -1971,16 +1971,16 @@ void zend_do_fetch_global_or_static_variable(znode *varname, znode *static_assig
 	if (varname->op_type == IS_CONST) {
 		zval_copy_ctor(&varname->u.constant);
 	}
-	fetch_simple_variable(&lval, varname, 0 CLS_CC); /* Relies on the fact that the default fetch is BP_VAR_W */
+	fetch_simple_variable(&lval, varname, 0 TSRMLS_CC); /* Relies on the fact that the default fetch is BP_VAR_W */
 
-	zend_do_assign_ref(NULL, &lval, &result CLS_CC);
+	zend_do_assign_ref(NULL, &lval, &result TSRMLS_CC);
 	CG(active_op_array)->opcodes[CG(active_op_array)->last-1].result.u.EA.type |= EXT_TYPE_UNUSED;
 }
 
 
-void zend_do_cast(znode *result, znode *expr, int type CLS_DC)
+void zend_do_cast(znode *result, znode *expr, int type TSRMLS_DC)
 {
-	zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	opline->opcode = ZEND_CAST;
 	opline->result.op_type = IS_TMP_VAR;
@@ -1992,11 +1992,11 @@ void zend_do_cast(znode *result, znode *expr, int type CLS_DC)
 }
 
 
-void zend_do_include_or_eval(int type, znode *result, znode *op1 CLS_DC)
+void zend_do_include_or_eval(int type, znode *result, znode *op1 TSRMLS_DC)
 {
-	zend_do_extended_fcall_begin(CLS_C);
+	zend_do_extended_fcall_begin(TSRMLS_C);
 	{
-		zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+		zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 		opline->opcode = ZEND_INCLUDE_OR_EVAL;
 		opline->result.op_type = IS_VAR;
@@ -2009,25 +2009,25 @@ void zend_do_include_or_eval(int type, znode *result, znode *op1 CLS_DC)
 			opline->result.u.EA.type |= EXT_TYPE_UNUSED;
 		}
 	}
-	zend_do_extended_fcall_end(CLS_C);
+	zend_do_extended_fcall_end(TSRMLS_C);
 }
 
 
-void zend_do_indirect_references(znode *result, znode *num_references, znode *variable CLS_DC)
+void zend_do_indirect_references(znode *result, znode *num_references, znode *variable TSRMLS_DC)
 {
 	int i;
 
-	zend_do_end_variable_parse(BP_VAR_R, 0 CLS_CC);
+	zend_do_end_variable_parse(BP_VAR_R, 0 TSRMLS_CC);
 	for (i=1; i<num_references->u.constant.value.lval; i++) {
-		fetch_simple_variable_ex(result, variable, 0, ZEND_FETCH_R CLS_CC);
+		fetch_simple_variable_ex(result, variable, 0, ZEND_FETCH_R TSRMLS_CC);
 		*variable = *result;
 	}
-	zend_do_begin_variable_parse(CLS_C);
-	fetch_simple_variable(result, variable, 1 CLS_CC);
+	zend_do_begin_variable_parse(TSRMLS_C);
+	fetch_simple_variable(result, variable, 1 TSRMLS_CC);
 }
 
 
-void zend_do_unset(znode *variable CLS_DC)
+void zend_do_unset(znode *variable TSRMLS_DC)
 {
 	zend_op *last_op;
 
@@ -2046,12 +2046,12 @@ void zend_do_unset(znode *variable CLS_DC)
 }
 
 
-void zend_do_isset_or_isempty(int type, znode *result, znode *variable CLS_DC)
+void zend_do_isset_or_isempty(int type, znode *result, znode *variable TSRMLS_DC)
 {
 	zend_op *opline;
 
-	zend_do_end_variable_parse(BP_VAR_IS, 0 CLS_CC);
-	opline = get_next_op(CG(active_op_array) CLS_CC);
+	zend_do_end_variable_parse(BP_VAR_IS, 0 TSRMLS_CC);
+	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	opline->opcode = ZEND_ISSET_ISEMPTY;
 	opline->result.op_type = IS_TMP_VAR;
@@ -2063,9 +2063,9 @@ void zend_do_isset_or_isempty(int type, znode *result, znode *variable CLS_DC)
 }
 
 
-void zend_do_foreach_begin(znode *foreach_token, znode *array, znode *open_brackets_token, znode *as_token, int variable CLS_DC)
+void zend_do_foreach_begin(znode *foreach_token, znode *array, znode *open_brackets_token, znode *as_token, int variable TSRMLS_DC)
 {
-	zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	/* Preform array reset */
 	opline->opcode = ZEND_FE_RESET;
@@ -2085,7 +2085,7 @@ void zend_do_foreach_begin(znode *foreach_token, znode *array, znode *open_brack
 	/* save the location of the beginning of the loop (array fetching) */
 	foreach_token->u.opline_num = get_next_op_number(CG(active_op_array));
 
-	opline = get_next_op(CG(active_op_array) CLS_CC);
+	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 	opline->opcode = ZEND_FE_FETCH;
 	opline->result.op_type = IS_TMP_VAR;
 	opline->result.u.var = get_temporary_variable(CG(active_op_array));
@@ -2095,9 +2095,9 @@ void zend_do_foreach_begin(znode *foreach_token, znode *array, znode *open_brack
 }
 
 
-void zend_do_foreach_cont(znode *value, znode *key, znode *as_token CLS_DC)
+void zend_do_foreach_cont(znode *value, znode *key, znode *as_token TSRMLS_DC)
 {
-	zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 	znode result_value, result_key, dummy;
 
 	if (key->op_type != IS_UNUSED) {
@@ -2121,7 +2121,7 @@ void zend_do_foreach_cont(znode *value, znode *key, znode *as_token CLS_DC)
 	result_value = opline->result;
 
 	if (key->op_type != IS_UNUSED) {
-		opline = get_next_op(CG(active_op_array) CLS_CC);
+		opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 		opline->opcode = ZEND_FETCH_DIM_TMP_VAR;
 		opline->result.op_type = IS_VAR;
 		opline->result.u.EA.type = 0;
@@ -2134,22 +2134,22 @@ void zend_do_foreach_cont(znode *value, znode *key, znode *as_token CLS_DC)
 		result_key = opline->result;
 	}
 
-	zend_do_assign(&dummy, value, &result_value CLS_CC);
+	zend_do_assign(&dummy, value, &result_value TSRMLS_CC);
 	CG(active_op_array)->opcodes[CG(active_op_array)->last-1].result.u.EA.type |= EXT_TYPE_UNUSED;
 	if (key->op_type != IS_UNUSED) {
-		zend_do_assign(&dummy, key, &result_key CLS_CC);
+		zend_do_assign(&dummy, key, &result_key TSRMLS_CC);
 		CG(active_op_array)->opcodes[CG(active_op_array)->last-1].result.u.EA.type |= EXT_TYPE_UNUSED;	
 	}
-	zend_do_free(as_token CLS_CC);
+	zend_do_free(as_token TSRMLS_CC);
 
-	do_begin_loop(CLS_C);
+	do_begin_loop(TSRMLS_C);
 	INC_BPC(CG(active_op_array));
 }
 
 
-void zend_do_foreach_end(znode *foreach_token, znode *open_brackets_token CLS_DC)
+void zend_do_foreach_end(znode *foreach_token, znode *open_brackets_token TSRMLS_DC)
 {
-	zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	opline->opcode = ZEND_JMP;
 	opline->op1.u.opline_num = foreach_token->u.opline_num;
@@ -2158,9 +2158,9 @@ void zend_do_foreach_end(znode *foreach_token, znode *open_brackets_token CLS_DC
 
 	CG(active_op_array)->opcodes[foreach_token->u.opline_num].op2.u.opline_num = get_next_op_number(CG(active_op_array));
 
-	do_end_loop(foreach_token->u.opline_num CLS_CC);
+	do_end_loop(foreach_token->u.opline_num TSRMLS_CC);
 
-	generate_free_foreach_copy(open_brackets_token CLS_CC);
+	generate_free_foreach_copy(open_brackets_token TSRMLS_CC);
 
 	zend_stack_del_top(&CG(foreach_copy_stack));
 
@@ -2168,13 +2168,13 @@ void zend_do_foreach_end(znode *foreach_token, znode *open_brackets_token CLS_DC
 }
 
 
-void zend_do_declare_begin(CLS_D)
+void zend_do_declare_begin(TSRMLS_D)
 {
 	zend_stack_push(&CG(declare_stack), &CG(declarables), sizeof(zend_declarables));
 }
 
 
-void zend_do_declare_stmt(znode *var, znode *val CLS_DC)
+void zend_do_declare_stmt(znode *var, znode *val TSRMLS_DC)
 {
 	convert_to_string(&var->u.constant);
 
@@ -2186,7 +2186,7 @@ void zend_do_declare_stmt(znode *var, znode *val CLS_DC)
 }
 
 
-void zend_do_declare_end(CLS_D)
+void zend_do_declare_end(TSRMLS_D)
 {
 	zend_declarables *declarables;
 
@@ -2195,7 +2195,7 @@ void zend_do_declare_end(CLS_D)
 }
 
 
-void zend_do_end_heredoc(CLS_D)
+void zend_do_end_heredoc(TSRMLS_D)
 {
 	int opline_num = get_next_op_number(CG(active_op_array))-1;
 	zend_op *opline = &CG(active_op_array)->opcodes[opline_num];
@@ -2213,9 +2213,9 @@ void zend_do_end_heredoc(CLS_D)
 }
 
 
-void zend_do_exit(znode *result, znode *message CLS_DC)
+void zend_do_exit(znode *result, znode *message TSRMLS_DC)
 {
-	zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	opline->opcode = ZEND_EXIT;
 	opline->op1 = *message;
@@ -2227,9 +2227,9 @@ void zend_do_exit(znode *result, znode *message CLS_DC)
 }
 
 
-void zend_do_begin_silence(znode *strudel_token CLS_DC)
+void zend_do_begin_silence(znode *strudel_token TSRMLS_DC)
 {
-	zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	opline->opcode = ZEND_BEGIN_SILENCE;
 	opline->result.op_type = IS_TMP_VAR;
@@ -2240,9 +2240,9 @@ void zend_do_begin_silence(znode *strudel_token CLS_DC)
 }
 
 
-void zend_do_end_silence(znode *strudel_token CLS_DC)
+void zend_do_end_silence(znode *strudel_token TSRMLS_DC)
 {
-	zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	opline->opcode = ZEND_END_SILENCE;
 	opline->op1 = *strudel_token;
@@ -2250,12 +2250,12 @@ void zend_do_end_silence(znode *strudel_token CLS_DC)
 }
 
 
-void zend_do_begin_qm_op(znode *cond, znode *qm_token CLS_DC)
+void zend_do_begin_qm_op(znode *cond, znode *qm_token TSRMLS_DC)
 {
 	int jmpz_op_number = get_next_op_number(CG(active_op_array));
 	zend_op *opline;
 	
-	opline = get_next_op(CG(active_op_array) CLS_CC);
+	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	opline->opcode = ZEND_JMPZ;
 	opline->op1 = *cond;
@@ -2267,9 +2267,9 @@ void zend_do_begin_qm_op(znode *cond, znode *qm_token CLS_DC)
 }
 
 
-void zend_do_qm_true(znode *true_value, znode *qm_token, znode *colon_token CLS_DC)
+void zend_do_qm_true(znode *true_value, znode *qm_token, znode *colon_token TSRMLS_DC)
 {
-	zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	CG(active_op_array)->opcodes[qm_token->u.opline_num].op2.u.opline_num = get_next_op_number(CG(active_op_array))+1; /* jmp over the ZEND_JMP */
 
@@ -2282,16 +2282,16 @@ void zend_do_qm_true(znode *true_value, znode *qm_token, znode *colon_token CLS_
 	*qm_token = opline->result;
 	colon_token->u.opline_num = get_next_op_number(CG(active_op_array));
 
-	opline = get_next_op(CG(active_op_array) CLS_CC);
+	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 	opline->opcode = ZEND_JMP;
 	SET_UNUSED(opline->op1);
 	SET_UNUSED(opline->op2);
 }
 
 
-void zend_do_qm_false(znode *result, znode *false_value, znode *qm_token, znode *colon_token CLS_DC)
+void zend_do_qm_false(znode *result, znode *false_value, znode *qm_token, znode *colon_token TSRMLS_DC)
 {
-	zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	opline->opcode = ZEND_QM_ASSIGN;
 	opline->result = *qm_token;
@@ -2306,7 +2306,7 @@ void zend_do_qm_false(znode *result, znode *false_value, znode *qm_token, znode
 }
 
 
-void zend_do_extended_info(CLS_D)
+void zend_do_extended_info(TSRMLS_D)
 {
 	zend_op *opline;
 	
@@ -2314,7 +2314,7 @@ void zend_do_extended_info(CLS_D)
 		return;
 	}
 	
-	opline = get_next_op(CG(active_op_array) CLS_CC);
+	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	opline->opcode = ZEND_EXT_STMT;
 	SET_UNUSED(opline->op1);
@@ -2322,7 +2322,7 @@ void zend_do_extended_info(CLS_D)
 }
 
 
-void zend_do_extended_fcall_begin(CLS_D)
+void zend_do_extended_fcall_begin(TSRMLS_D)
 {
 	zend_op *opline;
 	
@@ -2330,7 +2330,7 @@ void zend_do_extended_fcall_begin(CLS_D)
 		return;
 	}
 	
-	opline = get_next_op(CG(active_op_array) CLS_CC);
+	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	opline->opcode = ZEND_EXT_FCALL_BEGIN;
 	SET_UNUSED(opline->op1);
@@ -2338,7 +2338,7 @@ void zend_do_extended_fcall_begin(CLS_D)
 }
 
 
-void zend_do_extended_fcall_end(CLS_D)
+void zend_do_extended_fcall_end(TSRMLS_D)
 {
 	zend_op *opline;
 	
@@ -2346,17 +2346,17 @@ void zend_do_extended_fcall_end(CLS_D)
 		return;
 	}
 	
-	opline = get_next_op(CG(active_op_array) CLS_CC);
+	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	opline->opcode = ZEND_EXT_FCALL_END;
 	SET_UNUSED(opline->op1);
 	SET_UNUSED(opline->op2);
 }
 
-void zend_do_ticks(CLS_D)
+void zend_do_ticks(TSRMLS_D)
 {
 	if (CG(declarables).ticks.value.lval) {
-		zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
+		zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 		opline->opcode = ZEND_TICKS;
 		opline->op1.u.constant = CG(declarables).ticks;
@@ -2366,17 +2366,17 @@ void zend_do_ticks(CLS_D)
 }
 
 
-int zendlex(znode *zendlval CLS_DC)
+int zendlex(znode *zendlval TSRMLS_DC)
 {
 	int retval;
 
 	zendlval->u.constant.type = IS_LONG;
-	retval = lex_scan(&zendlval->u.constant CLS_CC);
+	retval = lex_scan(&zendlval->u.constant TSRMLS_CC);
 	switch(retval) {
 		case T_COMMENT:
 		case T_OPEN_TAG:
 		case T_WHITESPACE:
-			retval = zendlex(zendlval CLS_CC);
+			retval = zendlex(zendlval TSRMLS_CC);
 			break;
 		case T_CLOSE_TAG:
 			retval = ';'; /* implicit ; */
diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h
index 976b8d152d..b9d14b3c62 100644
--- a/Zend/zend_compile.h
+++ b/Zend/zend_compile.h
@@ -42,7 +42,7 @@
 
 #define INC_BPC(op_array)	if (CG(interactive)) { ((op_array)->backpatch_count++); }
 #define DEC_BPC(op_array)	if (CG(interactive)) { ((op_array)->backpatch_count--); }
-#define HANDLE_INTERACTIVE()  if (CG(interactive)) { execute_new_code(CLS_C); }
+#define HANDLE_INTERACTIVE()  if (CG(interactive)) { execute_new_code(TSRMLS_C); }
 
 typedef struct _zend_op_array zend_op_array;
 
@@ -196,166 +196,166 @@ typedef struct _zend_file_handle {
 
 BEGIN_EXTERN_C()
 
-void init_compiler(CLS_D TSRMLS_DC);
-void shutdown_compiler(CLS_D);
-void zend_init_compiler_data_structures(CLS_D);
+void init_compiler(TSRMLS_D);
+void shutdown_compiler(TSRMLS_D);
+void zend_init_compiler_data_structures(TSRMLS_D);
 
-extern ZEND_API zend_op_array *(*zend_compile_file)(zend_file_handle *file_handle, int type CLS_DC);
+extern ZEND_API zend_op_array *(*zend_compile_file)(zend_file_handle *file_handle, int type TSRMLS_DC);
 
-void zend_activate(CLS_D TSRMLS_DC);
-void zend_deactivate(CLS_D TSRMLS_DC);
+void zend_activate(TSRMLS_D);
+void zend_deactivate(TSRMLS_D);
 void zend_activate_modules(void);
 void zend_deactivate_modules(void);
 
 
-int lex_scan(zval *zendlval CLS_DC);
-void startup_scanner(CLS_D);
-void shutdown_scanner(CLS_D);
+int lex_scan(zval *zendlval TSRMLS_DC);
+void startup_scanner(TSRMLS_D);
+void shutdown_scanner(TSRMLS_D);
 
 ZEND_API char *zend_set_compiled_filename(char *new_compiled_filename);
 ZEND_API void zend_restore_compiled_filename(char *original_compiled_filename);
-ZEND_API char *zend_get_compiled_filename(CLS_D);
-ZEND_API int zend_get_compiled_lineno(CLS_D);
+ZEND_API char *zend_get_compiled_filename(TSRMLS_D);
+ZEND_API int zend_get_compiled_lineno(TSRMLS_D);
 
 #ifdef ZTS
-const char *zend_get_zendtext(CLS_D);
-int zend_get_zendleng(CLS_D);
+const char *zend_get_zendtext(TSRMLS_D);
+int zend_get_zendleng(TSRMLS_D);
 #endif
 
 
 /* parser-driven code generators */
-void zend_do_binary_op(int op, znode *result, znode *op1, znode *op2 CLS_DC);
-void zend_do_unary_op(int op, znode *result, znode *op1 CLS_DC);
-void zend_do_binary_assign_op(int op, znode *result, znode *op1, znode *op2 CLS_DC);
-void zend_do_assign(znode *result, znode *variable, znode *value CLS_DC);
-void zend_do_assign_ref(znode *result, znode *lvar, znode *rvar CLS_DC);
-void fetch_simple_variable(znode *result, znode *varname, int bp CLS_DC);
-void fetch_simple_variable_ex(znode *result, znode *varname, int bp, int op CLS_DC);
-void zend_do_indirect_references(znode *result, znode *num_references, znode *variable CLS_DC);
-void zend_do_fetch_global_or_static_variable(znode *varname, znode *static_assignment, int fetch_type CLS_DC);
-void zend_do_fetch_globals(znode *varname CLS_DC);
-
-void fetch_array_begin(znode *result, znode *varname, znode *first_dim CLS_DC);
-void fetch_array_dim(znode *result, znode *parent, znode *dim CLS_DC);
-void fetch_string_offset(znode *result, znode *parent, znode *offset CLS_DC);
-void zend_do_print(znode *result, znode *arg CLS_DC);
-void zend_do_echo(znode *arg CLS_DC);
+void zend_do_binary_op(int op, znode *result, znode *op1, znode *op2 TSRMLS_DC);
+void zend_do_unary_op(int op, znode *result, znode *op1 TSRMLS_DC);
+void zend_do_binary_assign_op(int op, znode *result, znode *op1, znode *op2 TSRMLS_DC);
+void zend_do_assign(znode *result, znode *variable, znode *value TSRMLS_DC);
+void zend_do_assign_ref(znode *result, znode *lvar, znode *rvar TSRMLS_DC);
+void fetch_simple_variable(znode *result, znode *varname, int bp TSRMLS_DC);
+void fetch_simple_variable_ex(znode *result, znode *varname, int bp, int op TSRMLS_DC);
+void zend_do_indirect_references(znode *result, znode *num_references, znode *variable TSRMLS_DC);
+void zend_do_fetch_global_or_static_variable(znode *varname, znode *static_assignment, int fetch_type TSRMLS_DC);
+void zend_do_fetch_globals(znode *varname TSRMLS_DC);
+
+void fetch_array_begin(znode *result, znode *varname, znode *first_dim TSRMLS_DC);
+void fetch_array_dim(znode *result, znode *parent, znode *dim TSRMLS_DC);
+void fetch_string_offset(znode *result, znode *parent, znode *offset TSRMLS_DC);
+void zend_do_print(znode *result, znode *arg TSRMLS_DC);
+void zend_do_echo(znode *arg TSRMLS_DC);
 typedef int (*unary_op_type)(zval *, zval *);
 ZEND_API unary_op_type get_unary_op(int opcode);
 ZEND_API void *get_binary_op(int opcode);
 
-void zend_do_while_cond(znode *expr, znode *close_bracket_token CLS_DC);
-void zend_do_while_end(znode *while_token, znode *close_bracket_token CLS_DC);
-void zend_do_do_while_begin(CLS_D);
-void zend_do_do_while_end(znode *do_token, znode *expr_open_bracket, znode *expr CLS_DC);
+void zend_do_while_cond(znode *expr, znode *close_bracket_token TSRMLS_DC);
+void zend_do_while_end(znode *while_token, znode *close_bracket_token TSRMLS_DC);
+void zend_do_do_while_begin(TSRMLS_D);
+void zend_do_do_while_end(znode *do_token, znode *expr_open_bracket, znode *expr TSRMLS_DC);
 
 
-void zend_do_if_cond(znode *cond, znode *closing_bracket_token CLS_DC);
-void zend_do_if_after_statement(znode *closing_bracket_token, unsigned char initialize CLS_DC);
-void zend_do_if_end(CLS_D);
+void zend_do_if_cond(znode *cond, znode *closing_bracket_token TSRMLS_DC);
+void zend_do_if_after_statement(znode *closing_bracket_token, unsigned char initialize TSRMLS_DC);
+void zend_do_if_end(TSRMLS_D);
 
-void zend_do_for_cond(znode *expr, znode *second_semicolon_token CLS_DC);
-void zend_do_for_before_statement(znode *cond_start, znode *second_semicolon_token CLS_DC);
-void zend_do_for_end(znode *second_semicolon_token CLS_DC);
+void zend_do_for_cond(znode *expr, znode *second_semicolon_token TSRMLS_DC);
+void zend_do_for_before_statement(znode *cond_start, znode *second_semicolon_token TSRMLS_DC);
+void zend_do_for_end(znode *second_semicolon_token TSRMLS_DC);
 
-void zend_do_pre_incdec(znode *result, znode *op1, int op CLS_DC);
-void zend_do_post_incdec(znode *result, znode *op1, int op CLS_DC);
+void zend_do_pre_incdec(znode *result, znode *op1, int op TSRMLS_DC);
+void zend_do_post_incdec(znode *result, znode *op1, int op TSRMLS_DC);
 
-void zend_do_begin_variable_parse(CLS_D);
-void zend_do_end_variable_parse(int type, int arg_offset CLS_DC);
+void zend_do_begin_variable_parse(TSRMLS_D);
+void zend_do_end_variable_parse(int type, int arg_offset TSRMLS_DC);
 
-void zend_do_free(znode *op1 CLS_DC);
+void zend_do_free(znode *op1 TSRMLS_DC);
 
-void zend_do_init_string(znode *result CLS_DC);
-void zend_do_add_char(znode *result, znode *op1, znode *op2 CLS_DC);
-void zend_do_add_string(znode *result, znode *op1, znode *op2 CLS_DC);
-void zend_do_add_variable(znode *result, znode *op1, znode *op2 CLS_DC);
+void zend_do_init_string(znode *result TSRMLS_DC);
+void zend_do_add_char(znode *result, znode *op1, znode *op2 TSRMLS_DC);
+void zend_do_add_string(znode *result, znode *op1, znode *op2 TSRMLS_DC);
+void zend_do_add_variable(znode *result, znode *op1, znode *op2 TSRMLS_DC);
 
-void zend_do_begin_function_declaration(znode *function_token, znode *function_name, int is_method, int return_reference CLS_DC);
-void zend_do_end_function_declaration(znode *function_token CLS_DC);
-void zend_do_receive_arg(int op, znode *var, znode *offset, znode *initialization, unsigned char pass_type CLS_DC);
-int zend_do_begin_function_call(znode *function_name CLS_DC);
-void zend_do_begin_dynamic_function_call(znode *function_name CLS_DC);
-void zend_do_begin_class_member_function_call(znode *class_name, znode *function_name CLS_DC);
-void zend_do_end_function_call(znode *function_name, znode *result, znode *argument_list, int is_method, int is_dynamic_fcall CLS_DC);
-void zend_do_return(znode *expr, int do_end_vparse CLS_DC);
+void zend_do_begin_function_declaration(znode *function_token, znode *function_name, int is_method, int return_reference TSRMLS_DC);
+void zend_do_end_function_declaration(znode *function_token TSRMLS_DC);
+void zend_do_receive_arg(int op, znode *var, znode *offset, znode *initialization, unsigned char pass_type TSRMLS_DC);
+int zend_do_begin_function_call(znode *function_name TSRMLS_DC);
+void zend_do_begin_dynamic_function_call(znode *function_name TSRMLS_DC);
+void zend_do_begin_class_member_function_call(znode *class_name, znode *function_name TSRMLS_DC);
+void zend_do_end_function_call(znode *function_name, znode *result, znode *argument_list, int is_method, int is_dynamic_fcall TSRMLS_DC);
+void zend_do_return(znode *expr, int do_end_vparse TSRMLS_DC);
 ZEND_API int do_bind_function_or_class(zend_op *opline, HashTable *function_table, HashTable *class_table, int compile_time);
 void zend_do_inheritance(zend_class_entry *ce, zend_class_entry *parent_ce);
-void zend_do_early_binding(CLS_D);
+void zend_do_early_binding(TSRMLS_D);
 
-void zend_do_pass_param(znode *param, int op, int offset CLS_DC);
+void zend_do_pass_param(znode *param, int op, int offset TSRMLS_DC);
 
 
-void zend_do_boolean_or_begin(znode *expr1, znode *op_token CLS_DC);
-void zend_do_boolean_or_end(znode *result, znode *expr1, znode *expr2, znode *op_token CLS_DC);
-void zend_do_boolean_and_begin(znode *expr1, znode *op_token CLS_DC);               
-void zend_do_boolean_and_end(znode *result, znode *expr1, znode *expr2, znode *op_token CLS_DC);
+void zend_do_boolean_or_begin(znode *expr1, znode *op_token TSRMLS_DC);
+void zend_do_boolean_or_end(znode *result, znode *expr1, znode *expr2, znode *op_token TSRMLS_DC);
+void zend_do_boolean_and_begin(znode *expr1, znode *op_token TSRMLS_DC);               
+void zend_do_boolean_and_end(znode *result, znode *expr1, znode *expr2, znode *op_token TSRMLS_DC);
 
-void zend_do_brk_cont(int op, znode *expr CLS_DC);
+void zend_do_brk_cont(int op, znode *expr TSRMLS_DC);
 
-void zend_do_switch_cond(znode *cond CLS_DC);
-void zend_do_switch_end(znode *case_list CLS_DC);
-void zend_do_case_before_statement(znode *case_list, znode *case_token, znode *case_expr CLS_DC);
-void zend_do_case_after_statement(znode *result, znode *case_token CLS_DC);
-void zend_do_default_before_statement(znode *case_list, znode *default_token CLS_DC);
+void zend_do_switch_cond(znode *cond TSRMLS_DC);
+void zend_do_switch_end(znode *case_list TSRMLS_DC);
+void zend_do_case_before_statement(znode *case_list, znode *case_token, znode *case_expr TSRMLS_DC);
+void zend_do_case_after_statement(znode *result, znode *case_token TSRMLS_DC);
+void zend_do_default_before_statement(znode *case_list, znode *default_token TSRMLS_DC);
 
-void zend_do_begin_class_declaration(znode *class_name, znode *parent_class_name CLS_DC);
-void zend_do_end_class_declaration(CLS_D);
-void zend_do_declare_property(znode *var_name, znode *value CLS_DC);
+void zend_do_begin_class_declaration(znode *class_name, znode *parent_class_name TSRMLS_DC);
+void zend_do_end_class_declaration(TSRMLS_D);
+void zend_do_declare_property(znode *var_name, znode *value TSRMLS_DC);
 
-void zend_do_fetch_property(znode *result, znode *object, znode *property CLS_DC);
+void zend_do_fetch_property(znode *result, znode *object, znode *property TSRMLS_DC);
 
 
-void zend_do_push_object(znode *object CLS_DC);
-void zend_do_pop_object(znode *object CLS_DC);
+void zend_do_push_object(znode *object TSRMLS_DC);
+void zend_do_pop_object(znode *object TSRMLS_DC);
 
 
-void zend_do_begin_new_object(znode *new_token, znode *class_name CLS_DC);
-void zend_do_end_new_object(znode *result, znode *class_name, znode *new_token, znode *argument_list CLS_DC);
+void zend_do_begin_new_object(znode *new_token, znode *class_name TSRMLS_DC);
+void zend_do_end_new_object(znode *result, znode *class_name, znode *new_token, znode *argument_list TSRMLS_DC);
 
-void zend_do_fetch_constant(znode *result, znode *constant_name, int mode CLS_DC);
+void zend_do_fetch_constant(znode *result, znode *constant_name, int mode TSRMLS_DC);
 
-void zend_do_shell_exec(znode *result, znode *cmd CLS_DC);
+void zend_do_shell_exec(znode *result, znode *cmd TSRMLS_DC);
 
-void zend_do_init_array(znode *result, znode *expr, znode *offset, int is_ref CLS_DC);
-void zend_do_add_array_element(znode *result, znode *expr, znode *offset, int is_ref CLS_DC);
+void zend_do_init_array(znode *result, znode *expr, znode *offset, int is_ref TSRMLS_DC);
+void zend_do_add_array_element(znode *result, znode *expr, znode *offset, int is_ref TSRMLS_DC);
 void zend_do_add_static_array_element(znode *result, znode *offset, znode *expr);
-void zend_do_list_init(CLS_D);
-void zend_do_list_end(znode *result, znode *expr CLS_DC);
-void zend_do_add_list_element(znode *element CLS_DC);
-void zend_do_new_list_begin(CLS_D);
-void zend_do_new_list_end(CLS_D);
+void zend_do_list_init(TSRMLS_D);
+void zend_do_list_end(znode *result, znode *expr TSRMLS_DC);
+void zend_do_add_list_element(znode *element TSRMLS_DC);
+void zend_do_new_list_begin(TSRMLS_D);
+void zend_do_new_list_end(TSRMLS_D);
 
-void zend_do_cast(znode *result, znode *expr, int type CLS_DC);
-void zend_do_include_or_eval(int type, znode *result, znode *op1 CLS_DC);
+void zend_do_cast(znode *result, znode *expr, int type TSRMLS_DC);
+void zend_do_include_or_eval(int type, znode *result, znode *op1 TSRMLS_DC);
 
-void zend_do_unset(znode *variable CLS_DC);
-void zend_do_isset_or_isempty(int type, znode *result, znode *variable CLS_DC);
+void zend_do_unset(znode *variable TSRMLS_DC);
+void zend_do_isset_or_isempty(int type, znode *result, znode *variable TSRMLS_DC);
 
-void zend_do_foreach_begin(znode *foreach_token, znode *array, znode *open_brackets_token, znode *as_token, int variable CLS_DC);
-void zend_do_foreach_cont(znode *value, znode *key, znode *as_token CLS_DC);
-void zend_do_foreach_end(znode *foreach_token, znode *open_brackets_token CLS_DC);
+void zend_do_foreach_begin(znode *foreach_token, znode *array, znode *open_brackets_token, znode *as_token, int variable TSRMLS_DC);
+void zend_do_foreach_cont(znode *value, znode *key, znode *as_token TSRMLS_DC);
+void zend_do_foreach_end(znode *foreach_token, znode *open_brackets_token TSRMLS_DC);
 
-void zend_do_declare_begin(CLS_D);
-void zend_do_declare_stmt(znode *var, znode *val CLS_DC);
-void zend_do_declare_end(CLS_D);
+void zend_do_declare_begin(TSRMLS_D);
+void zend_do_declare_stmt(znode *var, znode *val TSRMLS_DC);
+void zend_do_declare_end(TSRMLS_D);
 
-void zend_do_end_heredoc(CLS_D);
+void zend_do_end_heredoc(TSRMLS_D);
 
-void zend_do_exit(znode *result, znode *message CLS_DC);
+void zend_do_exit(znode *result, znode *message TSRMLS_DC);
 
-void zend_do_begin_silence(znode *strudel_token CLS_DC);
-void zend_do_end_silence(znode *strudel_token CLS_DC);
+void zend_do_begin_silence(znode *strudel_token TSRMLS_DC);
+void zend_do_end_silence(znode *strudel_token TSRMLS_DC);
 
-void zend_do_begin_qm_op(znode *cond, znode *qm_token CLS_DC);
-void zend_do_qm_true(znode *true_value, znode *qm_token, znode *colon_token CLS_DC);
-void zend_do_qm_false(znode *result, znode *false_value, znode *qm_token, znode *colon_token CLS_DC);
+void zend_do_begin_qm_op(znode *cond, znode *qm_token TSRMLS_DC);
+void zend_do_qm_true(znode *true_value, znode *qm_token, znode *colon_token TSRMLS_DC);
+void zend_do_qm_false(znode *result, znode *false_value, znode *qm_token, znode *colon_token TSRMLS_DC);
 
-void zend_do_extended_info(CLS_D);
-void zend_do_extended_fcall_begin(CLS_D);
-void zend_do_extended_fcall_end(CLS_D);
+void zend_do_extended_info(TSRMLS_D);
+void zend_do_extended_fcall_begin(TSRMLS_D);
+void zend_do_extended_fcall_end(TSRMLS_D);
 
-void zend_do_ticks(CLS_D);
+void zend_do_ticks(TSRMLS_D);
 
 ZEND_API void function_add_ref(zend_function *function);
 
@@ -363,14 +363,14 @@ ZEND_API void function_add_ref(zend_function *function);
 
 
 /* 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 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 zend_op_array *compile_file(zend_file_handle *file_handle, int type TSRMLS_DC);
+ZEND_API zend_op_array *compile_string(zval *source_string, char *filename TSRMLS_DC);	
+ZEND_API zend_op_array *compile_filename(int type, zval *filename TSRMLS_DC);
+ZEND_API int zend_execute_scripts(int type TSRMLS_DC, int file_count, ...);
+ZEND_API int open_file_for_scanning(zend_file_handle *file_handle TSRMLS_DC);
+ZEND_API void init_op_array(zend_op_array *op_array, int type, int initial_ops_size TSRMLS_DC);
 ZEND_API void destroy_op_array(zend_op_array *op_array);
-ZEND_API void zend_destroy_file_handle(zend_file_handle *file_handle CLS_DC);
+ZEND_API void zend_destroy_file_handle(zend_file_handle *file_handle TSRMLS_DC);
 ZEND_API void zend_file_handle_dtor(zend_file_handle *fh);
 
 ZEND_API void destroy_zend_function(zend_function *function);
@@ -380,8 +380,8 @@ void zend_class_add_ref(zend_class_entry *ce);
 #define ZEND_FUNCTION_DTOR (void (*)(void *)) destroy_zend_function
 #define ZEND_CLASS_DTOR (void (*)(void *)) destroy_zend_class
 
-zend_op *get_next_op(zend_op_array *op_array CLS_DC);
-void init_op(zend_op *op CLS_DC);
+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);
 void print_op_array(zend_op_array *op_array, int optimizations);
@@ -390,7 +390,7 @@ zend_brk_cont_element *get_next_brk_cont_element(zend_op_array *op_array);
 ZEND_API zend_bool zend_is_compiling(void);
 ZEND_API char *zend_make_compiled_string_description(char *name);
 
-int zendlex(znode *zendlval CLS_DC);
+int zendlex(znode *zendlval TSRMLS_DC);
 
 #define ZEND_NOP					0
 									
diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c
index 3a0ada3dcc..0f1b31d1a2 100644
--- a/Zend/zend_execute.c
+++ b/Zend/zend_execute.c
@@ -2036,7 +2036,7 @@ send_by_ref:
 					int return_value_used;
 					zval *inc_filename = get_zval_ptr(&opline->op1, Ts, &EG(free_op1), BP_VAR_R);
 					zval tmp_inc_filename;
-					CLS_FETCH();
+					TSRMLS_FETCH();
 
 					if (inc_filename->type!=IS_STRING) {
 						tmp_inc_filename = *inc_filename;
@@ -2062,8 +2062,8 @@ send_by_ref:
 
 								if (file_handle.handle.fp) {
 									if (!opened_path || zend_hash_add(&EG(included_files), opened_path, strlen(opened_path)+1, (void *)&dummy, sizeof(int), NULL)==SUCCESS) {
-										new_op_array = zend_compile_file(&file_handle, (opline->op2.u.constant.value.lval==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE) CLS_CC);
-										zend_destroy_file_handle(&file_handle CLS_CC);
+										new_op_array = zend_compile_file(&file_handle, (opline->op2.u.constant.value.lval==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE) TSRMLS_CC);
+										zend_destroy_file_handle(&file_handle TSRMLS_CC);
 										opened_path = NULL; /* zend_destroy_file_handle() already frees it */
 									} else {
 										fclose(file_handle.handle.fp);
@@ -2083,12 +2083,12 @@ send_by_ref:
 							break;
 						case ZEND_INCLUDE:
 						case ZEND_REQUIRE:
-							new_op_array = compile_filename(opline->op2.u.constant.value.lval, inc_filename CLS_CC TSRMLS_CC);
+							new_op_array = compile_filename(opline->op2.u.constant.value.lval, inc_filename TSRMLS_CC);
 							break;
 						case ZEND_EVAL: {
 								char *eval_desc = zend_make_compiled_string_description("eval()'d code");
 
-								new_op_array = compile_string(inc_filename, eval_desc CLS_CC);
+								new_op_array = compile_string(inc_filename, eval_desc TSRMLS_CC);
 								efree(eval_desc);
 							}
 							break;
diff --git a/Zend/zend_execute.h b/Zend/zend_execute.h
index 19fcdeec36..5aebab318f 100644
--- a/Zend/zend_execute.h
+++ b/Zend/zend_execute.h
@@ -49,7 +49,7 @@ typedef union _temp_variable {
 
 ZEND_API extern void (*zend_execute)(zend_op_array *op_array TSRMLS_DC);
 
-void init_executor(CLS_D TSRMLS_DC);
+void init_executor(TSRMLS_D);
 void shutdown_executor(TSRMLS_D);
 ZEND_API void execute(zend_op_array *op_array TSRMLS_DC);
 ZEND_API int zend_is_true(zval *op);
@@ -62,7 +62,7 @@ static inline void safe_free_zval_ptr(zval *p)
 	}
 }
 
-ZEND_API int zend_eval_string(char *str, zval *retval_ptr, char *string_name CLS_DC TSRMLS_DC);
+ZEND_API int zend_eval_string(char *str, zval *retval_ptr, char *string_name TSRMLS_DC);
 static inline int i_zend_is_true(zval *op)
 {
 	int result;
@@ -127,7 +127,7 @@ static inline int zend_ptr_stack_get_arg(int requested_arg, void **data TSRMLS_D
 	return SUCCESS;
 }
 
-void execute_new_code(CLS_D);
+void execute_new_code(TSRMLS_D);
 
 
 /* services */
diff --git a/Zend/zend_execute_API.c b/Zend/zend_execute_API.c
index 8e9f0a44c0..42137cff0c 100644
--- a/Zend/zend_execute_API.c
+++ b/Zend/zend_execute_API.c
@@ -102,7 +102,7 @@ static int is_not_internal_class(zend_class_entry *ce)
 }
 
 
-void init_executor(CLS_D TSRMLS_DC)
+void init_executor(TSRMLS_D)
 {
 	INIT_ZVAL(EG(uninitialized_zval));
 	INIT_ZVAL(EG(error_zval));
@@ -529,7 +529,7 @@ int call_user_function_ex(HashTable *function_table, zval **object_pp, zval *fun
 }
 
 
-ZEND_API int zend_eval_string(char *str, zval *retval_ptr, char *string_name CLS_DC TSRMLS_DC)
+ZEND_API int zend_eval_string(char *str, zval *retval_ptr, char *string_name TSRMLS_DC)
 {
 	zval pv;
 	zend_op_array *new_op_array;
@@ -554,7 +554,7 @@ ZEND_API int zend_eval_string(char *str, zval *retval_ptr, char *string_name CLS
 
 	original_handle_op_arrays = CG(handle_op_arrays);
 	CG(handle_op_arrays) = 0;
-	new_op_array = compile_string(&pv, string_name CLS_CC);
+	new_op_array = compile_string(&pv, string_name TSRMLS_CC);
 	CG(handle_op_arrays) = original_handle_op_arrays;
 
 	if (new_op_array) {
@@ -596,11 +596,10 @@ ZEND_API int zend_eval_string(char *str, zval *retval_ptr, char *string_name CLS
 }
 
 
-void execute_new_code(CLS_D)
+void execute_new_code(TSRMLS_D)
 {
     zend_op *opline, *end;
 	zend_op *ret_opline;
-	TSRMLS_FETCH();
 
 	if (!CG(interactive)
 		|| CG(active_op_array)->backpatch_count>0
@@ -609,7 +608,7 @@ void execute_new_code(CLS_D)
 		return;
 	}
 
-	ret_opline = get_next_op(CG(active_op_array) CLS_CC);
+	ret_opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 	ret_opline->opcode = ZEND_RETURN;
 	ret_opline->op1.op_type = IS_CONST;
 	INIT_ZVAL(ret_opline->op1.u.constant);
@@ -647,8 +646,6 @@ ZEND_API void zend_timeout(int dummy)
 	TSRMLS_FETCH();
 
 	/* is there any point in this?  we're terminating the request anyway...
-	PLS_FETCH();
-
 	PG(connection_status) |= PHP_CONNECTION_TIMEOUT;
 	*/
 	zend_error(E_ERROR, "Maximum execution time of %d second%s exceeded",
@@ -677,16 +674,16 @@ static LRESULT CALLBACK zend_timeout_WndProc(HWND hWnd, UINT message, WPARAM wPa
 			break;
 		case WM_TIMER: {
 #ifdef ZTS
-				zend_executor_globals *executor_globals;
+				void ***tsrm_ls;
 
-				executor_globals = ts_resource_ex(executor_globals_id, &wParam);
-				if (!executor_globals) {
+				tsrm_ls = ts_resource_ex(0, &wParam);
+				if (!tsrm_ls) {
 					/* Thread died before receiving its timeout? */
 					break;
 				}
 #endif
 				KillTimer(timeout_window, wParam);
-				executor_globals->timed_out = 1;
+				EG(timed_out) = 1;
 			}
 			break;
 		default:
diff --git a/Zend/zend_fast_cache.h b/Zend/zend_fast_cache.h
index f3e7a15492..a13b5a185f 100644
--- a/Zend/zend_fast_cache.h
+++ b/Zend/zend_fast_cache.h
@@ -58,7 +58,7 @@ typedef struct _zend_fast_cache_list_entry {
 
 #define ZEND_FAST_ALLOC(p, type, fc_type)								\
 	{																\
-		ALS_FETCH();												\
+		TSRMLS_FETCH();												\
 																	\
 		if (((p) = (type *) AG(fast_cache_list_head)[fc_type])) {	\
 			AG(fast_cache_list_head)[fc_type] = ((zend_fast_cache_list_entry *) AG(fast_cache_list_head)[fc_type])->next;	\
@@ -72,7 +72,7 @@ typedef struct _zend_fast_cache_list_entry {
 
 #define ZEND_FAST_FREE(p, fc_type)										\
 	{																\
-		ALS_FETCH();												\
+		TSRMLS_FETCH();												\
 																	\
 		((zend_fast_cache_list_entry *) (p))->next = (zend_fast_cache_list_entry *) AG(fast_cache_list_head)[fc_type];	\
 		AG(fast_cache_list_head)[fc_type] = (zend_fast_cache_list_entry *) (p);			\
diff --git a/Zend/zend_globals_macros.h b/Zend/zend_globals_macros.h
index fbb4e71995..5ad45d4675 100644
--- a/Zend/zend_globals_macros.h
+++ b/Zend/zend_globals_macros.h
@@ -27,22 +27,12 @@ typedef struct _zend_alloc_globals zend_alloc_globals;
 
 /* Compiler */
 #ifdef ZTS
-# define CLS_D	zend_compiler_globals *compiler_globals
-# define CLS_DC	, CLS_D
-# define CLS_C	compiler_globals
-# define CLS_CC , CLS_C
-# define CG(v) (((zend_compiler_globals *) compiler_globals)->v)
-# define CLS_FETCH()	zend_compiler_globals *compiler_globals = (zend_compiler_globals *) ts_resource(compiler_globals_id)
+# define CG(v) TSRMG(compiler_globals_id, zend_compiler_globals *, v)
 BEGIN_EXTERN_C()
 int zendparse(void *compiler_globals);
 END_EXTERN_C()
 #else
-# define CLS_D	void
-# define CLS_DC
-# define CLS_C
-# define CLS_CC
 # define CG(v) (compiler_globals.v)
-# define CLS_FETCH()
 extern ZEND_API struct _zend_compiler_globals compiler_globals;
 int zendparse(void);
 #endif
@@ -59,19 +49,9 @@ extern ZEND_API zend_executor_globals executor_globals;
 
 /* Memory Manager */
 #ifdef ZTS
-# define ALS_D	zend_alloc_globals *alloc_globals
-# define ALS_DC	, ALS_D
-# define ALS_C	alloc_globals
-# define ALS_CC , ALS_C
-# define AG(v) (((zend_alloc_globals *) alloc_globals)->v)
-# define ALS_FETCH()	zend_alloc_globals *alloc_globals = (zend_alloc_globals *) ts_resource(alloc_globals_id)
+# define AG(v) TSRMG(alloc_globals_id, zend_alloc_globals *, v)
 #else
-# define ALS_D	void
-# define ALS_DC
-# define ALS_C
-# define ALS_CC
 # define AG(v) (alloc_globals.v)
-# define ALS_FETCH()
 extern ZEND_API zend_alloc_globals alloc_globals;
 #endif
 
diff --git a/Zend/zend_highlight.c b/Zend/zend_highlight.c
index 889374a140..dee5a30e0e 100644
--- a/Zend/zend_highlight.c
+++ b/Zend/zend_highlight.c
@@ -29,8 +29,8 @@
 extern char *zendtext;
 extern int zendleng;
 #else
-#define zendtext ((char *) zend_get_zendtext(CLS_C))
-#define zendleng zend_get_zendleng(CLS_C)
+#define zendtext ((char *) zend_get_zendtext(TSRMLS_C))
+#define zendleng zend_get_zendleng(TSRMLS_C)
 #endif
 
 ZEND_API void zend_html_putc(char c)
@@ -88,13 +88,13 @@ ZEND_API void zend_highlight(zend_syntax_highlighter_ini *syntax_highlighter_ini
 	char *last_color = syntax_highlighter_ini->highlight_html;
 	char *next_color;
 	int in_string=0;
-	CLS_FETCH();
+	TSRMLS_FETCH();
 
 	zend_printf("<code>");
 	zend_printf("<font color=\"%s\">\n", last_color);
 	/* highlight stuff coming back from zendlex() */
 	token.type = 0;
-	while ((token_type=lex_scan(&token CLS_CC))) {
+	while ((token_type=lex_scan(&token TSRMLS_CC))) {
 		switch (token_type) {
 			case T_INLINE_HTML:
 				next_color = syntax_highlighter_ini->highlight_html;
@@ -170,7 +170,7 @@ ZEND_API void zend_highlight(zend_syntax_highlighter_ini *syntax_highlighter_ini
 			efree(token.value.str.val);
 			if (has_semicolon) {
 				/* the following semicolon was unput(), ignore it */
-				lex_scan(&token CLS_CC);
+				lex_scan(&token TSRMLS_CC);
 			}
 		}
 		token.type = 0;
diff --git a/Zend/zend_indent.c b/Zend/zend_indent.c
index 32f074db70..ff9d41f0a4 100644
--- a/Zend/zend_indent.c
+++ b/Zend/zend_indent.c
@@ -30,8 +30,8 @@
 extern char *zendtext;
 extern int zendleng;
 #else
-#define zendtext ((char *) zend_get_zendtext(CLS_C))
-#define zendleng zend_get_zendleng(CLS_C)
+#define zendtext ((char *) zend_get_zendtext(TSRMLS_C))
+#define zendleng zend_get_zendleng(TSRMLS_C)
 #endif
 
 
@@ -59,13 +59,13 @@ ZEND_API void zend_indent()
 	int nest_level=0;
 	int emit_whitespace[256];
 	int i;
-	CLS_FETCH();
+	TSRMLS_FETCH();
 
 	memset(emit_whitespace, 0, sizeof(int)*256);
 
 	/* highlight stuff coming back from zendlex() */
 	token.type = 0;
-	while ((token_type=lex_scan(&token CLS_CC))) {
+	while ((token_type=lex_scan(&token TSRMLS_CC))) {
 		switch (token_type) {
 			case T_INLINE_HTML:
 				zend_write(zendtext, zendleng);
diff --git a/Zend/zend_ini_parser.y b/Zend/zend_ini_parser.y
index 4fc7731293..6b4f431e34 100644
--- a/Zend/zend_ini_parser.y
+++ b/Zend/zend_ini_parser.y
@@ -123,7 +123,7 @@ static void ini_error(char *str)
 	char *error_buf;
 	int error_buf_len;
 	char *currently_parsed_filename = zend_ini_scanner_get_filename();
-	CLS_FETCH();
+	TSRMLS_FETCH();
 
 	error_buf_len = 128+strlen(currently_parsed_filename); /* should be more than enough */
 	error_buf = (char *) emalloc(error_buf_len);
@@ -147,7 +147,7 @@ int zend_parse_ini_file(zend_file_handle *fh, zend_bool unbuffered_errors, zend_
 {
 	zend_ini_parser_param ini_parser_param;
 	int retval;
-	CLS_FETCH();
+	TSRMLS_FETCH();
 
 	ini_parser_param.ini_parser_cb = ini_parser_cb;
 	ini_parser_param.arg = arg;
diff --git a/Zend/zend_ini_scanner.l b/Zend/zend_ini_scanner.l
index d78a146dfe..fd04482367 100644
--- a/Zend/zend_ini_scanner.l
+++ b/Zend/zend_ini_scanner.l
@@ -72,21 +72,21 @@ char *zend_ini_scanner_get_filename()
 
 int zend_ini_scanner_get_lineno()
 {
-	CLS_FETCH();
+	TSRMLS_FETCH();
 
 	return CG(ini_scanner)->lineno();
 }
 
 char *zend_ini_scanner_get_filename()
 {
-	CLS_FETCH();
+	TSRMLS_FETCH();
 
 	return CG(ini_scanner)->filename;
 }
 
 int ini_lex(zval *ini_lval)
 {
-	CLS_FETCH();
+	TSRMLS_FETCH();
 
 	return CG(ini_scanner)->lex_scan(ini_lval);
 }
@@ -110,7 +110,7 @@ int yyFlexLexer::yylex()
 int zend_ini_open_file_for_scanning(zend_file_handle *fh)
 {
 	FILE *fp;
-	CLS_FETCH();
+	TSRMLS_FETCH();
 
 	switch (fh->type) {
 		case ZEND_HANDLE_FP:
@@ -152,7 +152,7 @@ void zend_ini_close_file(zend_file_handle *fh)
 			break;
 #ifdef ZTS
 		case ZEND_HANDLE_STDIOSTREAM: {
-				CLS_FETCH();
+				TSRMLS_FETCH();
 				delete CG(ini_scanner);
 			}
 			break;
diff --git a/Zend/zend_language_parser.y b/Zend/zend_language_parser.y
index 1dceae6f04..e3fd1fd782 100644
--- a/Zend/zend_language_parser.y
+++ b/Zend/zend_language_parser.y
@@ -37,8 +37,8 @@
 #define YYERROR_VERBOSE
 #define YYSTYPE znode
 #ifdef ZTS
-# define YYPARSE_PARAM compiler_globals
-# define YYLEX_PARAM compiler_globals
+# define YYPARSE_PARAM tsrm_ls
+# define YYLEX_PARAM tsrm_ls
 #endif
 
 
@@ -138,20 +138,20 @@ start:
 	top_statement_list
 ;
 
-top_statement_list:	
-		top_statement_list  { zend_do_extended_info(CLS_C); } top_statement { TSRMLS_FETCH(); HANDLE_INTERACTIVE(); }
+top_statement_list:
+		top_statement_list  { zend_do_extended_info(TSRMLS_C); } top_statement { TSRMLS_FETCH(); HANDLE_INTERACTIVE(); }
 	|	/* empty */
 ;
 
 
 top_statement:
 		statement
-	|	declaration_statement	{ zend_do_early_binding(CLS_C); }
+	|	declaration_statement	{ zend_do_early_binding(TSRMLS_C); }
 ;
 
 
 inner_statement_list:
-		inner_statement_list  { zend_do_extended_info(CLS_C); } inner_statement { TSRMLS_FETCH(); HANDLE_INTERACTIVE(); }
+		inner_statement_list  { zend_do_extended_info(TSRMLS_C); } inner_statement { TSRMLS_FETCH(); HANDLE_INTERACTIVE(); }
 	|	/* empty */
 ;
 
@@ -163,43 +163,43 @@ inner_statement:
 
 
 statement:
-		unticked_statement { zend_do_ticks(CLS_C); }
+		unticked_statement { zend_do_ticks(TSRMLS_C); }
 ;
 
 
 unticked_statement:
 		'{' inner_statement_list '}'
-	|	T_IF '(' expr ')' { zend_do_if_cond(&$3, &$4 CLS_CC); } statement { zend_do_if_after_statement(&$4, 1 CLS_CC); } elseif_list else_single { zend_do_if_end(CLS_C); }
-	|	T_IF '(' expr ')' ':' { zend_do_if_cond(&$3, &$4 CLS_CC); } inner_statement_list { zend_do_if_after_statement(&$4, 1 CLS_CC); } new_elseif_list new_else_single T_ENDIF ';' { zend_do_if_end(CLS_C); }
-	|	T_WHILE '(' { $1.u.opline_num = get_next_op_number(CG(active_op_array));  } expr  ')' { zend_do_while_cond(&$4, &$5 CLS_CC); } while_statement { zend_do_while_end(&$1, &$5 CLS_CC); }
-	|	T_DO { $1.u.opline_num = get_next_op_number(CG(active_op_array));  zend_do_do_while_begin(CLS_C); } statement T_WHILE '(' { $5.u.opline_num = get_next_op_number(CG(active_op_array)); } expr ')' ';' { zend_do_do_while_end(&$1, &$5, &$7 CLS_CC); }
+	|	T_IF '(' expr ')' { zend_do_if_cond(&$3, &$4 TSRMLS_CC); } statement { zend_do_if_after_statement(&$4, 1 TSRMLS_CC); } elseif_list else_single { zend_do_if_end(TSRMLS_C); }
+	|	T_IF '(' expr ')' ':' { zend_do_if_cond(&$3, &$4 TSRMLS_CC); } inner_statement_list { zend_do_if_after_statement(&$4, 1 TSRMLS_CC); } new_elseif_list new_else_single T_ENDIF ';' { zend_do_if_end(TSRMLS_C); }
+	|	T_WHILE '(' { $1.u.opline_num = get_next_op_number(CG(active_op_array));  } expr  ')' { zend_do_while_cond(&$4, &$5 TSRMLS_CC); } while_statement { zend_do_while_end(&$1, &$5 TSRMLS_CC); }
+	|	T_DO { $1.u.opline_num = get_next_op_number(CG(active_op_array));  zend_do_do_while_begin(TSRMLS_C); } statement T_WHILE '(' { $5.u.opline_num = get_next_op_number(CG(active_op_array)); } expr ')' ';' { zend_do_do_while_end(&$1, &$5, &$7 TSRMLS_CC); }
 	|	T_FOR 
 			'('
 				for_expr
-			';' { zend_do_free(&$3 CLS_CC); $4.u.opline_num = get_next_op_number(CG(active_op_array)); }
+			';' { zend_do_free(&$3 TSRMLS_CC); $4.u.opline_num = get_next_op_number(CG(active_op_array)); }
 				for_expr
-			';' { zend_do_extended_info(CLS_C); zend_do_for_cond(&$6, &$7 CLS_CC); }
+			';' { zend_do_extended_info(TSRMLS_C); zend_do_for_cond(&$6, &$7 TSRMLS_CC); }
 				for_expr
-			')' { zend_do_free(&$9 CLS_CC); zend_do_for_before_statement(&$4, &$7 CLS_CC); }
-			for_statement { zend_do_for_end(&$7 CLS_CC); }
-	|	T_SWITCH '(' expr ')'	{ zend_do_switch_cond(&$3 CLS_CC); } switch_case_list { zend_do_switch_end(&$6 CLS_CC); }
-	|	T_BREAK ';'				{ zend_do_brk_cont(ZEND_BRK, NULL CLS_CC); }
-	|	T_BREAK expr ';'		{ zend_do_brk_cont(ZEND_BRK, &$2 CLS_CC); }
-	|	T_CONTINUE ';'			{ zend_do_brk_cont(ZEND_CONT, NULL CLS_CC); }
-	|	T_CONTINUE expr ';'		{ zend_do_brk_cont(ZEND_CONT, &$2 CLS_CC); }
-	|	T_RETURN ';'						{ zend_do_return(NULL, 0 CLS_CC); }
-	|	T_RETURN expr_without_variable ';'	{ zend_do_return(&$2, 0 CLS_CC); }
-	|	T_RETURN cvar ';'					{ zend_do_return(&$2, 1 CLS_CC); }
+			')' { zend_do_free(&$9 TSRMLS_CC); zend_do_for_before_statement(&$4, &$7 TSRMLS_CC); }
+			for_statement { zend_do_for_end(&$7 TSRMLS_CC); }
+	|	T_SWITCH '(' expr ')'	{ zend_do_switch_cond(&$3 TSRMLS_CC); } switch_case_list { zend_do_switch_end(&$6 TSRMLS_CC); }
+	|	T_BREAK ';'				{ zend_do_brk_cont(ZEND_BRK, NULL TSRMLS_CC); }
+	|	T_BREAK expr ';'		{ zend_do_brk_cont(ZEND_BRK, &$2 TSRMLS_CC); }
+	|	T_CONTINUE ';'			{ zend_do_brk_cont(ZEND_CONT, NULL TSRMLS_CC); }
+	|	T_CONTINUE expr ';'		{ zend_do_brk_cont(ZEND_CONT, &$2 TSRMLS_CC); }
+	|	T_RETURN ';'						{ zend_do_return(NULL, 0 TSRMLS_CC); }
+	|	T_RETURN expr_without_variable ';'	{ zend_do_return(&$2, 0 TSRMLS_CC); }
+	|	T_RETURN cvar ';'					{ zend_do_return(&$2, 1 TSRMLS_CC); }
 	|	T_GLOBAL global_var_list ';'
 	|	T_STATIC static_var_list ';'
 	|	T_ECHO echo_expr_list ';'
-	|	T_INLINE_HTML			{ zend_do_echo(&$1 CLS_CC); }
-	|	expr ';'				{ zend_do_free(&$1 CLS_CC); }
+	|	T_INLINE_HTML			{ zend_do_echo(&$1 TSRMLS_CC); }
+	|	expr ';'				{ zend_do_free(&$1 TSRMLS_CC); }
 	|	T_USE use_filename ';'		{ zend_error(E_COMPILE_ERROR,"use: Not yet supported. Please use include_once() or require_once()");  zval_dtor(&$2.u.constant); }
 	|	T_UNSET '(' unset_variables ')' ';'
-	|	T_FOREACH '(' w_cvar T_AS { zend_do_foreach_begin(&$1, &$3, &$2, &$4, 1 CLS_CC); } w_cvar foreach_optional_arg ')' { zend_do_foreach_cont(&$6, &$7, &$4 CLS_CC); } foreach_statement { zend_do_foreach_end(&$1, &$2 CLS_CC); }
-	|	T_FOREACH '(' expr_without_variable T_AS { zend_do_foreach_begin(&$1, &$3, &$2, &$4, 0 CLS_CC); } w_cvar foreach_optional_arg ')' { zend_do_foreach_cont(&$6, &$7, &$4 CLS_CC); } foreach_statement { zend_do_foreach_end(&$1, &$2 CLS_CC); }
-	|	T_DECLARE { zend_do_declare_begin(CLS_C); } '(' declare_list ')' declare_statement { zend_do_declare_end(CLS_C); }
+	|	T_FOREACH '(' w_cvar T_AS { zend_do_foreach_begin(&$1, &$3, &$2, &$4, 1 TSRMLS_CC); } w_cvar foreach_optional_arg ')' { zend_do_foreach_cont(&$6, &$7, &$4 TSRMLS_CC); } foreach_statement { zend_do_foreach_end(&$1, &$2 TSRMLS_CC); }
+	|	T_FOREACH '(' expr_without_variable T_AS { zend_do_foreach_begin(&$1, &$3, &$2, &$4, 0 TSRMLS_CC); } w_cvar foreach_optional_arg ')' { zend_do_foreach_cont(&$6, &$7, &$4 TSRMLS_CC); } foreach_statement { zend_do_foreach_end(&$1, &$2 TSRMLS_CC); }
+	|	T_DECLARE { zend_do_declare_begin(TSRMLS_C); } '(' declare_list ')' declare_statement { zend_do_declare_end(TSRMLS_C); }
 	|	';'		/* empty statement */
 ;
 
@@ -209,7 +209,7 @@ unset_variables:
 ;
 
 unset_variable:
-		cvar	{ zend_do_end_variable_parse(BP_VAR_UNSET, 0 CLS_CC); zend_do_unset(&$1 CLS_CC); }
+		cvar	{ zend_do_end_variable_parse(BP_VAR_UNSET, 0 TSRMLS_CC); zend_do_unset(&$1 TSRMLS_CC); }
 ;
 
 use_filename:
@@ -219,17 +219,17 @@ use_filename:
 
 
 declaration_statement:
-		unticked_declaration_statement	{ zend_do_ticks(CLS_C); }
+		unticked_declaration_statement	{ zend_do_ticks(TSRMLS_C); }
 ;
 
 
 unticked_declaration_statement:
-		T_FUNCTION { $1.u.opline_num = CG(zend_lineno); } is_reference T_STRING { zend_do_begin_function_declaration(&$1, &$4, 0, $3.op_type CLS_CC); }
-			'(' parameter_list ')' '{' inner_statement_list '}' { zend_do_end_function_declaration(&$1 CLS_CC); }
-	|	T_OLD_FUNCTION { $1.u.opline_num = CG(zend_lineno); } is_reference T_STRING  { zend_do_begin_function_declaration(&$1, &$4, 0, $3.op_type CLS_CC); }
-			parameter_list '(' inner_statement_list ')' ';' { zend_do_end_function_declaration(&$1 CLS_CC); }
-	|	T_CLASS T_STRING { zend_do_begin_class_declaration(&$2, NULL CLS_CC); } '{' class_statement_list '}' { zend_do_end_class_declaration(CLS_C); }
-	|	T_CLASS T_STRING T_EXTENDS T_STRING { zend_do_begin_class_declaration(&$2, &$4 CLS_CC); } '{' class_statement_list '}' { zend_do_end_class_declaration(CLS_C); }
+		T_FUNCTION { $1.u.opline_num = CG(zend_lineno); } is_reference T_STRING { zend_do_begin_function_declaration(&$1, &$4, 0, $3.op_type TSRMLS_CC); }
+			'(' parameter_list ')' '{' inner_statement_list '}' { zend_do_end_function_declaration(&$1 TSRMLS_CC); }
+	|	T_OLD_FUNCTION { $1.u.opline_num = CG(zend_lineno); } is_reference T_STRING  { zend_do_begin_function_declaration(&$1, &$4, 0, $3.op_type TSRMLS_CC); }
+			parameter_list '(' inner_statement_list ')' ';' { zend_do_end_function_declaration(&$1 TSRMLS_CC); }
+	|	T_CLASS T_STRING { zend_do_begin_class_declaration(&$2, NULL TSRMLS_CC); } '{' class_statement_list '}' { zend_do_end_class_declaration(TSRMLS_C); }
+	|	T_CLASS T_STRING T_EXTENDS T_STRING { zend_do_begin_class_declaration(&$2, &$4 TSRMLS_CC); } '{' class_statement_list '}' { zend_do_end_class_declaration(TSRMLS_C); }
 ;
 
 
@@ -258,8 +258,8 @@ declare_statement:
 
 
 declare_list:
-		T_STRING '=' static_scalar					{ zend_do_declare_stmt(&$1, &$3 CLS_CC); }
-	|	declare_list ',' T_STRING '=' static_scalar	{ zend_do_declare_stmt(&$3, &$5 CLS_CC); }
+		T_STRING '=' static_scalar					{ zend_do_declare_stmt(&$1, &$3 TSRMLS_CC); }
+	|	declare_list ',' T_STRING '=' static_scalar	{ zend_do_declare_stmt(&$3, &$5 TSRMLS_CC); }
 ;
 
 
@@ -273,8 +273,8 @@ switch_case_list:
 
 case_list:
 		/* empty */	{ $$.op_type = IS_UNUSED; }
-	|	case_list T_CASE expr case_separator { zend_do_extended_info(CLS_C);  zend_do_case_before_statement(&$1, &$2, &$3 CLS_CC); } inner_statement_list { zend_do_case_after_statement(&$$, &$2 CLS_CC); $$.op_type = IS_CONST }
-	|	case_list T_DEFAULT case_separator { zend_do_extended_info(CLS_C);  zend_do_default_before_statement(&$1, &$2 CLS_CC); } inner_statement_list { zend_do_case_after_statement(&$$, &$2 CLS_CC); $$.op_type = IS_CONST; }
+	|	case_list T_CASE expr case_separator { zend_do_extended_info(TSRMLS_C);  zend_do_case_before_statement(&$1, &$2, &$3 TSRMLS_CC); } inner_statement_list { zend_do_case_after_statement(&$$, &$2 TSRMLS_CC); $$.op_type = IS_CONST }
+	|	case_list T_DEFAULT case_separator { zend_do_extended_info(TSRMLS_C);  zend_do_default_before_statement(&$1, &$2 TSRMLS_CC); } inner_statement_list { zend_do_case_after_statement(&$$, &$2 TSRMLS_CC); $$.op_type = IS_CONST; }
 ;
 
 
@@ -293,13 +293,13 @@ while_statement:
 
 elseif_list:
 		/* empty */
-	|	elseif_list T_ELSEIF '(' expr ')' { zend_do_if_cond(&$4, &$5 CLS_CC); } statement { zend_do_if_after_statement(&$5, 0 CLS_CC); }
+	|	elseif_list T_ELSEIF '(' expr ')' { zend_do_if_cond(&$4, &$5 TSRMLS_CC); } statement { zend_do_if_after_statement(&$5, 0 TSRMLS_CC); }
 ;
 
 
 new_elseif_list:
 		/* empty */
-	|	new_elseif_list T_ELSEIF '(' expr ')' ':' { zend_do_if_cond(&$4, &$5 CLS_CC); } inner_statement_list { zend_do_if_after_statement(&$5, 0 CLS_CC); }
+	|	new_elseif_list T_ELSEIF '(' expr ')' ':' { zend_do_if_cond(&$4, &$5 TSRMLS_CC); } inner_statement_list { zend_do_if_after_statement(&$5, 0 TSRMLS_CC); }
 ;
 
 
@@ -322,14 +322,14 @@ parameter_list:
 
 
 non_empty_parameter_list:
-		T_VARIABLE				{ znode tmp;  fetch_simple_variable(&tmp, &$1, 0 CLS_CC); $$.op_type = IS_CONST; $$.u.constant.value.lval=1; $$.u.constant.type=IS_LONG; INIT_PZVAL(&$$.u.constant); zend_do_receive_arg(ZEND_RECV, &tmp, &$$, NULL, BYREF_NONE CLS_CC); }
-	|	'&' T_VARIABLE			{ znode tmp;  fetch_simple_variable(&tmp, &$2, 0 CLS_CC); $$.op_type = IS_CONST; $$.u.constant.value.lval=1; $$.u.constant.type=IS_LONG; INIT_PZVAL(&$$.u.constant); zend_do_receive_arg(ZEND_RECV, &tmp, &$$, NULL, BYREF_FORCE CLS_CC); }
-	|	T_CONST T_VARIABLE 		{ znode tmp;  fetch_simple_variable(&tmp, &$2, 0 CLS_CC); $$.op_type = IS_CONST; $$.u.constant.value.lval=1; $$.u.constant.type=IS_LONG; INIT_PZVAL(&$$.u.constant); zend_do_receive_arg(ZEND_RECV, &tmp, &$$, NULL, BYREF_NONE CLS_CC); }
-	|	T_VARIABLE '=' static_scalar				{ znode tmp;  fetch_simple_variable(&tmp, &$1, 0 CLS_CC); $$.op_type = IS_CONST; $$.u.constant.value.lval=1; $$.u.constant.type=IS_LONG; INIT_PZVAL(&$$.u.constant); zend_do_receive_arg(ZEND_RECV_INIT, &tmp, &$$, &$3, BYREF_NONE CLS_CC); }
-	|	non_empty_parameter_list ',' T_VARIABLE 	{ znode tmp;  fetch_simple_variable(&tmp, &$3, 0 CLS_CC); $$=$1; $$.u.constant.value.lval++; zend_do_receive_arg(ZEND_RECV, &tmp, &$$, NULL, BYREF_NONE CLS_CC); }
-	|	non_empty_parameter_list ',' '&' T_VARIABLE	{ znode tmp;  fetch_simple_variable(&tmp, &$4, 0 CLS_CC); $$=$1; $$.u.constant.value.lval++; zend_do_receive_arg(ZEND_RECV, &tmp, &$$, NULL, BYREF_FORCE CLS_CC); }
-	|	non_empty_parameter_list ',' T_CONST T_VARIABLE				{ znode tmp;  fetch_simple_variable(&tmp, &$4, 0 CLS_CC); $$=$1; $$.u.constant.value.lval++; zend_do_receive_arg(ZEND_RECV, &tmp, &$$, NULL, BYREF_NONE CLS_CC); }
-	|	non_empty_parameter_list ',' T_VARIABLE '=' static_scalar 	{ znode tmp;  fetch_simple_variable(&tmp, &$3, 0 CLS_CC); $$=$1; $$.u.constant.value.lval++; zend_do_receive_arg(ZEND_RECV_INIT, &tmp, &$$, &$5, BYREF_NONE CLS_CC); }
+		T_VARIABLE				{ znode tmp;  fetch_simple_variable(&tmp, &$1, 0 TSRMLS_CC); $$.op_type = IS_CONST; $$.u.constant.value.lval=1; $$.u.constant.type=IS_LONG; INIT_PZVAL(&$$.u.constant); zend_do_receive_arg(ZEND_RECV, &tmp, &$$, NULL, BYREF_NONE TSRMLS_CC); }
+	|	'&' T_VARIABLE			{ znode tmp;  fetch_simple_variable(&tmp, &$2, 0 TSRMLS_CC); $$.op_type = IS_CONST; $$.u.constant.value.lval=1; $$.u.constant.type=IS_LONG; INIT_PZVAL(&$$.u.constant); zend_do_receive_arg(ZEND_RECV, &tmp, &$$, NULL, BYREF_FORCE TSRMLS_CC); }
+	|	T_CONST T_VARIABLE 		{ znode tmp;  fetch_simple_variable(&tmp, &$2, 0 TSRMLS_CC); $$.op_type = IS_CONST; $$.u.constant.value.lval=1; $$.u.constant.type=IS_LONG; INIT_PZVAL(&$$.u.constant); zend_do_receive_arg(ZEND_RECV, &tmp, &$$, NULL, BYREF_NONE TSRMLS_CC); }
+	|	T_VARIABLE '=' static_scalar				{ znode tmp;  fetch_simple_variable(&tmp, &$1, 0 TSRMLS_CC); $$.op_type = IS_CONST; $$.u.constant.value.lval=1; $$.u.constant.type=IS_LONG; INIT_PZVAL(&$$.u.constant); zend_do_receive_arg(ZEND_RECV_INIT, &tmp, &$$, &$3, BYREF_NONE TSRMLS_CC); }
+	|	non_empty_parameter_list ',' T_VARIABLE 	{ znode tmp;  fetch_simple_variable(&tmp, &$3, 0 TSRMLS_CC); $$=$1; $$.u.constant.value.lval++; zend_do_receive_arg(ZEND_RECV, &tmp, &$$, NULL, BYREF_NONE TSRMLS_CC); }
+	|	non_empty_parameter_list ',' '&' T_VARIABLE	{ znode tmp;  fetch_simple_variable(&tmp, &$4, 0 TSRMLS_CC); $$=$1; $$.u.constant.value.lval++; zend_do_receive_arg(ZEND_RECV, &tmp, &$$, NULL, BYREF_FORCE TSRMLS_CC); }
+	|	non_empty_parameter_list ',' T_CONST T_VARIABLE				{ znode tmp;  fetch_simple_variable(&tmp, &$4, 0 TSRMLS_CC); $$=$1; $$.u.constant.value.lval++; zend_do_receive_arg(ZEND_RECV, &tmp, &$$, NULL, BYREF_NONE TSRMLS_CC); }
+	|	non_empty_parameter_list ',' T_VARIABLE '=' static_scalar 	{ znode tmp;  fetch_simple_variable(&tmp, &$3, 0 TSRMLS_CC); $$=$1; $$.u.constant.value.lval++; zend_do_receive_arg(ZEND_RECV_INIT, &tmp, &$$, &$5, BYREF_NONE TSRMLS_CC); }
 ;
 
 
@@ -340,17 +340,17 @@ function_call_parameter_list:
 
 
 non_empty_function_call_parameter_list:
-		expr_without_variable	{ $$.u.constant.value.lval = 1;  zend_do_pass_param(&$1, ZEND_SEND_VAL, $$.u.constant.value.lval CLS_CC); }
-	|	cvar					{ $$.u.constant.value.lval = 1;  zend_do_pass_param(&$1, ZEND_SEND_VAR, $$.u.constant.value.lval CLS_CC); }
-	|	'&' w_cvar 				{ $$.u.constant.value.lval = 1;  zend_do_pass_param(&$2, ZEND_SEND_REF, $$.u.constant.value.lval CLS_CC); }
-	|	non_empty_function_call_parameter_list ',' expr_without_variable	{ $$.u.constant.value.lval=$1.u.constant.value.lval+1;  zend_do_pass_param(&$3, ZEND_SEND_VAL, $$.u.constant.value.lval CLS_CC); }
-	|	non_empty_function_call_parameter_list ',' cvar						{ $$.u.constant.value.lval=$1.u.constant.value.lval+1;  zend_do_pass_param(&$3, ZEND_SEND_VAR, $$.u.constant.value.lval CLS_CC); }
-	|	non_empty_function_call_parameter_list ',' '&' w_cvar				{ $$.u.constant.value.lval=$1.u.constant.value.lval+1;  zend_do_pass_param(&$4, ZEND_SEND_REF, $$.u.constant.value.lval CLS_CC); }
+		expr_without_variable	{ $$.u.constant.value.lval = 1;  zend_do_pass_param(&$1, ZEND_SEND_VAL, $$.u.constant.value.lval TSRMLS_CC); }
+	|	cvar					{ $$.u.constant.value.lval = 1;  zend_do_pass_param(&$1, ZEND_SEND_VAR, $$.u.constant.value.lval TSRMLS_CC); }
+	|	'&' w_cvar 				{ $$.u.constant.value.lval = 1;  zend_do_pass_param(&$2, ZEND_SEND_REF, $$.u.constant.value.lval TSRMLS_CC); }
+	|	non_empty_function_call_parameter_list ',' expr_without_variable	{ $$.u.constant.value.lval=$1.u.constant.value.lval+1;  zend_do_pass_param(&$3, ZEND_SEND_VAL, $$.u.constant.value.lval TSRMLS_CC); }
+	|	non_empty_function_call_parameter_list ',' cvar						{ $$.u.constant.value.lval=$1.u.constant.value.lval+1;  zend_do_pass_param(&$3, ZEND_SEND_VAR, $$.u.constant.value.lval TSRMLS_CC); }
+	|	non_empty_function_call_parameter_list ',' '&' w_cvar				{ $$.u.constant.value.lval=$1.u.constant.value.lval+1;  zend_do_pass_param(&$4, ZEND_SEND_REF, $$.u.constant.value.lval TSRMLS_CC); }
 ;
 
 global_var_list:
-		global_var_list ',' global_var	{ zend_do_fetch_global_or_static_variable(&$3, NULL, ZEND_FETCH_GLOBAL CLS_CC); }
-	|	global_var						{ zend_do_fetch_global_or_static_variable(&$1, NULL, ZEND_FETCH_GLOBAL CLS_CC); }
+		global_var_list ',' global_var	{ zend_do_fetch_global_or_static_variable(&$3, NULL, ZEND_FETCH_GLOBAL TSRMLS_CC); }
+	|	global_var						{ zend_do_fetch_global_or_static_variable(&$1, NULL, ZEND_FETCH_GLOBAL TSRMLS_CC); }
 ;
 
 
@@ -362,10 +362,10 @@ global_var:
 
 
 static_var_list:
-		static_var_list ',' T_VARIABLE { zend_do_fetch_global_or_static_variable(&$3, NULL, ZEND_FETCH_STATIC CLS_CC); }
-	|	static_var_list ',' T_VARIABLE '=' static_scalar { zend_do_fetch_global_or_static_variable(&$3, &$5, ZEND_FETCH_STATIC CLS_CC); }
-	|	T_VARIABLE  { zend_do_fetch_global_or_static_variable(&$1, NULL, ZEND_FETCH_STATIC CLS_CC); }
-	|	T_VARIABLE '=' static_scalar { zend_do_fetch_global_or_static_variable(&$1, &$3, ZEND_FETCH_STATIC CLS_CC); }
+		static_var_list ',' T_VARIABLE { zend_do_fetch_global_or_static_variable(&$3, NULL, ZEND_FETCH_STATIC TSRMLS_CC); }
+	|	static_var_list ',' T_VARIABLE '=' static_scalar { zend_do_fetch_global_or_static_variable(&$3, &$5, ZEND_FETCH_STATIC TSRMLS_CC); }
+	|	T_VARIABLE  { zend_do_fetch_global_or_static_variable(&$1, NULL, ZEND_FETCH_STATIC TSRMLS_CC); }
+	|	T_VARIABLE '=' static_scalar { zend_do_fetch_global_or_static_variable(&$1, &$3, ZEND_FETCH_STATIC TSRMLS_CC); }
 
 ;
 
@@ -378,10 +378,10 @@ class_statement_list:
 
 class_statement:
 		T_VAR class_variable_decleration ';'
-	|	T_FUNCTION { $1.u.opline_num = CG(zend_lineno); } is_reference T_STRING { zend_do_begin_function_declaration(&$1, &$4, 1, $3.op_type CLS_CC); } '(' 
-			parameter_list ')' '{' inner_statement_list '}' { zend_do_end_function_declaration(&$1 CLS_CC); }
-	|	T_OLD_FUNCTION { $1.u.opline_num = CG(zend_lineno); } is_reference T_STRING { zend_do_begin_function_declaration(&$1, &$4, 1, $3.op_type CLS_CC); }
-			parameter_list '(' inner_statement_list ')' ';' { zend_do_end_function_declaration(&$1 CLS_CC); }
+	|	T_FUNCTION { $1.u.opline_num = CG(zend_lineno); } is_reference T_STRING { zend_do_begin_function_declaration(&$1, &$4, 1, $3.op_type TSRMLS_CC); } '(' 
+			parameter_list ')' '{' inner_statement_list '}' { zend_do_end_function_declaration(&$1 TSRMLS_CC); }
+	|	T_OLD_FUNCTION { $1.u.opline_num = CG(zend_lineno); } is_reference T_STRING { zend_do_begin_function_declaration(&$1, &$4, 1, $3.op_type TSRMLS_CC); }
+			parameter_list '(' inner_statement_list ')' ';' { zend_do_end_function_declaration(&$1 TSRMLS_CC); }
 
 ;
 
@@ -390,16 +390,16 @@ is_reference:
 	|	'&'			{ $$.op_type = ZEND_RETURN_REF; }
 
 class_variable_decleration:
-		class_variable_decleration ',' T_VARIABLE					{ zend_do_declare_property(&$3, NULL CLS_CC); }
-	|	class_variable_decleration ',' T_VARIABLE '=' static_scalar	{ zend_do_declare_property(&$3, &$5 CLS_CC); }
-	|	T_VARIABLE						{ zend_do_declare_property(&$1, NULL CLS_CC); }
-	|	T_VARIABLE '=' static_scalar	{ zend_do_declare_property(&$1, &$3 CLS_CC); }
+		class_variable_decleration ',' T_VARIABLE					{ zend_do_declare_property(&$3, NULL TSRMLS_CC); }
+	|	class_variable_decleration ',' T_VARIABLE '=' static_scalar	{ zend_do_declare_property(&$3, &$5 TSRMLS_CC); }
+	|	T_VARIABLE						{ zend_do_declare_property(&$1, NULL TSRMLS_CC); }
+	|	T_VARIABLE '=' static_scalar	{ zend_do_declare_property(&$1, &$3 TSRMLS_CC); }
 ;
 
 
 echo_expr_list:	
-	|	echo_expr_list ',' expr { zend_do_echo(&$3 CLS_CC); }
-	|	expr					{ zend_do_echo(&$1 CLS_CC); }
+	|	echo_expr_list ',' expr { zend_do_echo(&$3 TSRMLS_CC); }
+	|	expr					{ zend_do_echo(&$1 TSRMLS_CC); }
 ;
 
 
@@ -409,92 +409,92 @@ for_expr:
 ;
 
 non_empty_for_expr:
-		non_empty_for_expr ','	{ zend_do_free(&$1 CLS_CC); } expr { $$ = $4; }
+		non_empty_for_expr ','	{ zend_do_free(&$1 TSRMLS_CC); } expr { $$ = $4; }
 	|	expr					{ $$ = $1; }
 ;
 
 
 expr_without_variable:	
-		T_LIST '(' { zend_do_list_init(CLS_C); } assignment_list ')' '=' expr { zend_do_list_end(&$$, &$7 CLS_CC); }
-	|	cvar '=' expr		{ zend_do_end_variable_parse(BP_VAR_W, 0 CLS_CC); zend_do_assign(&$$, &$1, &$3 CLS_CC); }
-	|	cvar '=' '&' w_cvar	{ zend_do_end_variable_parse(BP_VAR_W, 0 CLS_CC); zend_do_assign_ref(&$$, &$1, &$4 CLS_CC); }
-	|	cvar '=' '&' function_call { zend_do_end_variable_parse(BP_VAR_W, 0 CLS_CC); zend_do_assign_ref(&$$, &$1, &$4 CLS_CC); }
-	|	cvar '=' '&' T_NEW static_or_variable_string { zend_do_extended_fcall_begin(CLS_C); zend_do_begin_new_object(&$4, &$5 CLS_CC); } ctor_arguments { zend_do_end_new_object(&$3, &$5, &$4, &$7 CLS_CC); zend_do_extended_fcall_end(CLS_C); zend_do_end_variable_parse(BP_VAR_W, 0 CLS_CC); zend_do_assign_ref(&$$, &$1, &$3 CLS_CC); }
-	|	T_NEW static_or_variable_string { zend_do_extended_fcall_begin(CLS_C); zend_do_begin_new_object(&$1, &$2 CLS_CC); } ctor_arguments { zend_do_end_new_object(&$$, &$2, &$1, &$4 CLS_CC); zend_do_extended_fcall_end(CLS_C);}
-	|	cvar T_PLUS_EQUAL expr 	{ zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_ADD, &$$, &$1, &$3 CLS_CC); }
-	|	cvar T_MINUS_EQUAL expr	{ zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_SUB, &$$, &$1, &$3 CLS_CC); }
-	|	cvar T_MUL_EQUAL expr		{ zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_MUL, &$$, &$1, &$3 CLS_CC); }
-	|	cvar T_DIV_EQUAL expr		{ zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_DIV, &$$, &$1, &$3 CLS_CC); }
-	|	cvar T_CONCAT_EQUAL expr	{ zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_CONCAT, &$$, &$1, &$3 CLS_CC); }
-	|	cvar T_MOD_EQUAL expr		{ zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_MOD, &$$, &$1, &$3 CLS_CC); }
-	|	cvar T_AND_EQUAL expr		{ zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_BW_AND, &$$, &$1, &$3 CLS_CC); }
-	|	cvar T_OR_EQUAL expr 		{ zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_BW_OR, &$$, &$1, &$3 CLS_CC); }
-	|	cvar T_XOR_EQUAL expr 		{ zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_BW_XOR, &$$, &$1, &$3 CLS_CC); }
-	|	cvar T_SL_EQUAL expr	{ zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_SL, &$$, &$1, &$3 CLS_CC); } 
-	|	cvar T_SR_EQUAL expr	{ zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_SR, &$$, &$1, &$3 CLS_CC); } 
-	|	rw_cvar T_INC { zend_do_post_incdec(&$$, &$1, ZEND_POST_INC CLS_CC); }
-	|	T_INC rw_cvar { zend_do_pre_incdec(&$$, &$2, ZEND_PRE_INC CLS_CC); }
-	|	rw_cvar T_DEC { zend_do_post_incdec(&$$, &$1, ZEND_POST_DEC CLS_CC); }
-	|	T_DEC rw_cvar { zend_do_pre_incdec(&$$, &$2, ZEND_PRE_DEC CLS_CC); }
-	|	expr T_BOOLEAN_OR { zend_do_boolean_or_begin(&$1, &$2 CLS_CC); } expr { zend_do_boolean_or_end(&$$, &$1, &$4, &$2 CLS_CC); }
-	|	expr T_BOOLEAN_AND { zend_do_boolean_and_begin(&$1, &$2 CLS_CC); } expr { zend_do_boolean_and_end(&$$, &$1, &$4, &$2 CLS_CC); }  
-	|	expr T_LOGICAL_OR { zend_do_boolean_or_begin(&$1, &$2 CLS_CC); } expr { zend_do_boolean_or_end(&$$, &$1, &$4, &$2 CLS_CC); }
-	|	expr T_LOGICAL_AND { zend_do_boolean_and_begin(&$1, &$2 CLS_CC); } expr { zend_do_boolean_and_end(&$$, &$1, &$4, &$2 CLS_CC); }
-	|	expr T_LOGICAL_XOR expr { zend_do_binary_op(ZEND_BOOL_XOR, &$$, &$1, &$3 CLS_CC); }
-	|	expr '|' expr	{ zend_do_binary_op(ZEND_BW_OR, &$$, &$1, &$3 CLS_CC); }
-	|	expr '&' expr	{ zend_do_binary_op(ZEND_BW_AND, &$$, &$1, &$3 CLS_CC); }
-	|	expr '^' expr	{ zend_do_binary_op(ZEND_BW_XOR, &$$, &$1, &$3 CLS_CC); }
-	|	expr '.' expr 	{ zend_do_binary_op(ZEND_CONCAT,&$$,&$1,&$3 CLS_CC); }
-	|	expr '+' expr 	{ zend_do_binary_op(ZEND_ADD,&$$,&$1,&$3 CLS_CC); }
-	|	expr '-' expr 	{ zend_do_binary_op(ZEND_SUB,&$$,&$1,&$3 CLS_CC); }
-	|	expr '*' expr	{ zend_do_binary_op(ZEND_MUL,&$$,&$1,&$3 CLS_CC); }
-	|	expr '/' expr	{ zend_do_binary_op(ZEND_DIV,&$$,&$1,&$3 CLS_CC); }
-	|	expr '%' expr 	{ zend_do_binary_op(ZEND_MOD,&$$,&$1,&$3 CLS_CC); }
-	| 	expr T_SL expr	{ zend_do_binary_op(ZEND_SL, &$$, &$1, &$3 CLS_CC); }
-	|	expr T_SR expr	{ zend_do_binary_op(ZEND_SR, &$$, &$1, &$3 CLS_CC); }
-	|	'+' expr { $1.u.constant.value.lval=0; $1.u.constant.type=IS_LONG; $1.op_type = IS_CONST; INIT_PZVAL(&$1.u.constant); zend_do_binary_op(ZEND_ADD, &$$, &$1, &$2 CLS_CC); }
-	|	'-' expr { $1.u.constant.value.lval=0; $1.u.constant.type=IS_LONG; $1.op_type = IS_CONST; INIT_PZVAL(&$1.u.constant); zend_do_binary_op(ZEND_SUB, &$$, &$1, &$2 CLS_CC); }
-	|	'!' expr { zend_do_unary_op(ZEND_BOOL_NOT, &$$, &$2 CLS_CC); }
-	|	'~' expr { zend_do_unary_op(ZEND_BW_NOT, &$$, &$2 CLS_CC); }
-	|	expr T_IS_IDENTICAL expr		{ zend_do_binary_op(ZEND_IS_IDENTICAL, &$$, &$1, &$3 CLS_CC); }
-	|	expr T_IS_NOT_IDENTICAL expr	{ zend_do_binary_op(ZEND_IS_NOT_IDENTICAL, &$$, &$1, &$3 CLS_CC); }
-	|	expr T_IS_EQUAL expr			{ zend_do_binary_op(ZEND_IS_EQUAL, &$$, &$1, &$3 CLS_CC); }
-	|	expr T_IS_NOT_EQUAL expr 		{ zend_do_binary_op(ZEND_IS_NOT_EQUAL, &$$, &$1, &$3 CLS_CC); }
-	|	expr '<' expr 					{ zend_do_binary_op(ZEND_IS_SMALLER, &$$, &$1, &$3 CLS_CC); }
-	|	expr T_IS_SMALLER_OR_EQUAL expr { zend_do_binary_op(ZEND_IS_SMALLER_OR_EQUAL, &$$, &$1, &$3 CLS_CC); }
-	|	expr '>' expr 					{ zend_do_binary_op(ZEND_IS_SMALLER, &$$, &$3, &$1 CLS_CC); }
-	|	expr T_IS_GREATER_OR_EQUAL expr { zend_do_binary_op(ZEND_IS_SMALLER_OR_EQUAL, &$$, &$3, &$1 CLS_CC); }
+		T_LIST '(' { zend_do_list_init(TSRMLS_C); } assignment_list ')' '=' expr { zend_do_list_end(&$$, &$7 TSRMLS_CC); }
+	|	cvar '=' expr		{ zend_do_end_variable_parse(BP_VAR_W, 0 TSRMLS_CC); zend_do_assign(&$$, &$1, &$3 TSRMLS_CC); }
+	|	cvar '=' '&' w_cvar	{ zend_do_end_variable_parse(BP_VAR_W, 0 TSRMLS_CC); zend_do_assign_ref(&$$, &$1, &$4 TSRMLS_CC); }
+	|	cvar '=' '&' function_call { zend_do_end_variable_parse(BP_VAR_W, 0 TSRMLS_CC); zend_do_assign_ref(&$$, &$1, &$4 TSRMLS_CC); }
+	|	cvar '=' '&' T_NEW static_or_variable_string { zend_do_extended_fcall_begin(TSRMLS_C); zend_do_begin_new_object(&$4, &$5 TSRMLS_CC); } ctor_arguments { zend_do_end_new_object(&$3, &$5, &$4, &$7 TSRMLS_CC); zend_do_extended_fcall_end(TSRMLS_C); zend_do_end_variable_parse(BP_VAR_W, 0 TSRMLS_CC); zend_do_assign_ref(&$$, &$1, &$3 TSRMLS_CC); }
+	|	T_NEW static_or_variable_string { zend_do_extended_fcall_begin(TSRMLS_C); zend_do_begin_new_object(&$1, &$2 TSRMLS_CC); } ctor_arguments { zend_do_end_new_object(&$$, &$2, &$1, &$4 TSRMLS_CC); zend_do_extended_fcall_end(TSRMLS_C);}
+	|	cvar T_PLUS_EQUAL expr 	{ zend_do_end_variable_parse(BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_ADD, &$$, &$1, &$3 TSRMLS_CC); }
+	|	cvar T_MINUS_EQUAL expr	{ zend_do_end_variable_parse(BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_SUB, &$$, &$1, &$3 TSRMLS_CC); }
+	|	cvar T_MUL_EQUAL expr		{ zend_do_end_variable_parse(BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_MUL, &$$, &$1, &$3 TSRMLS_CC); }
+	|	cvar T_DIV_EQUAL expr		{ zend_do_end_variable_parse(BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_DIV, &$$, &$1, &$3 TSRMLS_CC); }
+	|	cvar T_CONCAT_EQUAL expr	{ zend_do_end_variable_parse(BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_CONCAT, &$$, &$1, &$3 TSRMLS_CC); }
+	|	cvar T_MOD_EQUAL expr		{ zend_do_end_variable_parse(BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_MOD, &$$, &$1, &$3 TSRMLS_CC); }
+	|	cvar T_AND_EQUAL expr		{ zend_do_end_variable_parse(BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_BW_AND, &$$, &$1, &$3 TSRMLS_CC); }
+	|	cvar T_OR_EQUAL expr 		{ zend_do_end_variable_parse(BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_BW_OR, &$$, &$1, &$3 TSRMLS_CC); }
+	|	cvar T_XOR_EQUAL expr 		{ zend_do_end_variable_parse(BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_BW_XOR, &$$, &$1, &$3 TSRMLS_CC); }
+	|	cvar T_SL_EQUAL expr	{ zend_do_end_variable_parse(BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_SL, &$$, &$1, &$3 TSRMLS_CC); } 
+	|	cvar T_SR_EQUAL expr	{ zend_do_end_variable_parse(BP_VAR_RW, 0 TSRMLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_SR, &$$, &$1, &$3 TSRMLS_CC); } 
+	|	rw_cvar T_INC { zend_do_post_incdec(&$$, &$1, ZEND_POST_INC TSRMLS_CC); }
+	|	T_INC rw_cvar { zend_do_pre_incdec(&$$, &$2, ZEND_PRE_INC TSRMLS_CC); }
+	|	rw_cvar T_DEC { zend_do_post_incdec(&$$, &$1, ZEND_POST_DEC TSRMLS_CC); }
+	|	T_DEC rw_cvar { zend_do_pre_incdec(&$$, &$2, ZEND_PRE_DEC TSRMLS_CC); }
+	|	expr T_BOOLEAN_OR { zend_do_boolean_or_begin(&$1, &$2 TSRMLS_CC); } expr { zend_do_boolean_or_end(&$$, &$1, &$4, &$2 TSRMLS_CC); }
+	|	expr T_BOOLEAN_AND { zend_do_boolean_and_begin(&$1, &$2 TSRMLS_CC); } expr { zend_do_boolean_and_end(&$$, &$1, &$4, &$2 TSRMLS_CC); }  
+	|	expr T_LOGICAL_OR { zend_do_boolean_or_begin(&$1, &$2 TSRMLS_CC); } expr { zend_do_boolean_or_end(&$$, &$1, &$4, &$2 TSRMLS_CC); }
+	|	expr T_LOGICAL_AND { zend_do_boolean_and_begin(&$1, &$2 TSRMLS_CC); } expr { zend_do_boolean_and_end(&$$, &$1, &$4, &$2 TSRMLS_CC); }
+	|	expr T_LOGICAL_XOR expr { zend_do_binary_op(ZEND_BOOL_XOR, &$$, &$1, &$3 TSRMLS_CC); }
+	|	expr '|' expr	{ zend_do_binary_op(ZEND_BW_OR, &$$, &$1, &$3 TSRMLS_CC); }
+	|	expr '&' expr	{ zend_do_binary_op(ZEND_BW_AND, &$$, &$1, &$3 TSRMLS_CC); }
+	|	expr '^' expr	{ zend_do_binary_op(ZEND_BW_XOR, &$$, &$1, &$3 TSRMLS_CC); }
+	|	expr '.' expr 	{ zend_do_binary_op(ZEND_CONCAT,&$$,&$1,&$3 TSRMLS_CC); }
+	|	expr '+' expr 	{ zend_do_binary_op(ZEND_ADD,&$$,&$1,&$3 TSRMLS_CC); }
+	|	expr '-' expr 	{ zend_do_binary_op(ZEND_SUB,&$$,&$1,&$3 TSRMLS_CC); }
+	|	expr '*' expr	{ zend_do_binary_op(ZEND_MUL,&$$,&$1,&$3 TSRMLS_CC); }
+	|	expr '/' expr	{ zend_do_binary_op(ZEND_DIV,&$$,&$1,&$3 TSRMLS_CC); }
+	|	expr '%' expr 	{ zend_do_binary_op(ZEND_MOD,&$$,&$1,&$3 TSRMLS_CC); }
+	| 	expr T_SL expr	{ zend_do_binary_op(ZEND_SL, &$$, &$1, &$3 TSRMLS_CC); }
+	|	expr T_SR expr	{ zend_do_binary_op(ZEND_SR, &$$, &$1, &$3 TSRMLS_CC); }
+	|	'+' expr { $1.u.constant.value.lval=0; $1.u.constant.type=IS_LONG; $1.op_type = IS_CONST; INIT_PZVAL(&$1.u.constant); zend_do_binary_op(ZEND_ADD, &$$, &$1, &$2 TSRMLS_CC); }
+	|	'-' expr { $1.u.constant.value.lval=0; $1.u.constant.type=IS_LONG; $1.op_type = IS_CONST; INIT_PZVAL(&$1.u.constant); zend_do_binary_op(ZEND_SUB, &$$, &$1, &$2 TSRMLS_CC); }
+	|	'!' expr { zend_do_unary_op(ZEND_BOOL_NOT, &$$, &$2 TSRMLS_CC); }
+	|	'~' expr { zend_do_unary_op(ZEND_BW_NOT, &$$, &$2 TSRMLS_CC); }
+	|	expr T_IS_IDENTICAL expr		{ zend_do_binary_op(ZEND_IS_IDENTICAL, &$$, &$1, &$3 TSRMLS_CC); }
+	|	expr T_IS_NOT_IDENTICAL expr	{ zend_do_binary_op(ZEND_IS_NOT_IDENTICAL, &$$, &$1, &$3 TSRMLS_CC); }
+	|	expr T_IS_EQUAL expr			{ zend_do_binary_op(ZEND_IS_EQUAL, &$$, &$1, &$3 TSRMLS_CC); }
+	|	expr T_IS_NOT_EQUAL expr 		{ zend_do_binary_op(ZEND_IS_NOT_EQUAL, &$$, &$1, &$3 TSRMLS_CC); }
+	|	expr '<' expr 					{ zend_do_binary_op(ZEND_IS_SMALLER, &$$, &$1, &$3 TSRMLS_CC); }
+	|	expr T_IS_SMALLER_OR_EQUAL expr { zend_do_binary_op(ZEND_IS_SMALLER_OR_EQUAL, &$$, &$1, &$3 TSRMLS_CC); }
+	|	expr '>' expr 					{ zend_do_binary_op(ZEND_IS_SMALLER, &$$, &$3, &$1 TSRMLS_CC); }
+	|	expr T_IS_GREATER_OR_EQUAL expr { zend_do_binary_op(ZEND_IS_SMALLER_OR_EQUAL, &$$, &$3, &$1 TSRMLS_CC); }
 	|	'(' expr ')' 	{ $$ = $2; }
-	|	expr '?' { zend_do_begin_qm_op(&$1, &$2 CLS_CC); }
-		expr ':' { zend_do_qm_true(&$4, &$2, &$5 CLS_CC); }
-		expr	 { zend_do_qm_false(&$$, &$7, &$2, &$5 CLS_CC); }
+	|	expr '?' { zend_do_begin_qm_op(&$1, &$2 TSRMLS_CC); }
+		expr ':' { zend_do_qm_true(&$4, &$2, &$5 TSRMLS_CC); }
+		expr	 { zend_do_qm_false(&$$, &$7, &$2, &$5 TSRMLS_CC); }
 	|	function_call { $$ = $1; }
 	|	internal_functions_in_yacc { $$ = $1; }
-	|	T_INT_CAST expr 	{ zend_do_cast(&$$, &$2, IS_LONG CLS_CC); }
-	|	T_DOUBLE_CAST expr 	{ zend_do_cast(&$$, &$2, IS_DOUBLE CLS_CC); }
-	|	T_STRING_CAST expr	{ zend_do_cast(&$$, &$2, IS_STRING CLS_CC); } 
-	|	T_ARRAY_CAST expr 	{ zend_do_cast(&$$, &$2, IS_ARRAY CLS_CC); }
-	|	T_OBJECT_CAST expr 	{ zend_do_cast(&$$, &$2, IS_OBJECT CLS_CC); }
-	|	T_BOOL_CAST expr	{ zend_do_cast(&$$, &$2, IS_BOOL CLS_CC); }
-	|	T_UNSET_CAST expr	{ zend_do_cast(&$$, &$2, IS_NULL CLS_CC); }
-	|	T_EXIT exit_expr	{ zend_do_exit(&$$, &$2 CLS_CC); }
-	|	'@' { zend_do_begin_silence(&$1 CLS_CC); } expr { zend_do_end_silence(&$1 CLS_CC); $$ = $3; }
+	|	T_INT_CAST expr 	{ zend_do_cast(&$$, &$2, IS_LONG TSRMLS_CC); }
+	|	T_DOUBLE_CAST expr 	{ zend_do_cast(&$$, &$2, IS_DOUBLE TSRMLS_CC); }
+	|	T_STRING_CAST expr	{ zend_do_cast(&$$, &$2, IS_STRING TSRMLS_CC); } 
+	|	T_ARRAY_CAST expr 	{ zend_do_cast(&$$, &$2, IS_ARRAY TSRMLS_CC); }
+	|	T_OBJECT_CAST expr 	{ zend_do_cast(&$$, &$2, IS_OBJECT TSRMLS_CC); }
+	|	T_BOOL_CAST expr	{ zend_do_cast(&$$, &$2, IS_BOOL TSRMLS_CC); }
+	|	T_UNSET_CAST expr	{ zend_do_cast(&$$, &$2, IS_NULL TSRMLS_CC); }
+	|	T_EXIT exit_expr	{ zend_do_exit(&$$, &$2 TSRMLS_CC); }
+	|	'@' { zend_do_begin_silence(&$1 TSRMLS_CC); } expr { zend_do_end_silence(&$1 TSRMLS_CC); $$ = $3; }
 	|	scalar				{ $$ = $1; }
 	|	T_ARRAY '(' array_pair_list ')' { $$ = $3; }
-	|	'`' encaps_list '`'		{ zend_do_shell_exec(&$$, &$2 CLS_CC); }
-	|	T_PRINT expr  { zend_do_print(&$$, &$2 CLS_CC); }
+	|	'`' encaps_list '`'		{ zend_do_shell_exec(&$$, &$2 TSRMLS_CC); }
+	|	T_PRINT expr  { zend_do_print(&$$, &$2 TSRMLS_CC); }
 ;
 
 function_call:
-		T_STRING	'(' { $2.u.opline_num = zend_do_begin_function_call(&$1 CLS_CC); }
+		T_STRING	'(' { $2.u.opline_num = zend_do_begin_function_call(&$1 TSRMLS_CC); }
 				function_call_parameter_list
-				')' { zend_do_end_function_call(&$1, &$$, &$4, 0, $2.u.opline_num CLS_CC); zend_do_extended_fcall_end(CLS_C); }
-	|	cvar '(' { zend_do_begin_dynamic_function_call(&$1 CLS_CC); } 
+				')' { zend_do_end_function_call(&$1, &$$, &$4, 0, $2.u.opline_num TSRMLS_CC); zend_do_extended_fcall_end(TSRMLS_C); }
+	|	cvar '(' { zend_do_begin_dynamic_function_call(&$1 TSRMLS_CC); } 
 				function_call_parameter_list 
-				')' { zend_do_end_function_call(&$1, &$$, &$4, 0, 1 CLS_CC); zend_do_extended_fcall_end(CLS_C);}
-	|	T_STRING T_PAAMAYIM_NEKUDOTAYIM static_or_variable_string '(' { zend_do_extended_fcall_begin(CLS_C); zend_do_begin_class_member_function_call(&$1, &$3 CLS_CC); } 
+				')' { zend_do_end_function_call(&$1, &$$, &$4, 0, 1 TSRMLS_CC); zend_do_extended_fcall_end(TSRMLS_C);}
+	|	T_STRING T_PAAMAYIM_NEKUDOTAYIM static_or_variable_string '(' { zend_do_extended_fcall_begin(TSRMLS_C); zend_do_begin_class_member_function_call(&$1, &$3 TSRMLS_CC); } 
 											function_call_parameter_list 
-											')' { zend_do_end_function_call(&$3, &$$, &$6, 1, 1 CLS_CC); zend_do_extended_fcall_end(CLS_C);}
+											')' { zend_do_end_function_call(&$3, &$$, &$6, 1, 1 TSRMLS_CC); zend_do_extended_fcall_end(TSRMLS_C);}
 ;
 
 
@@ -528,7 +528,7 @@ common_scalar:
 
 static_scalar: /* compile-time evaluated scalars */
 		common_scalar		{ $$ = $1; }
-	|	T_STRING 		{ zend_do_fetch_constant(&$$, &$1, ZEND_CT CLS_CC); }
+	|	T_STRING 		{ zend_do_fetch_constant(&$$, &$1, ZEND_CT TSRMLS_CC); }
 	|	'+' static_scalar	{ $$ = $1; }
 	|	'-' static_scalar	{ zval minus_one;  minus_one.type = IS_LONG; minus_one.value.lval = -1;  mul_function(&$2.u.constant, &$2.u.constant, &minus_one);  $$ = $2; }
 	|	T_ARRAY '(' static_array_pair_list ')' { $$ = $3; $$.u.constant.type = IS_CONSTANT_ARRAY; }
@@ -536,12 +536,12 @@ static_scalar: /* compile-time evaluated scalars */
 
 
 scalar:
-		T_STRING 				{ zend_do_fetch_constant(&$$, &$1, ZEND_RT CLS_CC); }
+		T_STRING 				{ zend_do_fetch_constant(&$$, &$1, ZEND_RT TSRMLS_CC); }
 	|	T_STRING_VARNAME		{ $$ = $1; }
 	|	common_scalar			{ $$ = $1; }
 	|	'"' encaps_list '"' 	{ $$ = $2; }
 	|	'\'' encaps_list '\''	{ $$ = $2; }
-	|	T_START_HEREDOC encaps_list T_END_HEREDOC { $$ = $2; zend_do_end_heredoc(CLS_C); }
+	|	T_START_HEREDOC encaps_list T_END_HEREDOC { $$ = $2; zend_do_end_heredoc(TSRMLS_C); }
 ;
 
 
@@ -569,36 +569,36 @@ expr:
 
 
 r_cvar:
-	cvar { zend_do_end_variable_parse(BP_VAR_R, 0 CLS_CC); $$ = $1; }
+	cvar { zend_do_end_variable_parse(BP_VAR_R, 0 TSRMLS_CC); $$ = $1; }
 ;
 
 
 w_cvar:
-	cvar { zend_do_end_variable_parse(BP_VAR_W, 0 CLS_CC); $$ = $1; }
+	cvar { zend_do_end_variable_parse(BP_VAR_W, 0 TSRMLS_CC); $$ = $1; }
 ;
 
 
 rw_cvar:
-	cvar { zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); $$ = $1; }
+	cvar { zend_do_end_variable_parse(BP_VAR_RW, 0 TSRMLS_CC); $$ = $1; }
 ;
 
 
 cvar:
 		cvar_without_objects { $$ = $1; }
-	|	cvar_without_objects T_OBJECT_OPERATOR { zend_do_push_object(&$1 CLS_CC); } ref_list { $$ = $4; }
+	|	cvar_without_objects T_OBJECT_OPERATOR { zend_do_push_object(&$1 TSRMLS_CC); } ref_list { $$ = $4; }
 ;
 
 
 cvar_without_objects:
 		reference_variable { $$ = $1; }
-	|	simple_indirect_reference reference_variable { zend_do_indirect_references(&$$, &$1, &$2 CLS_CC); }
+	|	simple_indirect_reference reference_variable { zend_do_indirect_references(&$$, &$1, &$2 TSRMLS_CC); }
 ;
 
 
 reference_variable:
-		reference_variable '[' dim_offset ']'	{ fetch_array_dim(&$$, &$1, &$3 CLS_CC); }
-	|	reference_variable '{' expr '}'		{ fetch_string_offset(&$$, &$1, &$3 CLS_CC); }
-	|	compound_variable			{ zend_do_fetch_globals(&$1 CLS_CC); zend_do_begin_variable_parse(CLS_C); fetch_simple_variable(&$$, &$1, 1 CLS_CC); }
+		reference_variable '[' dim_offset ']'	{ fetch_array_dim(&$$, &$1, &$3 TSRMLS_CC); }
+	|	reference_variable '{' expr '}'		{ fetch_string_offset(&$$, &$1, &$3 TSRMLS_CC); }
+	|	compound_variable			{ zend_do_fetch_globals(&$1 TSRMLS_CC); zend_do_begin_variable_parse(TSRMLS_C); fetch_simple_variable(&$$, &$1, 1 TSRMLS_CC); }
 ;
 	
 
@@ -614,18 +614,18 @@ dim_offset:
 
 ref_list:
 		object_property  { $$ = $1; }
-	|	ref_list T_OBJECT_OPERATOR { zend_do_push_object(&$1 CLS_CC); } object_property { $$ = $4; }
+	|	ref_list T_OBJECT_OPERATOR { zend_do_push_object(&$1 TSRMLS_CC); } object_property { $$ = $4; }
 ;
 
 object_property:
 		object_dim_list { $$ = $1; }
-	|	cvar_without_objects { zend_do_end_variable_parse(BP_VAR_R, 0 CLS_CC); } { znode tmp_znode;  zend_do_pop_object(&tmp_znode CLS_CC);  zend_do_fetch_property(&$$, &tmp_znode, &$1 CLS_CC);}
+	|	cvar_without_objects { zend_do_end_variable_parse(BP_VAR_R, 0 TSRMLS_CC); } { znode tmp_znode;  zend_do_pop_object(&tmp_znode TSRMLS_CC);  zend_do_fetch_property(&$$, &tmp_znode, &$1 TSRMLS_CC);}
 ;
 
 object_dim_list:
-		object_dim_list '[' dim_offset ']'	{ fetch_array_dim(&$$, &$1, &$3 CLS_CC); }
-	|	object_dim_list '{' expr '}'		{ fetch_string_offset(&$$, &$1, &$3 CLS_CC); }
-	|	variable_name { znode tmp_znode;  zend_do_pop_object(&tmp_znode CLS_CC);  zend_do_fetch_property(&$$, &tmp_znode, &$1 CLS_CC);}
+		object_dim_list '[' dim_offset ']'	{ fetch_array_dim(&$$, &$1, &$3 TSRMLS_CC); }
+	|	object_dim_list '{' expr '}'		{ fetch_string_offset(&$$, &$1, &$3 TSRMLS_CC); }
+	|	variable_name { znode tmp_znode;  zend_do_pop_object(&tmp_znode TSRMLS_CC);  zend_do_fetch_property(&$$, &tmp_znode, &$1 TSRMLS_CC);}
 ;
 
 variable_name:
@@ -646,52 +646,52 @@ assignment_list:
 
 
 assignment_list_element:
-		cvar								{ zend_do_add_list_element(&$1 CLS_CC); }
-	|	T_LIST '(' { zend_do_new_list_begin(CLS_C); } assignment_list ')'	{ zend_do_new_list_end(CLS_C); }
-	|	/* empty */							{ zend_do_add_list_element(NULL CLS_CC); }
+		cvar								{ zend_do_add_list_element(&$1 TSRMLS_CC); }
+	|	T_LIST '(' { zend_do_new_list_begin(TSRMLS_C); } assignment_list ')'	{ zend_do_new_list_end(TSRMLS_C); }
+	|	/* empty */							{ zend_do_add_list_element(NULL TSRMLS_CC); }
 ;
 
 
 array_pair_list:
-		/* empty */ { zend_do_init_array(&$$, NULL, NULL, 0 CLS_CC); }
+		/* empty */ { zend_do_init_array(&$$, NULL, NULL, 0 TSRMLS_CC); }
 	|	non_empty_array_pair_list possible_comma	{ $$ = $1; }
 ;
 
 non_empty_array_pair_list:
-		non_empty_array_pair_list ',' expr T_DOUBLE_ARROW expr	{ zend_do_add_array_element(&$$, &$5, &$3, 0 CLS_CC); }
-	|	non_empty_array_pair_list ',' expr			{ zend_do_add_array_element(&$$, &$3, NULL, 0 CLS_CC); }
-	|	expr T_DOUBLE_ARROW expr	{ zend_do_init_array(&$$, &$3, &$1, 0 CLS_CC); }
-	|	expr 				{ zend_do_init_array(&$$, &$1, NULL, 0 CLS_CC); }
-	|	non_empty_array_pair_list ',' expr T_DOUBLE_ARROW '&' w_cvar { zend_do_add_array_element(&$$, &$6, &$3, 1 CLS_CC); }
-	|	non_empty_array_pair_list ',' '&' w_cvar { zend_do_add_array_element(&$$, &$4, NULL, 1 CLS_CC); }
-	|	expr T_DOUBLE_ARROW '&' w_cvar	{ zend_do_init_array(&$$, &$4, &$1, 1 CLS_CC); }
-	|	'&' w_cvar 			{ zend_do_init_array(&$$, &$2, NULL, 1 CLS_CC); }
+		non_empty_array_pair_list ',' expr T_DOUBLE_ARROW expr	{ zend_do_add_array_element(&$$, &$5, &$3, 0 TSRMLS_CC); }
+	|	non_empty_array_pair_list ',' expr			{ zend_do_add_array_element(&$$, &$3, NULL, 0 TSRMLS_CC); }
+	|	expr T_DOUBLE_ARROW expr	{ zend_do_init_array(&$$, &$3, &$1, 0 TSRMLS_CC); }
+	|	expr 				{ zend_do_init_array(&$$, &$1, NULL, 0 TSRMLS_CC); }
+	|	non_empty_array_pair_list ',' expr T_DOUBLE_ARROW '&' w_cvar { zend_do_add_array_element(&$$, &$6, &$3, 1 TSRMLS_CC); }
+	|	non_empty_array_pair_list ',' '&' w_cvar { zend_do_add_array_element(&$$, &$4, NULL, 1 TSRMLS_CC); }
+	|	expr T_DOUBLE_ARROW '&' w_cvar	{ zend_do_init_array(&$$, &$4, &$1, 1 TSRMLS_CC); }
+	|	'&' w_cvar 			{ zend_do_init_array(&$$, &$2, NULL, 1 TSRMLS_CC); }
 ;
 
 encaps_list:
-		encaps_list encaps_var { zend_do_end_variable_parse(BP_VAR_R, 0 CLS_CC);  zend_do_add_variable(&$$, &$1, &$2 CLS_CC); }
-	|	encaps_list T_STRING			{ zend_do_add_string(&$$, &$1, &$2 CLS_CC); }
-	|	encaps_list T_NUM_STRING		{ zend_do_add_string(&$$, &$1, &$2 CLS_CC); }
-	|	encaps_list T_ENCAPSED_AND_WHITESPACE	{ zend_do_add_string(&$$, &$1, &$2 CLS_CC); }
-	|	encaps_list T_CHARACTER 		{ zend_do_add_char(&$$, &$1, &$2 CLS_CC); }
-	|	encaps_list T_BAD_CHARACTER		{ zend_do_add_string(&$$, &$1, &$2 CLS_CC); }
-	|	encaps_list '['		{ $2.u.constant.value.lval = (long) '['; zend_do_add_char(&$$, &$1, &$2 CLS_CC); }
-	|	encaps_list ']'		{ $2.u.constant.value.lval = (long) ']'; zend_do_add_char(&$$, &$1, &$2 CLS_CC); }
-	|	encaps_list '{'		{ $2.u.constant.value.lval = (long) '{'; zend_do_add_char(&$$, &$1, &$2 CLS_CC); }
-	|	encaps_list '}'		{ $2.u.constant.value.lval = (long) '}'; zend_do_add_char(&$$, &$1, &$2 CLS_CC); }
-	|	encaps_list T_OBJECT_OPERATOR  { znode tmp;  $2.u.constant.value.lval = (long) '-';  zend_do_add_char(&tmp, &$1, &$2 CLS_CC);  $2.u.constant.value.lval = (long) '>'; zend_do_add_char(&$$, &tmp, &$2 CLS_CC); }
-	|	/* empty */			{ zend_do_init_string(&$$ CLS_CC); }
+		encaps_list encaps_var { zend_do_end_variable_parse(BP_VAR_R, 0 TSRMLS_CC);  zend_do_add_variable(&$$, &$1, &$2 TSRMLS_CC); }
+	|	encaps_list T_STRING			{ zend_do_add_string(&$$, &$1, &$2 TSRMLS_CC); }
+	|	encaps_list T_NUM_STRING		{ zend_do_add_string(&$$, &$1, &$2 TSRMLS_CC); }
+	|	encaps_list T_ENCAPSED_AND_WHITESPACE	{ zend_do_add_string(&$$, &$1, &$2 TSRMLS_CC); }
+	|	encaps_list T_CHARACTER 		{ zend_do_add_char(&$$, &$1, &$2 TSRMLS_CC); }
+	|	encaps_list T_BAD_CHARACTER		{ zend_do_add_string(&$$, &$1, &$2 TSRMLS_CC); }
+	|	encaps_list '['		{ $2.u.constant.value.lval = (long) '['; zend_do_add_char(&$$, &$1, &$2 TSRMLS_CC); }
+	|	encaps_list ']'		{ $2.u.constant.value.lval = (long) ']'; zend_do_add_char(&$$, &$1, &$2 TSRMLS_CC); }
+	|	encaps_list '{'		{ $2.u.constant.value.lval = (long) '{'; zend_do_add_char(&$$, &$1, &$2 TSRMLS_CC); }
+	|	encaps_list '}'		{ $2.u.constant.value.lval = (long) '}'; zend_do_add_char(&$$, &$1, &$2 TSRMLS_CC); }
+	|	encaps_list T_OBJECT_OPERATOR  { znode tmp;  $2.u.constant.value.lval = (long) '-';  zend_do_add_char(&tmp, &$1, &$2 TSRMLS_CC);  $2.u.constant.value.lval = (long) '>'; zend_do_add_char(&$$, &tmp, &$2 TSRMLS_CC); }
+	|	/* empty */			{ zend_do_init_string(&$$ TSRMLS_CC); }
 
 ;
 
 
 
 encaps_var:
-		T_VARIABLE { zend_do_fetch_globals(&$1 CLS_CC); zend_do_begin_variable_parse(CLS_C); fetch_simple_variable(&$$, &$1, 1 CLS_CC); }
-	|	T_VARIABLE '[' { zend_do_begin_variable_parse(CLS_C); } encaps_var_offset ']'	{ zend_do_fetch_globals(&$1 CLS_CC);  fetch_array_begin(&$$, &$1, &$4 CLS_CC); }
-	|	T_VARIABLE T_OBJECT_OPERATOR T_STRING { zend_do_begin_variable_parse(CLS_C); fetch_simple_variable(&$2, &$1, 1 CLS_CC); zend_do_fetch_property(&$$, &$2, &$3 CLS_CC); }
-	|	T_DOLLAR_OPEN_CURLY_BRACES expr '}' { zend_do_begin_variable_parse(CLS_C);  fetch_simple_variable(&$$, &$2, 1 CLS_CC); }
-	|	T_DOLLAR_OPEN_CURLY_BRACES T_STRING_VARNAME '[' expr ']' '}' { zend_do_begin_variable_parse(CLS_C);  fetch_array_begin(&$$, &$2, &$4 CLS_CC); }
+		T_VARIABLE { zend_do_fetch_globals(&$1 TSRMLS_CC); zend_do_begin_variable_parse(TSRMLS_C); fetch_simple_variable(&$$, &$1, 1 TSRMLS_CC); }
+	|	T_VARIABLE '[' { zend_do_begin_variable_parse(TSRMLS_C); } encaps_var_offset ']'	{ zend_do_fetch_globals(&$1 TSRMLS_CC);  fetch_array_begin(&$$, &$1, &$4 TSRMLS_CC); }
+	|	T_VARIABLE T_OBJECT_OPERATOR T_STRING { zend_do_begin_variable_parse(TSRMLS_C); fetch_simple_variable(&$2, &$1, 1 TSRMLS_CC); zend_do_fetch_property(&$$, &$2, &$3 TSRMLS_CC); }
+	|	T_DOLLAR_OPEN_CURLY_BRACES expr '}' { zend_do_begin_variable_parse(TSRMLS_C);  fetch_simple_variable(&$$, &$2, 1 TSRMLS_CC); }
+	|	T_DOLLAR_OPEN_CURLY_BRACES T_STRING_VARNAME '[' expr ']' '}' { zend_do_begin_variable_parse(TSRMLS_C);  fetch_array_begin(&$$, &$2, &$4 TSRMLS_CC); }
 	|	T_CURLY_OPEN cvar '}' { $$ = $2; }
 ;
 
@@ -699,23 +699,23 @@ encaps_var:
 encaps_var_offset:
 		T_STRING		{ $$ = $1; }
 	|	T_NUM_STRING	{ $$ = $1; }
-	|	T_VARIABLE		{ fetch_simple_variable(&$$, &$1, 1 CLS_CC); }
+	|	T_VARIABLE		{ fetch_simple_variable(&$$, &$1, 1 TSRMLS_CC); }
 ;
 
 
 internal_functions_in_yacc:
 		T_ISSET '(' isset_variables ')' { $$ = $3; }
-	|	T_EMPTY '(' cvar ')'	{ zend_do_isset_or_isempty(ZEND_ISEMPTY, &$$, &$3 CLS_CC); }
-	|	T_INCLUDE expr 			{ zend_do_include_or_eval(ZEND_INCLUDE, &$$, &$2 CLS_CC); }
-	|	T_INCLUDE_ONCE expr 	{ zend_do_include_or_eval(ZEND_INCLUDE_ONCE, &$$, &$2 CLS_CC); }
-	|	T_EVAL '(' expr ')' 	{ zend_do_include_or_eval(ZEND_EVAL, &$$, &$3 CLS_CC); }
-	|	T_REQUIRE expr			{ zend_do_include_or_eval(ZEND_REQUIRE, &$$, &$2 CLS_CC); }
-	|	T_REQUIRE_ONCE expr		{ zend_do_include_or_eval(ZEND_REQUIRE_ONCE, &$$, &$2 CLS_CC); }
+	|	T_EMPTY '(' cvar ')'	{ zend_do_isset_or_isempty(ZEND_ISEMPTY, &$$, &$3 TSRMLS_CC); }
+	|	T_INCLUDE expr 			{ zend_do_include_or_eval(ZEND_INCLUDE, &$$, &$2 TSRMLS_CC); }
+	|	T_INCLUDE_ONCE expr 	{ zend_do_include_or_eval(ZEND_INCLUDE_ONCE, &$$, &$2 TSRMLS_CC); }
+	|	T_EVAL '(' expr ')' 	{ zend_do_include_or_eval(ZEND_EVAL, &$$, &$3 TSRMLS_CC); }
+	|	T_REQUIRE expr			{ zend_do_include_or_eval(ZEND_REQUIRE, &$$, &$2 TSRMLS_CC); }
+	|	T_REQUIRE_ONCE expr		{ zend_do_include_or_eval(ZEND_REQUIRE_ONCE, &$$, &$2 TSRMLS_CC); }
 ;
 
 isset_variables:
-		cvar 				{ zend_do_isset_or_isempty(ZEND_ISSET, &$$, &$1 CLS_CC); }
-	|	isset_variables ',' { zend_do_boolean_and_begin(&$1, &$2 CLS_CC); } cvar { znode tmp; zend_do_isset_or_isempty(ZEND_ISSET, &tmp, &$4 CLS_CC); zend_do_boolean_and_end(&$$, &$1, &tmp, &$2 CLS_CC); }
+		cvar 				{ zend_do_isset_or_isempty(ZEND_ISSET, &$$, &$1 TSRMLS_CC); }
+	|	isset_variables ',' { zend_do_boolean_and_begin(&$1, &$2 TSRMLS_CC); } cvar { znode tmp; zend_do_isset_or_isempty(ZEND_ISSET, &tmp, &$4 TSRMLS_CC); zend_do_boolean_and_end(&$$, &$1, &tmp, &$2 TSRMLS_CC); }
 ;	
 
 %%
diff --git a/Zend/zend_language_scanner.h b/Zend/zend_language_scanner.h
index 66a0e5962c..f3b478d06b 100644
--- a/Zend/zend_language_scanner.h
+++ b/Zend/zend_language_scanner.h
@@ -26,7 +26,7 @@ class ZendFlexLexer : public yyFlexLexer
 {
 public:
 	virtual ~ZendFlexLexer();
-	int lex_scan(zval *zendlval CLS_DC);
+	int lex_scan(zval *zendlval TSRMLS_DC);
 	void BeginState(int state);
 };
 
diff --git a/Zend/zend_language_scanner.l b/Zend/zend_language_scanner.l
index 94cf3952e4..3e124adeff 100644
--- a/Zend/zend_language_scanner.l
+++ b/Zend/zend_language_scanner.l
@@ -73,9 +73,9 @@
 #endif
 
 #ifdef ZTS
-#define YY_DECL int ZendFlexLexer::lex_scan(zval *zendlval CLS_DC)
+#define YY_DECL int ZendFlexLexer::lex_scan(zval *zendlval TSRMLS_DC)
 #else
-#define YY_DECL int lex_scan(zval *zendlval CLS_DC)
+#define YY_DECL int lex_scan(zval *zendlval TSRMLS_DC)
 #endif
 
 #define YY_INTERACTIVE
@@ -124,14 +124,14 @@ void zend_fatal_scanner_error(char *message)
 }
 
 BEGIN_EXTERN_C()
-void startup_scanner(CLS_D)
+void startup_scanner(TSRMLS_D)
 {
 	CG(heredoc) = NULL;
 	CG(heredoc_len)=0;
 }
 
 
-void shutdown_scanner(CLS_D)
+void shutdown_scanner(TSRMLS_D)
 {
 	if (CG(heredoc)) {
 		efree(CG(heredoc));
@@ -141,7 +141,7 @@ void shutdown_scanner(CLS_D)
 END_EXTERN_C()
 
 
-static inline void save_lexical_state(zend_lex_state *lex_state CLS_DC)
+static inline void save_lexical_state(zend_lex_state *lex_state TSRMLS_DC)
 {
 #ifndef ZTS
 	memcpy(&lex_state->buffer_state,&YY_CURRENT_BUFFER,sizeof(YY_BUFFER_STATE));
@@ -150,12 +150,12 @@ static inline void save_lexical_state(zend_lex_state *lex_state CLS_DC)
 #else
 	lex_state->ZFL = CG(ZFL);
 #endif
-	lex_state->filename = zend_get_compiled_filename(CLS_C);
+	lex_state->filename = zend_get_compiled_filename(TSRMLS_C);
 	lex_state->lineno = CG(zend_lineno);
 }
 
 
-static inline void restore_lexical_state(zend_lex_state *lex_state CLS_DC)
+static inline void restore_lexical_state(zend_lex_state *lex_state TSRMLS_DC)
 {
 #ifndef ZTS
 	YY_BUFFER_STATE original_buffer_state = YY_CURRENT_BUFFER;
@@ -233,13 +233,13 @@ int zend_compare_file_handles(zend_file_handle *fh1, zend_file_handle *fh2)
 }
 
 
-ZEND_API void zend_destroy_file_handle(zend_file_handle *file_handle CLS_DC)
+ZEND_API void zend_destroy_file_handle(zend_file_handle *file_handle TSRMLS_DC)
 {
 	zend_llist_del_element(&CG(open_files), file_handle, (int (*)(void *, void *)) zend_compare_file_handles);
 }
 
 
-ZEND_API int open_file_for_scanning(zend_file_handle *file_handle CLS_DC)
+ZEND_API int open_file_for_scanning(zend_file_handle *file_handle TSRMLS_DC)
 {
 	char *file_path=NULL;
 
@@ -321,7 +321,7 @@ ZEND_API int open_file_for_scanning(zend_file_handle *file_handle CLS_DC)
 END_EXTERN_C()
 
 
-ZEND_API zend_op_array *compile_file(zend_file_handle *file_handle, int type CLS_DC)
+ZEND_API zend_op_array *compile_file(zend_file_handle *file_handle, int type TSRMLS_DC)
 {
 	zend_lex_state original_lex_state;
 	zend_op_array *op_array = (zend_op_array *) emalloc(sizeof(zend_op_array));
@@ -338,11 +338,11 @@ ZEND_API zend_op_array *compile_file(zend_file_handle *file_handle, int type CLS
 	retval_znode.u.constant.is_ref = 0;
 	retval_znode.u.constant.refcount = 1;
 
-	save_lexical_state(&original_lex_state CLS_CC);
+	save_lexical_state(&original_lex_state TSRMLS_CC);
 
 	retval = op_array; /* success oriented */
 
-	if (open_file_for_scanning(file_handle CLS_CC)==FAILURE) {
+	if (open_file_for_scanning(file_handle TSRMLS_CC)==FAILURE) {
 		if (type==ZEND_REQUIRE) {
 			zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, file_handle->filename);
 			zend_bailout();		
@@ -351,11 +351,11 @@ ZEND_API zend_op_array *compile_file(zend_file_handle *file_handle, int type CLS
 		}
 		compilation_successful=0;
 	} else {
-		init_op_array(op_array, ZEND_USER_FUNCTION, INITIAL_OP_ARRAY_SIZE CLS_CC);
+		init_op_array(op_array, ZEND_USER_FUNCTION, INITIAL_OP_ARRAY_SIZE TSRMLS_CC);
 		CG(in_compilation) = 1;
 		CG(active_op_array) = op_array;
-		compiler_result = zendparse(CLS_C);
-		zend_do_return(&retval_znode, 0 CLS_CC);
+		compiler_result = zendparse(TSRMLS_C);
+		zend_do_return(&retval_znode, 0 TSRMLS_CC);
 		CG(in_compilation) = original_in_compilation;
 		if (compiler_result==1) { /* parser error */
 			CG(unclean_shutdown) = 1;
@@ -374,13 +374,13 @@ ZEND_API zend_op_array *compile_file(zend_file_handle *file_handle, int type CLS
 		}
 	}
 	if (compilation_successful) {
-		restore_lexical_state(&original_lex_state CLS_CC);
+		restore_lexical_state(&original_lex_state TSRMLS_CC);
 	}
 	return retval;
 }
 
 
-zend_op_array *compile_filename(int type, zval *filename CLS_DC TSRMLS_DC)
+zend_op_array *compile_filename(int type, zval *filename TSRMLS_DC)
 {
 	zend_file_handle file_handle;
 	zval tmp;
@@ -398,12 +398,12 @@ zend_op_array *compile_filename(int type, zval *filename CLS_DC TSRMLS_DC)
 	file_handle.opened_path = NULL;
 
 
-	retval = zend_compile_file(&file_handle, type CLS_CC);
+	retval = zend_compile_file(&file_handle, type TSRMLS_CC);
 	if (retval && file_handle.opened_path) {
 		int dummy = 1;
 		zend_hash_add(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)+1, (void *)&dummy, sizeof(int), NULL);
 	}
-	zend_destroy_file_handle(&file_handle CLS_CC);
+	zend_destroy_file_handle(&file_handle TSRMLS_CC);
 
 	if (filename==&tmp) {
 		zval_dtor(&tmp);
@@ -414,7 +414,7 @@ zend_op_array *compile_filename(int type, zval *filename CLS_DC TSRMLS_DC)
 #ifndef ZTS
 static inline int prepare_string_for_scanning(zval *str, char *filename)
 #else
-static inline int prepare_string_for_scanning(zval *str, istrstream **input_stream, char *filename CLS_DC)
+static inline int prepare_string_for_scanning(zval *str, istrstream **input_stream, char *filename TSRMLS_DC)
 #endif
 {
 #ifndef ZTS
@@ -437,7 +437,7 @@ static inline int prepare_string_for_scanning(zval *str, istrstream **input_stre
 }
 
 
-zend_op_array *compile_string(zval *source_string, char *filename CLS_DC)
+zend_op_array *compile_string(zval *source_string, char *filename TSRMLS_DC)
 {
 	zend_lex_state original_lex_state;
 	zend_op_array *op_array = (zend_op_array *) emalloc(sizeof(zend_op_array));
@@ -462,35 +462,35 @@ zend_op_array *compile_string(zval *source_string, char *filename CLS_DC)
 	convert_to_string(&tmp);
 	source_string = &tmp;
 
-	save_lexical_state(&original_lex_state CLS_CC);
+	save_lexical_state(&original_lex_state TSRMLS_CC);
 #ifndef ZTS
 	if (prepare_string_for_scanning(source_string, filename)==FAILURE) {
 #else
-	if (prepare_string_for_scanning(source_string, &input_stream, filename CLS_CC)==FAILURE) {
+	if (prepare_string_for_scanning(source_string, &input_stream, filename TSRMLS_CC)==FAILURE) {
 #endif
 		efree(op_array);
 		retval = NULL;
 	} else {
-		init_op_array(op_array, ZEND_EVAL_CODE, INITIAL_OP_ARRAY_SIZE CLS_CC);
+		init_op_array(op_array, ZEND_EVAL_CODE, INITIAL_OP_ARRAY_SIZE TSRMLS_CC);
 		CG(active_op_array) = op_array;
 #ifndef ZTS
 		BEGIN(ST_IN_SCRIPTING);
 #else
 		CG(ZFL)->BeginState(ST_IN_SCRIPTING);
 #endif
-		compiler_result = zendparse(CLS_C);
+		compiler_result = zendparse(TSRMLS_C);
 		
 		if (compiler_result==1) {
 			CG(active_op_array) = original_active_op_array;
 			CG(unclean_shutdown)=1;
 			retval = NULL;
 		} else {
-			zend_do_return(NULL, 0 CLS_CC);
+			zend_do_return(NULL, 0 TSRMLS_CC);
 			CG(active_op_array) = original_active_op_array;
 			pass_two(op_array);
 			retval = op_array;
 		}
-		restore_lexical_state(&original_lex_state CLS_CC);
+		restore_lexical_state(&original_lex_state TSRMLS_CC);
 	}
 #ifdef ZTS
 	delete input_stream;
@@ -506,20 +506,20 @@ int highlight_file(char *filename, zend_syntax_highlighter_ini *syntax_highlight
 {
 	zend_lex_state original_lex_state;
 	zend_file_handle file_handle;
-	CLS_FETCH();
+	TSRMLS_FETCH();
 
 	file_handle.type = ZEND_HANDLE_FILENAME;
 	file_handle.filename = filename;
 	file_handle.free_filename = 0;
 	file_handle.opened_path = NULL;
-	save_lexical_state(&original_lex_state CLS_CC);
-	if (open_file_for_scanning(&file_handle CLS_CC)==FAILURE) {
+	save_lexical_state(&original_lex_state TSRMLS_CC);
+	if (open_file_for_scanning(&file_handle TSRMLS_CC)==FAILURE) {
 		zend_message_dispatcher(ZMSG_FAILED_HIGHLIGHT_FOPEN, filename);
 		return FAILURE;
 	}
 	zend_highlight(syntax_highlighter_ini);
-	zend_destroy_file_handle(&file_handle CLS_CC);
-	restore_lexical_state(&original_lex_state CLS_CC);
+	zend_destroy_file_handle(&file_handle TSRMLS_CC);
+	restore_lexical_state(&original_lex_state TSRMLS_CC);
 	return SUCCESS;
 }
 
@@ -530,20 +530,20 @@ int highlight_string(zval *str, zend_syntax_highlighter_ini *syntax_highlighter_
 #ifdef ZTS
 	istrstream *input_stream;
 #endif
-	CLS_FETCH();
+	TSRMLS_FETCH();
 
 	str = &tmp;
 	zval_copy_ctor(str);
-	save_lexical_state(&original_lex_state CLS_CC);
+	save_lexical_state(&original_lex_state TSRMLS_CC);
 #ifndef ZTS
 	if (prepare_string_for_scanning(str, str_name)==FAILURE) {
 #else
-	if (prepare_string_for_scanning(str, &input_stream, str_name CLS_CC)==FAILURE) {
+	if (prepare_string_for_scanning(str, &input_stream, str_name TSRMLS_CC)==FAILURE) {
 #endif
 		return FAILURE;
 	}
 	zend_highlight(syntax_highlighter_ini);
-	restore_lexical_state(&original_lex_state CLS_CC);
+	restore_lexical_state(&original_lex_state TSRMLS_CC);
 #ifdef ZTS
 	delete input_stream;
 #endif
@@ -554,19 +554,19 @@ END_EXTERN_C()
 
 #ifdef ZTS
 BEGIN_EXTERN_C()
-int lex_scan(zval *zendlval CLS_DC)
+int lex_scan(zval *zendlval TSRMLS_DC)
 {
-	return CG(ZFL)->lex_scan(zendlval CLS_CC);
+	return CG(ZFL)->lex_scan(zendlval TSRMLS_CC);
 }
 
 
-const char *zend_get_zendtext(CLS_D)
+const char *zend_get_zendtext(TSRMLS_D)
 {
 	return CG(ZFL)->YYText();
 }
 
 
-int zend_get_zendleng(CLS_D)
+int zend_get_zendleng(TSRMLS_D)
 {
 	return CG(ZFL)->YYLeng();
 }
@@ -1048,7 +1048,7 @@ NEWLINE ("\r"|"\n"|"\r\n")
 }
 
 <ST_IN_SCRIPTING>"__FILE__" {
-	char *filename = zend_get_compiled_filename(CLS_C);
+	char *filename = zend_get_compiled_filename(TSRMLS_C);
 	
 	if (!filename) {
 		filename = "";
diff --git a/Zend/zend_opcode.c b/Zend/zend_opcode.c
index d454b5c3ae..122cab58de 100644
--- a/Zend/zend_opcode.c
+++ b/Zend/zend_opcode.c
@@ -50,7 +50,7 @@ static void op_array_alloc_ops(zend_op_array *op_array)
 
 
 
-void init_op_array(zend_op_array *op_array, int type, int initial_ops_size CLS_DC)
+void init_op_array(zend_op_array *op_array, int type, int initial_ops_size TSRMLS_DC)
 {
 	op_array->type = type;
 
@@ -72,7 +72,7 @@ void init_op_array(zend_op_array *op_array, int type, int initial_ops_size CLS_D
 	op_array->T = 0;
 
 	op_array->function_name = NULL;
-	op_array->filename = zend_get_compiled_filename(CLS_C);
+	op_array->filename = zend_get_compiled_filename(TSRMLS_C);
 
 	op_array->arg_types = NULL;
 
@@ -181,7 +181,7 @@ ZEND_API void destroy_op_array(zend_op_array *op_array)
 }
 
 
-void init_op(zend_op *op CLS_DC)
+void init_op(zend_op *op TSRMLS_DC)
 {
 	memset(&op->result, 0, sizeof(znode));
 	op->lineno = CG(zend_lineno);
@@ -191,7 +191,7 @@ void init_op(zend_op *op CLS_DC)
 	memset(&op->op2, 0, sizeof(znode));
 }
 
-zend_op *get_next_op(zend_op_array *op_array CLS_DC)
+zend_op *get_next_op(zend_op_array *op_array TSRMLS_DC)
 {
 	zend_uint next_op_num = op_array->last++;
 	zend_op *next_op;
@@ -209,7 +209,7 @@ zend_op *get_next_op(zend_op_array *op_array CLS_DC)
 	
 	next_op = &(op_array->opcodes[next_op_num]);
 	
-	init_op(next_op CLS_CC);
+	init_op(next_op TSRMLS_CC);
 
 	return next_op;
 }
@@ -231,7 +231,7 @@ zend_brk_cont_element *get_next_brk_cont_element(zend_op_array *op_array)
 }
 
 
-static void zend_update_extended_info(zend_op_array *op_array CLS_DC)
+static void zend_update_extended_info(zend_op_array *op_array TSRMLS_DC)
 {
 	zend_op *opline = op_array->opcodes, *end=opline+op_array->last;
 
@@ -267,13 +267,13 @@ static void zend_extension_op_array_handler(zend_extension *extension, zend_op_a
 int pass_two(zend_op_array *op_array)
 {
 	zend_op *opline, *end;
-	CLS_FETCH();
+	TSRMLS_FETCH();
 
 	if (op_array->type!=ZEND_USER_FUNCTION && op_array->type!=ZEND_EVAL_CODE) {
 		return 0;
 	}
 	if (CG(extended_info)) {
-		zend_update_extended_info(op_array CLS_CC);
+		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);