Thread safety patch. We're still not quite there but it compiles again, and

more logic has been implemented.

diff --git a/Zend/zend-parser.y b/Zend/zend-parser.y
index 520e2227786f70960556fe396300c3b5ae88cc72..5ebe55d12b1d2b993ccc30e547a8cb8fb047e804 100644 (file)
--- a/Zend/zend-parser.y
+++ b/Zend/zend-parser.y
@@ -128,7 +128,7 @@
 %% /* Rules */
 
 statement_list:        
-               statement_list  { do_extended_info(CLS_C); } statement { HANDLE_INTERACTIVE(); }
+               statement_list  { do_extended_info(CLS_C); } statement { ELS_FETCH(); HANDLE_INTERACTIVE(); }
        |       /* empty */
 ;
 
@@ -169,7 +169,7 @@ statement:
        |       REQUIRE CONSTANT_ENCAPSED_STRING ';'                    { require_filename($2.u.constant.value.str.val CLS_CC); zval_dtor(&$2.u.constant); }
        |       REQUIRE '(' CONSTANT_ENCAPSED_STRING ')' ';'    { require_filename($3.u.constant.value.str.val CLS_CC); zval_dtor(&$3.u.constant); }
        |       ZEND_UNSET '(' r_cvar ')' ';' { do_unset(&$3 CLS_CC); }
-       |       ZEND_FOREACH '(' expr ZEND_AS { do_foreach_begin(&$1, &$3, &$2, &$4); } w_cvar foreach_optional_arg ')' { do_foreach_cont(&$6, &$7, &$4 CLS_CC); } foreach_statement { do_foreach_end(&$1, &$2 CLS_CC); }
+       |       ZEND_FOREACH '(' expr ZEND_AS { do_foreach_begin(&$1, &$3, &$2, &$4 CLS_CC); } w_cvar foreach_optional_arg ')' { do_foreach_cont(&$6, &$7, &$4 CLS_CC); } foreach_statement { do_foreach_end(&$1, &$2 CLS_CC); }
        |       ';'             /* empty statement */
 ;
 
@@ -511,7 +511,7 @@ cvar_without_objects:
 
 reference_variable:
                dim_list ']' { $$ = $1; }
-       |       compound_variable               { do_fetch_globals(&$1); do_begin_variable_parse(CLS_C); fetch_simple_variable(&$$, &$1, 1 CLS_CC); }
+       |       compound_variable               { do_fetch_globals(&$1 CLS_CC); do_begin_variable_parse(CLS_C); fetch_simple_variable(&$$, &$1, 1 CLS_CC); }
 ;
        
 
@@ -523,7 +523,7 @@ compound_variable:
 
 dim_list:
                dim_list ']' '[' dim_offset     { fetch_array_dim(&$$, &$1, &$4 CLS_CC); }
-       |       compound_variable  { do_fetch_globals(&$1); do_begin_variable_parse(CLS_C); } '[' dim_offset            { fetch_array_begin(&$$, &$1, &$4 CLS_CC); }
+       |       compound_variable  { do_fetch_globals(&$1 CLS_CC); do_begin_variable_parse(CLS_C); } '[' dim_offset             { fetch_array_begin(&$$, &$1, &$4 CLS_CC); }
 ;
 
 
@@ -599,15 +599,15 @@ encaps_list:
        |       encaps_list '{'         { $2.u.constant.value.chval = '{'; do_add_char(&$$, &$1, &$2 CLS_CC); }
        |       encaps_list '}'         { $2.u.constant.value.chval = '}'; do_add_char(&$$, &$1, &$2 CLS_CC); }
        |       encaps_list ZEND_OBJECT_OPERATOR  { znode tmp;  $2.u.constant.value.chval = '-';  do_add_char(&tmp, &$1, &$2 CLS_CC);  $2.u.constant.value.chval = '>'; do_add_char(&$$, &tmp, &$2 CLS_CC); }
-       |       /* empty */                     { do_init_string(&$$); }
+       |       /* empty */                     { do_init_string(&$$ CLS_CC); }
 
 ;
 
 
 
 encaps_var:
-               VARIABLE { do_fetch_globals(&$1); do_begin_variable_parse(CLS_C); fetch_simple_variable(&$$, &$1, 1 CLS_CC); }
-       |       VARIABLE '[' { do_begin_variable_parse(CLS_C); } encaps_var_offset ']'  { do_fetch_globals(&$1);  fetch_array_begin(&$$, &$1, &$4 CLS_CC); }
+               VARIABLE { do_fetch_globals(&$1 CLS_CC); do_begin_variable_parse(CLS_C); fetch_simple_variable(&$$, &$1, 1 CLS_CC); }
+       |       VARIABLE '[' { do_begin_variable_parse(CLS_C); } encaps_var_offset ']'  { do_fetch_globals(&$1 CLS_CC);  fetch_array_begin(&$$, &$1, &$4 CLS_CC); }
        |       VARIABLE ZEND_OBJECT_OPERATOR STRING { do_begin_variable_parse(CLS_C); fetch_simple_variable(&$2, &$1, 1 CLS_CC); do_fetch_property(&$$, &$2, &$3 CLS_CC); }
        |       DOLLAR_OPEN_CURLY_BRACES expr '}' { do_begin_variable_parse(CLS_C);  fetch_simple_variable(&$$, &$2, 1 CLS_CC); }
        |       DOLLAR_OPEN_CURLY_BRACES STRING '[' expr ']' '}' { do_begin_variable_parse(CLS_C);  fetch_array_begin(&$$, &$2, &$4 CLS_CC); }

diff --git a/Zend/zend-scanner.l b/Zend/zend-scanner.l
index 279c94da42ce3ff42b271fe397f749f78479b400..563807f4b047662413e1f3413759f3a32ab9ff96 100644 (file)
--- a/Zend/zend-scanner.l
+++ b/Zend/zend-scanner.l
@@ -171,19 +171,19 @@ inline int open_file_for_scanning(zend_file_handle *file_handle CLS_DC)
 
 
 
-ZEND_API zend_op_array *compile_files(int mark_as_ref ELS_DC, int file_count, ...)
+ZEND_API zend_op_array *compile_files(int mark_as_ref CLS_DC, int file_count, ...)
 {
        va_list files;
        zend_op_array *op_array;
 
        va_start(files, file_count);
-       op_array = v_compile_files(mark_as_ref ELS_CC, file_count, files);
+       op_array = v_compile_files(mark_as_ref CLS_CC, file_count, files);
        va_end(files);
        return op_array;
 }
 
 
-ZEND_API zend_op_array *v_compile_files(int mark_as_ref ELS_DC, int file_count, va_list files)
+ZEND_API zend_op_array *v_compile_files(int mark_as_ref CLS_DC, int file_count, va_list files)
 {
        zend_lex_state original_lex_state;
        zend_op_array *op_array = (zend_op_array *) emalloc(sizeof(zend_op_array));

diff --git a/Zend/zend.c b/Zend/zend.c
index df5f38ce2c6a438ba376ce29ee17cd34f3ef4af1..1103983e24d07d0d796b7ae29103fbab40c0ad1c 100644 (file)
--- a/Zend/zend.c
+++ b/Zend/zend.c
@@ -23,6 +23,14 @@
 #include "zend_constants.h"
 #include "zend_list.h"
 
+#ifdef ZTS
+#      define GLOBAL_FUNCTION_TABLE    global_function_table
+#      define GLOBAL_CLASS_TABLE               global_class_table
+#else
+#      define GLOBAL_FUNCTION_TABLE    CG(function_table)
+#      define GLOBAL_CLASS_TABLE               CG(class_table)
+#endif
+
 /* true multithread-shared globals */
 zend_class_entry standard_class;
 ZEND_API int (*zend_printf)(const char *format, ...);
@@ -32,6 +40,13 @@ void (*zend_message_dispatcher)(long message, void *data);
 FILE *(*zend_fopen)(const char *filename);
 void (*zend_block_interruptions)();
 void (*zend_unblock_interruptions)();
+#ifdef ZTS
+int compiler_globals_id;
+int executor_globals_id;
+int alloc_globals_id;
+HashTable *global_function_table;
+HashTable *global_class_table;
+#endif
 
 zend_utility_values zend_uv;
 
@@ -81,6 +96,7 @@ static void print_hash(HashTable *ht, int indent)
        ZEND_PUTS(")\n");
 }
 
+
 ZEND_API int zend_print_zval(zval *expr, int indent)
 {
        zval expr_copy;
@@ -145,6 +161,8 @@ static FILE *zend_fopen_wrapper(const char *filename)
 
 static void register_standard_class()
 {
+       CLS_FETCH();
+
        standard_class.type = ZEND_INTERNAL_CLASS;
        standard_class.name_length = sizeof("stdClass") - 1;
        standard_class.name = zend_strndup("stdClass", standard_class.name_length);
@@ -156,10 +174,33 @@ static void register_standard_class()
        standard_class.handle_property_set = NULL;
        standard_class.refcount = (int *) malloc(sizeof(int));
        *standard_class.refcount = 1;
-       zend_hash_add(CG(class_table), "stdClass", sizeof("stdClass"), &standard_class, sizeof(zend_class_entry), NULL);
+       zend_hash_add(GLOBAL_CLASS_TABLE, "stdClass", sizeof("stdClass"), &standard_class, sizeof(zend_class_entry), NULL);
 }
 
 
+#ifdef ZTS
+static void compiler_globals_ctor(zend_compiler_globals *compiler_globals)
+{
+       compiler_globals->function_table = (HashTable *) malloc(sizeof(HashTable));
+       zend_hash_init(compiler_globals->function_table, 100, NULL, (void (*)(void *)) destroy_zend_function, 1);
+       zend_hash_copy(compiler_globals->function_table, global_function_table, NULL, NULL, 0);
+
+       compiler_globals->class_table = (HashTable *) malloc(sizeof(HashTable));
+       zend_hash_init(compiler_globals->class_table, 10, NULL, (void (*)(void *)) destroy_zend_class, 1);
+       zend_hash_copy(compiler_globals->class_table, global_class_table, NULL, NULL, 0);
+}
+
+
+static void compiler_globals_dtor(zend_compiler_globals *compiler_globals)
+{
+       zend_hash_destroy(compiler_globals->function_table);
+       free(compiler_globals->function_table);
+       zend_hash_destroy(compiler_globals->class_table);
+       free(compiler_globals->class_table);
+}
+#endif
+
+
 int zend_startup(zend_utility_functions *utility_functions, char **extensions)
 {
        start_memory_manager();
@@ -185,16 +226,25 @@ int zend_startup(zend_utility_functions *utility_functions, char **extensions)
        zend_version_info_length = sizeof(ZEND_CORE_VERSION_INFO)-1;
 
        /* Prepare data structures */
+#ifndef ZTS
        zend_startup_constants();
-       CG(function_table) = (HashTable *) malloc(sizeof(HashTable));
-       CG(class_table) = (HashTable *) malloc(sizeof(HashTable));
-       zend_hash_init(CG(function_table), 100, NULL, (void (*)(void *)) destroy_zend_function, 1);
-       zend_hash_init(CG(class_table), 10, NULL, (void (*)(void *)) destroy_zend_class, 1);
+#endif
+       GLOBAL_FUNCTION_TABLE = (HashTable *) malloc(sizeof(HashTable));
+       GLOBAL_CLASS_TABLE = (HashTable *) malloc(sizeof(HashTable));
+       zend_hash_init(GLOBAL_FUNCTION_TABLE, 100, NULL, (void (*)(void *)) destroy_zend_function, 1);
+       zend_hash_init(GLOBAL_CLASS_TABLE, 10, NULL, (void (*)(void *)) destroy_zend_class, 1);
        register_standard_class();
        zend_hash_init(&module_registry, 50, NULL, (void (*)(void *)) module_destructor, 1);
        init_resource_plist();
        zend_hash_init(&list_destructors, 50, NULL, NULL, 1);
 
+#ifdef ZTS
+       tsrm_startup(1,1,0);
+       compiler_globals_id = ts_allocate_id(sizeof(zend_compiler_globals), (void (*)(void *)) compiler_globals_ctor, (void (*)(void *)) compiler_globals_dtor);
+       executor_globals_id = ts_allocate_id(sizeof(zend_executor_globals), NULL, NULL);
+       alloc_globals_id = ts_allocate_id(sizeof(zend_alloc_globals), NULL, NULL);
+#endif
+
        return SUCCESS;
 }
 
@@ -204,13 +254,15 @@ void zend_shutdown()
        destroy_resource_plist();
        zend_hash_destroy(&list_destructors);
        zend_hash_destroy(&module_registry);
-       zend_hash_destroy(CG(function_table));
-       free(CG(function_table));
-       zend_hash_destroy(CG(class_table));
-       free(CG(class_table));
+       zend_hash_destroy(GLOBAL_FUNCTION_TABLE);
+       free(GLOBAL_FUNCTION_TABLE);
+       zend_hash_destroy(GLOBAL_CLASS_TABLE);
+       free(GLOBAL_CLASS_TABLE);
        zend_shutdown_extensions();
        free(zend_version_info);
+#ifndef ZTS
        zend_shutdown_constants();
+#endif
 }
 
 

diff --git a/Zend/zend_API.c b/Zend/zend_API.c
index f16fd716517ad38dbb637f7b052dbd6826538baf..dabda17c145eb5d3c1cabc6b1cce9920f4f4cb25 100644 (file)
--- a/Zend/zend_API.c
+++ b/Zend/zend_API.c
@@ -33,11 +33,15 @@ HashTable list_destructors, module_registry;
 /* this function doesn't check for too many parameters */
 ZEND_API int getParameters(int ht, int param_count,...)
 {
-       void **p = EG(argument_stack).top_element-1;
-       int arg_count = (ulong) *p;
+       void **p;
+       int arg_count;
        va_list ptr;
        zval **param, *param_ptr;
        ELS_FETCH();
+       ALS_FETCH();
+
+       p = EG(argument_stack).top_element-1;
+       arg_count = (ulong) *p;
 
        if (param_count>arg_count) {
                return FAILURE;
@@ -71,11 +75,14 @@ ZEND_API int getParameters(int ht, int param_count,...)
 
 ZEND_API int getParametersArray(int ht, int param_count, zval **argument_array)
 {
-       void **p = EG(argument_stack).top_element-1;
-       int arg_count = (ulong) *p;
+       void **p;
+       int arg_count;
        zval *param_ptr;
        ELS_FETCH();
 
+       p = EG(argument_stack).top_element-1;
+       arg_count = (ulong) *p;
+
        if (param_count>arg_count) {
                return FAILURE;
        }
@@ -109,12 +116,15 @@ ZEND_API int getParametersArray(int ht, int param_count, zval **argument_array)
 /* this function doesn't check for too many parameters */
 ZEND_API int getParametersEx(int param_count,...)
 {
-       void **p = EG(argument_stack).top_element-1;
-       int arg_count = (ulong) *p;
+       void **p;
+       int arg_count;
        va_list ptr;
        zval ***param;
        ELS_FETCH();
 
+       p = EG(argument_stack).top_element-1;
+       arg_count = (ulong) *p;
+
        if (param_count>arg_count) {
                return FAILURE;
        }
@@ -132,10 +142,13 @@ ZEND_API int getParametersEx(int param_count,...)
 
 ZEND_API int getParametersArrayEx(int param_count, zval ***argument_array)
 {
-       void **p = EG(argument_stack).top_element-1;
-       int arg_count = (ulong) *p;
+       void **p;
+       int arg_count;
        ELS_FETCH();
 
+       p = EG(argument_stack).top_element-1;
+       arg_count = (ulong) *p;
+
        if (param_count>arg_count) {
                return FAILURE;
        }
@@ -166,11 +179,14 @@ ZEND_API int getThis(zval **this)
 
 ZEND_API int ParameterPassedByReference(int ht, uint n)
 {
-       void **p = EG(argument_stack).elements+EG(argument_stack).top-1;
-       ulong arg_count = (ulong) *p;
+       void **p;
+       ulong arg_count;
        zval *arg;
        ELS_FETCH();
 
+       p = EG(argument_stack).elements+EG(argument_stack).top-1;
+       arg_count = (ulong) *p;
+
        if (n>arg_count) {
                return FAILURE;
        }
@@ -566,7 +582,7 @@ int zend_startup_module(zend_module_entry *module)
                        }
                }
                module->type = MODULE_PERSISTENT;
-               register_module(module);
+               zend_register_module(module);
        }
        return SUCCESS;
 }
@@ -593,7 +609,7 @@ ZEND_API int _register_list_destructors(void (*list_destructor)(void *), void (*
 
 
 /* registers all functions in *library_functions in the function hash */
-int register_functions(zend_function_entry *functions)
+int zend_register_functions(zend_function_entry *functions)
 {
        zend_function_entry *ptr = functions;
        zend_internal_function internal_function;
@@ -608,7 +624,7 @@ int register_functions(zend_function_entry *functions)
                internal_function.function_name = ptr->fname;
                if (!internal_function.handler) {
                        zend_error(E_CORE_WARNING,"Null function defined as active function");
-                       unregister_functions(functions,count);
+                       zend_unregister_functions(functions,count);
                        return FAILURE;
                }
                if (zend_hash_add(CG(function_table), ptr->fname, strlen(ptr->fname)+1, &internal_function, sizeof(zend_internal_function), NULL) == FAILURE) {
@@ -625,7 +641,7 @@ int register_functions(zend_function_entry *functions)
                        }
                        ptr++;
                }
-               unregister_functions(functions,count);
+               zend_unregister_functions(functions,count);
                return FAILURE;
        }
        return SUCCESS;
@@ -634,7 +650,7 @@ int register_functions(zend_function_entry *functions)
 /* count=-1 means erase all functions, otherwise, 
  * erase the first count functions
  */
-void unregister_functions(zend_function_entry *functions,int count)
+void zend_unregister_functions(zend_function_entry *functions,int count)
 {
        zend_function_entry *ptr = functions;
        int i=0;
@@ -654,12 +670,12 @@ void unregister_functions(zend_function_entry *functions,int count)
 }
 
 
-ZEND_API int register_module(zend_module_entry *module)
+ZEND_API int zend_register_module(zend_module_entry *module)
 {
 #if 0
        zend_printf("%s:  Registering module %d\n",module->name, module->module_number);
 #endif
-       if (register_functions(module->functions)==FAILURE) {
+       if (zend_register_functions(module->functions)==FAILURE) {
                zend_error(E_CORE_WARNING,"%s:  Unable to register functions, unable to load",module->name);
                return FAILURE;
        }
@@ -689,7 +705,7 @@ void module_destructor(zend_module_entry *module)
                module->module_shutdown_func(module->type, module->module_number);
        }
        module->module_started=0;
-       unregister_functions(module->functions,-1);
+       zend_unregister_functions(module->functions,-1);
 
 #if HAVE_LIBDL
        if (module->handle) {

diff --git a/Zend/zend_API.h b/Zend/zend_API.h
index ffed84be10399a8e0dd05688b3d1d190977a4f83..4e264ae96773ec9276e39034f6513a792cfa39e9 100644 (file)
--- a/Zend/zend_API.h
+++ b/Zend/zend_API.h
@@ -38,9 +38,9 @@ ZEND_API int getParametersArrayEx(int param_count, zval ***argument_array);
 ZEND_API int getThis(zval **this);
 ZEND_API int ParameterPassedByReference(int ht, uint n);
 
-int register_functions(zend_function_entry *functions);
-void unregister_functions(zend_function_entry *functions, int count);
-ZEND_API int register_module(zend_module_entry *module_entry);
+int zend_register_functions(zend_function_entry *functions);
+void zend_unregister_functions(zend_function_entry *functions, int count);
+ZEND_API int zend_register_module(zend_module_entry *module_entry);
 zend_class_entry *register_internal_class(zend_class_entry *class_entry);
 
 ZEND_API void wrong_param_count(void);

diff --git a/Zend/zend_alloc.c b/Zend/zend_alloc.c
index 92c939cd3f1e9365a2de1af23cd5f6e9c18904d4..0e165c41c27ff2faac3442047717dcb8bf15ba46 100644 (file)
--- a/Zend/zend_alloc.c
+++ b/Zend/zend_alloc.c
@@ -86,8 +86,6 @@ static zend_alloc_globals alloc_globals;
        p->pLast = (mem_header *) NULL;
 
 
-/* used by ISAPI and NSAPI */
-
 #if ZEND_DEBUG
 ZEND_API void *_emalloc(size_t size, char *filename, uint lineno)
 #else
@@ -95,6 +93,7 @@ ZEND_API void *_emalloc(size_t size)
 #endif
 {
        mem_header *p;
+       ALS_FETCH();
 
        HANDLE_BLOCK_INTERRUPTIONS();
 
@@ -143,6 +142,7 @@ ZEND_API void _efree(void *ptr)
 #endif
 {
        mem_header *p = (mem_header *) ((char *)ptr - sizeof(mem_header) - PLATFORM_PADDING);
+       ALS_FETCH();
 
 #if ZEND_DEBUG
        _mem_block_check(ptr, 1, filename, lineno);
@@ -202,6 +202,7 @@ ZEND_API void *_erealloc(void *ptr, size_t size)
 {
        mem_header *p = (mem_header *) ((char *)ptr-sizeof(mem_header)-PLATFORM_PADDING);
        mem_header *orig = p;
+       ALS_FETCH();
 
        if (!ptr) {
 #if ZEND_DEBUG
@@ -319,6 +320,8 @@ ZEND_API int zend_set_memory_limit(unsigned int memory_limit)
 
 ZEND_API void start_memory_manager(void)
 {
+       ALS_FETCH();
+
        AG(phead) = AG(head) = NULL;
        
 #if MEMORY_LIMIT
@@ -334,6 +337,7 @@ ZEND_API void start_memory_manager(void)
 ZEND_API void shutdown_memory_manager(int silent, int clean_cache)
 {
        mem_header *p, *t;
+       ALS_FETCH();
 
        p=AG(head);
        t=AG(head);
@@ -464,8 +468,12 @@ ZEND_API int _mem_block_check(void *ptr, int silent, char *filename, int lineno)
 
 ZEND_API void _full_mem_check(int silent, char *filename, uint lineno)
 {
-       mem_header *p = AG(head);
+       mem_header *p;
        int errors=0;
+       ALS_FETCH();
+
+       p = AG(head);
+       
 
        fprintf(stderr,"------------------------------------------------\n");
        fprintf(stderr,"Full Memory Check at %s:%d\n", filename, lineno);
@@ -489,6 +497,7 @@ ZEND_API void _persist_alloc(void *ptr)
 #endif
 {
        mem_header *p = (mem_header *) ((char *)ptr-sizeof(mem_header)-PLATFORM_PADDING);
+       ALS_FETCH();
 
 #if ZEND_DEBUG
        _mem_block_check(ptr, 1, filename, lineno);

diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
index 01c8ba41e033232de9195fa914d5d48a65c81563..03e0efc69b430e8201777ce46c96fec60923eb33 100644 (file)
--- a/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@ -154,7 +154,7 @@ void do_binary_assign_op(int op, znode *result, znode *op1, znode *op2 CLS_DC)
 
 
 
-void do_fetch_globals(znode *varname)
+void do_fetch_globals(znode *varname CLS_DC)
 {
        if (!CG(active_op_array)->initialized_globals
                && varname->op_type == IS_CONST
@@ -496,7 +496,7 @@ void do_end_variable_parse(int type CLS_DC)
 }
 
 
-void do_init_string(znode *result)
+void do_init_string(znode *result CLS_DC)
 {
        zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
 
@@ -625,7 +625,7 @@ void do_begin_function_declaration(znode *function_token, znode *function_name,
        }
 
        if (CG(extended_info)) {
-               zend_op *opline = get_next_op(CG(active_op_array));
+               zend_op *opline = get_next_op(CG(active_op_array) CLS_CC);
 
                opline->opcode = ZEND_EXT_NOP;
                opline->lineno = function_begin_line;

diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h
index facde729ded5b82827da86f4256fb6986a90ff85..1265a608a09d025495c48b6a939c84dc0bf5317f 100644 (file)
--- a/Zend/zend_compile.h
+++ b/Zend/zend_compile.h
@@ -202,7 +202,7 @@ void do_assign_ref(znode *result, znode *lvar, znode *rvar CLS_DC);
 void fetch_simple_variable(znode *result, znode *varname, int bp CLS_DC);
 void do_indirect_references(znode *result, znode *num_references, znode *variable CLS_DC);
 void do_fetch_global_or_static_variable(znode *varname, znode *static_assignment, int fetch_type CLS_DC);
-void do_fetch_globals(znode *varname);
+void 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);
@@ -233,7 +233,7 @@ void do_end_variable_parse(int type CLS_DC);
 
 void do_free(znode *op1 CLS_DC);
 
-void do_init_string(znode *result);
+void do_init_string(znode *result CLS_DC);
 void do_add_char(znode *result, znode *op1, znode *op2 CLS_DC);
 void do_add_string(znode *result, znode *op1, znode *op2 CLS_DC);
 void do_add_variable(znode *result, znode *op1, znode *op2 CLS_DC);
@@ -320,7 +320,7 @@ void do_extended_fcall_end(CLS_D);
 ZEND_API int require_file(zend_file_handle *file_handle CLS_DC);       
 ZEND_API int require_filename(char *filename CLS_DC);                          
 ZEND_API zend_op_array *compile_files(int mark_as_ref CLS_DC, int file_count, ...);
-ZEND_API zend_op_array *v_compile_files(int mark_as_ref ELS_DC, int file_count, va_list files);
+ZEND_API zend_op_array *v_compile_files(int mark_as_ref CLS_DC, int file_count, va_list files);
 ZEND_API zend_op_array *compile_string(zval *source_string CLS_DC);    
 ZEND_API zend_op_array *compile_filename(zval *filename CLS_DC);
 inline int open_file_for_scanning(zend_file_handle *file_handle CLS_DC);

diff --git a/Zend/zend_constants.c b/Zend/zend_constants.c
index 6072227a8252537eb14db217b03490dde975f879..d94574f7cb6edd58dd23a6d3b4bbb56099c49637 100644 (file)
--- a/Zend/zend_constants.c
+++ b/Zend/zend_constants.c
@@ -53,6 +53,8 @@ static int clean_module_constant(zend_constant *c, int *module_number)
 
 void clean_module_constants(int module_number)
 {
+       ELS_FETCH();
+
        zend_hash_apply_with_argument(EG(zend_constants), (int (*)(void *,void *)) clean_module_constant, (void *) &module_number);
 }
 
@@ -65,6 +67,7 @@ int zend_startup_constants(void)
        DWORD dwWindowsMajorVersion =  (DWORD)(LOBYTE(LOWORD(dwVersion)));
        DWORD dwWindowsMinorVersion =  (DWORD)(HIBYTE(LOWORD(dwVersion)));
 #endif
+       ELS_FETCH();
 
 
 /* ZEND_FIX:  Move to PHP */
@@ -126,6 +129,8 @@ int zend_startup_constants(void)
 
 int zend_shutdown_constants(void)
 {
+       ELS_FETCH();
+
        zend_hash_destroy(EG(zend_constants));
        free(EG(zend_constants));
        return SUCCESS;
@@ -134,6 +139,8 @@ int zend_shutdown_constants(void)
 
 void clean_non_persistent_constants(void)
 {
+       ELS_FETCH();
+
        zend_hash_apply(EG(zend_constants), (int (*)(void *)) clean_non_persistent_constant);
 }
 
@@ -192,6 +199,7 @@ ZEND_API int zend_get_constant(char *name, uint name_len, zval *result)
        zend_constant *c;
        char *lookup_name = estrndup(name,name_len);
        int retval;
+       ELS_FETCH();
 
        zend_str_tolower(lookup_name, name_len);
 
@@ -215,6 +223,7 @@ ZEND_API int zend_get_constant(char *name, uint name_len, zval *result)
 ZEND_API void zend_register_constant(zend_constant *c)
 {
        char *lowercase_name = zend_strndup(c->name, c->name_len);
+       ELS_FETCH();
 
 #if 0
        printf("Registering constant for module %d\n",c->module_number);

diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c
index eb2dc8873ce71f05ba215a7ee1e5df6db4fa1735..165902b6960540b31de3996afdf34744068f2417 100644 (file)
--- a/Zend/zend_execute.c
+++ b/Zend/zend_execute.c
@@ -1373,7 +1373,7 @@ overloaded_function_call_cont:
                                                }
                                                EG(active_symbol_table) = calling_symbol_table;
                                        } else { /* ZEND_OVERLOADED_FUNCTION */
-                                               call_overloaded_function(opline->extended_value, &Ts[opline->result.u.var].tmp_var, &EG(regular_list), &EG(persistent_list));
+                                               call_overloaded_function(opline->extended_value, &Ts[opline->result.u.var].tmp_var, &EG(regular_list), &EG(persistent_list) ELS_CC);
                                                efree(function_being_called);
                                        }
                                        function_state.function = (zend_function *) op_array;
@@ -1470,7 +1470,7 @@ send_by_ref:
                                        zval **param;
 
                                        //if (zend_hash_index_find(EG(active_symbol_table), opline->op1.u.constant.value.lval, (void **) &param)==FAILURE) {
-                                       if (zend_ptr_stack_get_arg(opline->op1.u.constant.value.lval, (void **) &param)==FAILURE) {
+                                       if (zend_ptr_stack_get_arg(opline->op1.u.constant.value.lval, (void **) &param ELS_CC)==FAILURE) {
                                                zend_error(E_NOTICE, "Missing argument %d for %s()\n", opline->op1.u.constant.value.lval, get_active_function_name());
                                                DEC_AI_COUNT();
                                        } else if ((*param)->is_ref) {
@@ -1484,7 +1484,7 @@ send_by_ref:
                                        zval **param, *assignment_value;
 
                                        //if (zend_hash_index_find(EG(active_symbol_table), opline->op1.u.constant.value.lval, (void **) &param)==FAILURE) {
-                                       if (zend_ptr_stack_get_arg(opline->op1.u.constant.value.lval, (void **) &param)==FAILURE) {
+                                       if (zend_ptr_stack_get_arg(opline->op1.u.constant.value.lval, (void **) &param ELS_CC)==FAILURE) {
                                                if (opline->op2.op_type == IS_UNUSED) {
                                                        DEC_AI_COUNT();
                                                        break;

diff --git a/Zend/zend_execute.h b/Zend/zend_execute.h
index 206bcd6f6f70dea74857c4bac513dbc52e7b4863..fc70585b14d310426147942fb2c3209ae5681348 100644 (file)
--- a/Zend/zend_execute.h
+++ b/Zend/zend_execute.h
@@ -47,7 +47,7 @@ ZEND_API inline void zend_assign_to_variable_reference(znode *result, zval **var
 
 /* dedicated Zend executor functions - do not use! */
 ZEND_API inline void zend_ptr_stack_clear_multiple(ELS_D);
-ZEND_API inline int zend_ptr_stack_get_arg(int requested_arg, void **data);
+ZEND_API inline int zend_ptr_stack_get_arg(int requested_arg, void **data ELS_DC);
 
 #if SUPPORT_INTERACTIVE
 void execute_new_code(CLS_D);

diff --git a/Zend/zend_execute_API.c b/Zend/zend_execute_API.c
index 0b02007642df31d67ac2b98cfbc753cab4fea178..4a99396a921e24cfa15afb3d39cdbfef934fe78d 100644 (file)
--- a/Zend/zend_execute_API.c
+++ b/Zend/zend_execute_API.c
@@ -465,7 +465,7 @@ ZEND_API inline void zend_ptr_stack_clear_multiple(ELS_D)
 
 
 
-ZEND_API int zend_ptr_stack_get_arg(int requested_arg, void **data)
+ZEND_API int zend_ptr_stack_get_arg(int requested_arg, void **data ELS_DC)
 {
        void **p = EG(argument_stack).top_element-1;
        int arg_count = (ulong) *p;

diff --git a/Zend/zend_globals.h b/Zend/zend_globals.h
index 727eb312a6b45e56ed5f0e1441165a36b2340cc9..197172b326aa37ddcd0b9312725f69d36495fde1 100644 (file)
--- a/Zend/zend_globals.h
+++ b/Zend/zend_globals.h
@@ -24,13 +24,16 @@
 #include "zend_hash.h"
 #include "zend_llist.h"
 
+
+/* Define ZTS if you want a thread-safe Zend */
 #undef ZTS
 
 #ifdef ZTS
-#include "SAPI.h"
+#include "../TSRM/TSRM.h"
 
 extern int compiler_globals_id;
 extern int executor_globals_id;
+extern int alloc_globals_id;
 #endif
 
 typedef struct _zend_compiler_globals zend_compiler_globals;

diff --git a/Zend/zend_opcode.c b/Zend/zend_opcode.c
index 8c53e3e8077cb17bdf0583656eaf4a0d42b9a651..5cdc477796cb1906a0b25d0be888c1b9ef50a24a 100644 (file)
--- a/Zend/zend_opcode.c
+++ b/Zend/zend_opcode.c
@@ -59,15 +59,17 @@ void init_op_array(zend_op_array *op_array, int initial_ops_size)
 {
        op_array->type = ZEND_USER_FUNCTION;
 #if SUPPORT_INTERACTIVE
-       CLS_FETCH();
+       {
+               ELS_FETCH();
 
-       op_array->start_op_number = op_array->end_op_number = op_array->last_executed_op_number = 0;
-       op_array->backpatch_count = 0;
-       if (EG(interactive)) {
-               /* We must avoid a realloc() on the op_array in interactive mode, since pointers to constants
-                * will become invalid
-                */
-               initial_ops_size = 8192;
+               op_array->start_op_number = op_array->end_op_number = op_array->last_executed_op_number = 0;
+               op_array->backpatch_count = 0;
+               if (EG(interactive)) {
+                       /* We must avoid a realloc() on the op_array in interactive mode, since pointers to constants
+                        * will become invalid
+                        */
+                       initial_ops_size = 8192;
+               }
        }
 #endif
 
@@ -218,7 +220,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)
+static void zend_update_extended_info(zend_op_array *op_array CLS_DC)
 {
        zend_op *opline = op_array->opcodes, *end=opline+op_array->last;
 
@@ -238,7 +240,7 @@ static void zend_update_extended_info(zend_op_array *op_array)
                }
                opline++;
        }
-       opline = get_next_op(op_array);
+       opline = get_next_op(op_array CLS_CC);
        opline->opcode = ZEND_EXT_STMT;
        opline->op1.op_type = IS_UNUSED;
        opline->op2.op_type = IS_UNUSED;
@@ -266,7 +268,7 @@ int pass_two(zend_op_array *op_array)
                return 0;
        }
        if (CG(extended_info)) {
-               zend_update_extended_info(op_array);
+               zend_update_extended_info(op_array CLS_CC);
        }
        if (CG(handle_op_arrays)) {
                zend_llist_apply_with_argument(&zend_extensions, (void (*)(void *, void *)) zend_extension_op_array_handler, op_array);