Remove PHAR_GLOBALS (make it respect ZEND_ENABLE_STATIC_TSRMLS_CACHE)

diff --git a/ext/phar/func_interceptors.c b/ext/phar/func_interceptors.c
index e3bdf01cf1a6d23cd883facc7af682ca3194d466..8cadeb5a4a05b972b5f3fad320bd4201b1cea923 100644 (file)
--- a/ext/phar/func_interceptors.c
+++ b/ext/phar/func_interceptors.c
@@ -33,7 +33,7 @@ PHAR_FUNC(phar_opendir) /* {{{ */
                goto skip_phar;
        }
 
-       if ((PHAR_GLOBALS->phar_fname_map.u.flags && !zend_hash_num_elements(&(PHAR_GLOBALS->phar_fname_map)))
+       if ((PHAR_G(phar_fname_map.u.flags) && !zend_hash_num_elements(&(PHAR_G(phar_fname_map))))
                && !cached_phars.u.flags) {
                goto skip_phar;
        }
@@ -106,7 +106,7 @@ PHAR_FUNC(phar_file_get_contents) /* {{{ */
                goto skip_phar;
        }
 
-       if ((PHAR_GLOBALS->phar_fname_map.u.flags && !zend_hash_num_elements(&(PHAR_GLOBALS->phar_fname_map)))
+       if ((PHAR_G(phar_fname_map.u.flags) && !zend_hash_num_elements(&(PHAR_G(phar_fname_map))))
                && !cached_phars.u.flags) {
                goto skip_phar;
        }
@@ -239,7 +239,7 @@ PHAR_FUNC(phar_readfile) /* {{{ */
                goto skip_phar;
        }
 
-       if ((PHAR_GLOBALS->phar_fname_map.u.flags && !zend_hash_num_elements(&(PHAR_GLOBALS->phar_fname_map)))
+       if ((PHAR_G(phar_fname_map.u.flags) && !zend_hash_num_elements(&(PHAR_G(phar_fname_map))))
                && !cached_phars.u.flags) {
                goto skip_phar;
        }
@@ -339,7 +339,7 @@ PHAR_FUNC(phar_fopen) /* {{{ */
                goto skip_phar;
        }
 
-       if ((PHAR_GLOBALS->phar_fname_map.u.flags && !zend_hash_num_elements(&(PHAR_GLOBALS->phar_fname_map)))
+       if ((PHAR_G(phar_fname_map.u.flags) && !zend_hash_num_elements(&(PHAR_G(phar_fname_map))))
                && !cached_phars.u.flags) {
                /* no need to check, include_path not even specified in fopen/ no active phars */
                goto skip_phar;
@@ -910,7 +910,7 @@ PHAR_FUNC(phar_is_file) /* {{{ */
                goto skip_phar;
        }
 
-       if ((PHAR_GLOBALS->phar_fname_map.u.flags && !zend_hash_num_elements(&(PHAR_GLOBALS->phar_fname_map)))
+       if ((PHAR_G(phar_fname_map.u.flags) && !zend_hash_num_elements(&(PHAR_G(phar_fname_map))))
                && !cached_phars.u.flags) {
                goto skip_phar;
        }
@@ -977,7 +977,7 @@ PHAR_FUNC(phar_is_link) /* {{{ */
                goto skip_phar;
        }
 
-       if ((PHAR_GLOBALS->phar_fname_map.u.flags && !zend_hash_num_elements(&(PHAR_GLOBALS->phar_fname_map)))
+       if ((PHAR_G(phar_fname_map.u.flags) && !zend_hash_num_elements(&(PHAR_G(phar_fname_map))))
                && !cached_phars.u.flags) {
                goto skip_phar;
        }

diff --git a/ext/phar/phar.c b/ext/phar/phar.c
index 8448100f77cf1a48f6625655f7539f30b1ce4303..8c2b596c3ddf45908f2ab812ae9d8ec02dd9aecd 100644 (file)
--- a/ext/phar/phar.c
+++ b/ext/phar/phar.c
@@ -82,8 +82,8 @@ ZEND_INI_MH(phar_ini_modify_handler) /* {{{ */
 
        if (entry->name->len == sizeof("phar.readonly")-1) {
                PHAR_G(readonly) = ini;
-               if (PHAR_GLOBALS->request_init && PHAR_GLOBALS->phar_fname_map.u.flags) {
-                       zend_hash_apply_with_argument(&(PHAR_GLOBALS->phar_fname_map), phar_set_writeable_bit, (void *)&ini);
+               if (PHAR_G(request_init) && PHAR_G(phar_fname_map.u.flags)) {
+                       zend_hash_apply_with_argument(&(PHAR_G(phar_fname_map)), phar_set_writeable_bit, (void *)&ini);
                }
        } else {
                PHAR_G(require_hash) = ini;
@@ -105,16 +105,16 @@ static void phar_split_cache_list(void) /* {{{ */
        phar_archive_data *phar;
        uint i = 0;
 
-       if (!PHAR_GLOBALS->cache_list || !(PHAR_GLOBALS->cache_list[0])) {
+       if (!PHAR_G(cache_list) || !(PHAR_G(cache_list)[0])) {
                return;
        }
 
        ds[0] = DEFAULT_DIR_SEPARATOR;
        ds[1] = '\0';
-       tmp = estrdup(PHAR_GLOBALS->cache_list);
+       tmp = estrdup(PHAR_G(cache_list));
 
        /* fake request startup */
-       PHAR_GLOBALS->request_init = 1;
+       PHAR_G(request_init) = 1;
        zend_hash_init(&EG(regular_list), 0, NULL, NULL, 0);
        EG(regular_list).nNextFreeElement=1;    /* we don't want resource id 0 */
 
@@ -124,10 +124,10 @@ static void phar_split_cache_list(void) /* {{{ */
        zend_hash_init(&cached_phars, sizeof(phar_archive_data*), zend_get_hash_value, destroy_phar_data,  1);
        zend_hash_init(&cached_alias, sizeof(phar_archive_data*), zend_get_hash_value, NULL, 1);
        /* these two are real and will be copied over cached_phars/cached_alias later */
-       zend_hash_init(&(PHAR_GLOBALS->phar_fname_map), sizeof(phar_archive_data*), zend_get_hash_value, destroy_phar_data,  1);
-       zend_hash_init(&(PHAR_GLOBALS->phar_alias_map), sizeof(phar_archive_data*), zend_get_hash_value, NULL, 1);
-       PHAR_GLOBALS->manifest_cached = 1;
-       PHAR_GLOBALS->persist = 1;
+       zend_hash_init(&(PHAR_G(phar_fname_map)), sizeof(phar_archive_data*), zend_get_hash_value, destroy_phar_data,  1);
+       zend_hash_init(&(PHAR_G(phar_alias_map)), sizeof(phar_archive_data*), zend_get_hash_value, NULL, 1);
+       PHAR_G(manifest_cached) = 1;
+       PHAR_G(persist) = 1;
 
        for (key = php_strtok_r(tmp, ds, &lasts);
                        key;
@@ -142,19 +142,19 @@ finish_up:
                                phar->fp = NULL;
                        } else {
 finish_error:
-                               PHAR_GLOBALS->persist = 0;
-                               PHAR_GLOBALS->manifest_cached = 0;
+                               PHAR_G(persist) = 0;
+                               PHAR_G(manifest_cached) = 0;
                                efree(tmp);
                                zend_hash_destroy(&(PHAR_G(phar_fname_map)));
-                               PHAR_GLOBALS->phar_fname_map.u.flags = 0;
+                               PHAR_G(phar_fname_map.u.flags) = 0;
                                zend_hash_destroy(&(PHAR_G(phar_alias_map)));
-                               PHAR_GLOBALS->phar_alias_map.u.flags = 0;
+                               PHAR_G(phar_alias_map.u.flags) = 0;
                                zend_hash_destroy(&cached_phars);
                                zend_hash_destroy(&cached_alias);
                                zend_hash_graceful_reverse_destroy(&EG(regular_list));
                                memset(&EG(regular_list), 0, sizeof(HashTable));
                                /* free cached manifests */
-                               PHAR_GLOBALS->request_init = 0;
+                               PHAR_G(request_init) = 0;
                                return;
                        }
                } else {
@@ -166,15 +166,15 @@ finish_error:
                }
        }
 
-       PHAR_GLOBALS->persist = 0;
-       PHAR_GLOBALS->request_init = 0;
+       PHAR_G(persist) = 0;
+       PHAR_G(request_init) = 0;
        /* destroy dummy values from before */
        zend_hash_destroy(&cached_phars);
        zend_hash_destroy(&cached_alias);
-       cached_phars = PHAR_GLOBALS->phar_fname_map;
-       cached_alias = PHAR_GLOBALS->phar_alias_map;
-       PHAR_GLOBALS->phar_fname_map.u.flags = 0;
-       PHAR_GLOBALS->phar_alias_map.u.flags = 0;
+       cached_phars = PHAR_G(phar_fname_map);
+       cached_alias = PHAR_G(phar_alias_map);
+       PHAR_G(phar_fname_map.u.flags) = 0;
+       PHAR_G(phar_alias_map.u.flags) = 0;
        zend_hash_graceful_reverse_destroy(&EG(regular_list));
        memset(&EG(regular_list), 0, sizeof(HashTable));
        efree(tmp);
@@ -274,8 +274,8 @@ int phar_archive_delref(phar_archive_data *phar) /* {{{ */
        }
 
        if (--phar->refcount < 0) {
-               if (PHAR_GLOBALS->request_done
-               || zend_hash_str_del(&(PHAR_GLOBALS->phar_fname_map), phar->fname, phar->fname_len) != SUCCESS) {
+               if (PHAR_G(request_done)
+               || zend_hash_str_del(&(PHAR_G(phar_fname_map)), phar->fname, phar->fname_len) != SUCCESS) {
                        phar_destroy_phar_data(phar);
                }
                return 1;
@@ -296,7 +296,7 @@ int phar_archive_delref(phar_archive_data *phar) /* {{{ */
                if (!zend_hash_num_elements(&phar->manifest)) {
                        /* this is a new phar that has perhaps had an alias/metadata set, but has never
                        been flushed */
-                       if (zend_hash_str_del(&(PHAR_GLOBALS->phar_fname_map), phar->fname, phar->fname_len) != SUCCESS) {
+                       if (zend_hash_str_del(&(PHAR_G(phar_fname_map)), phar->fname, phar->fname_len) != SUCCESS) {
                                phar_destroy_phar_data(phar);
                        }
                        return 1;
@@ -355,7 +355,7 @@ static void destroy_phar_data(zval *zv) /* {{{ */
 {
        phar_archive_data *phar_data = (phar_archive_data *)Z_PTR_P(zv);
 
-       if (PHAR_GLOBALS->request_ends) {
+       if (PHAR_G(request_ends)) {
                /* first, iterate over the manifest and close all PHAR_TMP entry fp handles,
                this prevents unnecessary unfreed stream resources */
                zend_hash_apply(&(phar_data->manifest), phar_tmpclose_apply);
@@ -363,7 +363,7 @@ static void destroy_phar_data(zval *zv) /* {{{ */
                return;
        }
 
-       zend_hash_apply_with_argument(&(PHAR_GLOBALS->phar_alias_map), phar_unalias_apply, phar_data);
+       zend_hash_apply_with_argument(&(PHAR_G(phar_alias_map)), phar_unalias_apply, phar_data);
 
        if (--phar_data->refcount < 0) {
                phar_destroy_phar_data(phar_data);
@@ -1214,7 +1214,7 @@ static int phar_parse_pharfile(php_stream *fp, char *fname, int fname_len, char
                        MAPPHAR_FAIL("Cannot open archive \"%s\", invalid alias");
                }
 
-               if (NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len))) {
+               if (NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_G(phar_alias_map)), alias, alias_len))) {
                        if (SUCCESS != phar_free_alias(fd_ptr, alias, alias_len)) {
                                signature = NULL;
                                fp = NULL;
@@ -1222,12 +1222,12 @@ static int phar_parse_pharfile(php_stream *fp, char *fname, int fname_len, char
                        }
                }
 
-               zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len, mydata);
+               zend_hash_str_add_ptr(&(PHAR_G(phar_alias_map)), alias, alias_len, mydata);
        } else {
                mydata->is_temporary_alias = 1;
        }
 
-       zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_fname_map), mydata->fname, fname_len, mydata);
+       zend_hash_str_add_ptr(&(PHAR_G(phar_fname_map)), mydata->fname, fname_len, mydata);
        efree(savebuf);
 
        if (pphar) {
@@ -1413,7 +1413,7 @@ int phar_create_or_parse_filename(char *fname, int fname_len, char *alias, int a
        mydata->is_writeable = 1;
        mydata->is_brandnew = 1;
        phar_request_initialize();
-       zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_fname_map), mydata->fname, fname_len, mydata);
+       zend_hash_str_add_ptr(&(PHAR_G(phar_fname_map)), mydata->fname, fname_len, mydata);
 
        if (is_data) {
                alias = NULL;
@@ -1424,13 +1424,13 @@ int phar_create_or_parse_filename(char *fname, int fname_len, char *alias, int a
        } else {
                phar_archive_data *fd_ptr;
 
-               if (alias && NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len))) {
+               if (alias && NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_G(phar_alias_map)), alias, alias_len))) {
                        if (SUCCESS != phar_free_alias(fd_ptr, alias, alias_len)) {
                                if (error) {
                                        spprintf(error, 4096, "phar error: phar \"%s\" cannot set alias \"%s\", already in use by another phar archive", mydata->fname, alias);
                                }
 
-                               zend_hash_str_del(&(PHAR_GLOBALS->phar_fname_map), mydata->fname, fname_len);
+                               zend_hash_str_del(&(PHAR_G(phar_fname_map)), mydata->fname, fname_len);
 
                                if (pphar) {
                                        *pphar = NULL;
@@ -1445,14 +1445,14 @@ int phar_create_or_parse_filename(char *fname, int fname_len, char *alias, int a
        }
 
        if (alias_len && alias) {
-               if (NULL == zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len, mydata)) {
+               if (NULL == zend_hash_str_add_ptr(&(PHAR_G(phar_alias_map)), alias, alias_len, mydata)) {
                        if (options & REPORT_ERRORS) {
                                if (error) {
                                        spprintf(error, 0, "archive \"%s\" cannot be associated with alias \"%s\", already in use", fname, alias);
                                }
                        }
 
-                       zend_hash_str_del(&(PHAR_GLOBALS->phar_fname_map), mydata->fname, fname_len);
+                       zend_hash_str_del(&(PHAR_G(phar_fname_map)), mydata->fname, fname_len);
 
                        if (pphar) {
                                *pphar = NULL;
@@ -1746,7 +1746,7 @@ static int phar_analyze_path(const char *fname, const char *ext, int ext_len, in
 #ifdef PHP_WIN32
                phar_unixify_path_separators(realpath, strlen(realpath));
 #endif
-               if (zend_hash_str_exists(&(PHAR_GLOBALS->phar_fname_map), realpath, strlen(realpath))) {
+               if (zend_hash_str_exists(&(PHAR_G(phar_fname_map)), realpath, strlen(realpath))) {
                        efree(realpath);
                        efree(filename);
                        return SUCCESS;
@@ -1915,7 +1915,7 @@ int phar_detect_phar_fname_ext(const char *filename, int filename_len, const cha
                        *ext_str = NULL;
                        return FAILURE;
                }
-               if (zend_hash_str_exists(&(PHAR_GLOBALS->phar_alias_map), (char *) filename, pos - filename)) {
+               if (zend_hash_str_exists(&(PHAR_G(phar_alias_map)), (char *) filename, pos - filename)) {
                        *ext_str = pos;
                        *ext_len = -1;
                        return FAILURE;
@@ -1928,11 +1928,11 @@ int phar_detect_phar_fname_ext(const char *filename, int filename_len, const cha
                }
        }
 
-       if (zend_hash_num_elements(&(PHAR_GLOBALS->phar_fname_map)) || PHAR_G(manifest_cached)) {
+       if (zend_hash_num_elements(&(PHAR_G(phar_fname_map))) || PHAR_G(manifest_cached)) {
                phar_archive_data *pphar;
 
                if (is_complete) {
-                       if (NULL != (pphar = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_fname_map), (char *) filename, filename_len))) {
+                       if (NULL != (pphar = zend_hash_str_find_ptr(&(PHAR_G(phar_fname_map)), (char *) filename, filename_len))) {
                                *ext_str = filename + (filename_len - pphar->ext_len);
 woohoo:
                                *ext_len = pphar->ext_len;
@@ -1960,9 +1960,9 @@ woohoo:
                        zend_string *str_key;
                        zend_ulong unused;
 
-                       for (zend_hash_internal_pointer_reset(&(PHAR_GLOBALS->phar_fname_map));
-                               HASH_KEY_NON_EXISTENT != zend_hash_get_current_key(&(PHAR_GLOBALS->phar_fname_map), &str_key, &unused);
-                               zend_hash_move_forward(&(PHAR_GLOBALS->phar_fname_map))
+                       for (zend_hash_internal_pointer_reset(&(PHAR_G(phar_fname_map)));
+                               HASH_KEY_NON_EXISTENT != zend_hash_get_current_key(&(PHAR_G(phar_fname_map)), &str_key, &unused);
+                               zend_hash_move_forward(&(PHAR_G(phar_fname_map)))
                        ) {
                                if (str_key->len > (uint) filename_len) {
                                        continue;
@@ -1970,7 +1970,7 @@ woohoo:
 
                                if (!memcmp(filename, str_key->val, str_key->len) && ((uint)filename_len == str_key->len
                                        || filename[str_key->len] == '/' || filename[str_key->len] == '\0')) {
-                                       if (NULL == (pphar = zend_hash_get_current_data_ptr(&(PHAR_GLOBALS->phar_fname_map)))) {
+                                       if (NULL == (pphar = zend_hash_get_current_data_ptr(&(PHAR_G(phar_fname_map))))) {
                                                break;
                                        }
                                        *ext_str = filename + (str_key->len - pphar->ext_len);
@@ -3299,7 +3299,7 @@ static zend_op_array *phar_compile_file(zend_file_handle *file_handle, int type)
                                file_handle->handle.stream.fsizer  = phar_zend_stream_fsizer;
                                file_handle->handle.stream.isatty  = 0;
                                phar->is_persistent ?
-                                       php_stream_rewind(PHAR_GLOBALS->cached_fp[phar->phar_pos].fp) :
+                                       php_stream_rewind(PHAR_G(cached_fp)[phar->phar_pos].fp) :
                                        php_stream_rewind(phar->fp);
                                memset(&file_handle->handle.stream.mmap, 0, sizeof(file_handle->handle.stream.mmap));
                        }
@@ -3444,18 +3444,18 @@ PHP_MSHUTDOWN_FUNCTION(phar) /* {{{ */
 
 void phar_request_initialize(void) /* {{{ */
 {
-       if (!PHAR_GLOBALS->request_init)
+       if (!PHAR_G(request_init))
        {
                PHAR_G(last_phar) = NULL;
                PHAR_G(last_phar_name) = PHAR_G(last_alias) = NULL;
                PHAR_G(has_bz2) = zend_hash_str_exists(&module_registry, "bz2", sizeof("bz2")-1);
                PHAR_G(has_zlib) = zend_hash_str_exists(&module_registry, "zlib", sizeof("zlib")-1);
-               PHAR_GLOBALS->request_init = 1;
-               PHAR_GLOBALS->request_ends = 0;
-               PHAR_GLOBALS->request_done = 0;
-               zend_hash_init(&(PHAR_GLOBALS->phar_fname_map), 5, zend_get_hash_value, destroy_phar_data,  0);
-               zend_hash_init(&(PHAR_GLOBALS->phar_persist_map), 5, zend_get_hash_value, NULL,  0);
-               zend_hash_init(&(PHAR_GLOBALS->phar_alias_map), 5, zend_get_hash_value, NULL, 0);
+               PHAR_G(request_init) = 1;
+               PHAR_G(request_ends) = 0;
+               PHAR_G(request_done) = 0;
+               zend_hash_init(&(PHAR_G(phar_fname_map)), 5, zend_get_hash_value, destroy_phar_data,  0);
+               zend_hash_init(&(PHAR_G(phar_persist_map)), 5, zend_get_hash_value, NULL,  0);
+               zend_hash_init(&(PHAR_G(phar_alias_map)), 5, zend_get_hash_value, NULL, 0);
 
                if (PHAR_G(manifest_cached)) {
                        phar_archive_data *pphar;
@@ -3467,10 +3467,10 @@ void phar_request_initialize(void) /* {{{ */
                                stuff[pphar->phar_pos].manifest = (phar_entry_fp_info *) ecalloc( zend_hash_num_elements(&(pphar->manifest)), sizeof(phar_entry_fp_info));
                        }
 
-                       PHAR_GLOBALS->cached_fp = stuff;
+                       PHAR_G(cached_fp) = stuff;
                }
 
-               PHAR_GLOBALS->phar_SERVER_mung_list = 0;
+               PHAR_G(phar_SERVER_mung_list) = 0;
                PHAR_G(cwd) = NULL;
                PHAR_G(cwd_len) = 0;
                PHAR_G(cwd_init) = 0;
@@ -3482,34 +3482,34 @@ PHP_RSHUTDOWN_FUNCTION(phar) /* {{{ */
 {
        int i;
 
-       PHAR_GLOBALS->request_ends = 1;
+       PHAR_G(request_ends) = 1;
 
-       if (PHAR_GLOBALS->request_init)
+       if (PHAR_G(request_init))
        {
                phar_release_functions();
-               zend_hash_destroy(&(PHAR_GLOBALS->phar_alias_map));
-               PHAR_GLOBALS->phar_alias_map.u.flags = 0;
-               zend_hash_destroy(&(PHAR_GLOBALS->phar_fname_map));
-               PHAR_GLOBALS->phar_fname_map.u.flags = 0;
-               zend_hash_destroy(&(PHAR_GLOBALS->phar_persist_map));
-               PHAR_GLOBALS->phar_persist_map.u.flags = 0;
-               PHAR_GLOBALS->phar_SERVER_mung_list = 0;
-
-               if (PHAR_GLOBALS->cached_fp) {
+               zend_hash_destroy(&(PHAR_G(phar_alias_map)));
+               PHAR_G(phar_alias_map.u.flags) = 0;
+               zend_hash_destroy(&(PHAR_G(phar_fname_map)));
+               PHAR_G(phar_fname_map.u.flags) = 0;
+               zend_hash_destroy(&(PHAR_G(phar_persist_map)));
+               PHAR_G(phar_persist_map.u.flags) = 0;
+               PHAR_G(phar_SERVER_mung_list) = 0;
+
+               if (PHAR_G(cached_fp)) {
                        for (i = 0; i < zend_hash_num_elements(&cached_phars); ++i) {
-                               if (PHAR_GLOBALS->cached_fp[i].fp) {
-                                       php_stream_close(PHAR_GLOBALS->cached_fp[i].fp);
+                               if (PHAR_G(cached_fp)[i].fp) {
+                                       php_stream_close(PHAR_G(cached_fp)[i].fp);
                                }
-                               if (PHAR_GLOBALS->cached_fp[i].ufp) {
-                                       php_stream_close(PHAR_GLOBALS->cached_fp[i].ufp);
+                               if (PHAR_G(cached_fp)[i].ufp) {
+                                       php_stream_close(PHAR_G(cached_fp)[i].ufp);
                                }
-                               efree(PHAR_GLOBALS->cached_fp[i].manifest);
+                               efree(PHAR_G(cached_fp)[i].manifest);
                        }
-                       efree(PHAR_GLOBALS->cached_fp);
-                       PHAR_GLOBALS->cached_fp = 0;
+                       efree(PHAR_G(cached_fp));
+                       PHAR_G(cached_fp) = 0;
                }
 
-               PHAR_GLOBALS->request_init = 0;
+               PHAR_G(request_init) = 0;
 
                if (PHAR_G(cwd)) {
                        efree(PHAR_G(cwd));
@@ -3520,7 +3520,7 @@ PHP_RSHUTDOWN_FUNCTION(phar) /* {{{ */
                PHAR_G(cwd_init) = 0;
        }
 
-       PHAR_GLOBALS->request_done = 1;
+       PHAR_G(request_done) = 1;
        return SUCCESS;
 }
 /* }}} */

diff --git a/ext/phar/phar_internal.h b/ext/phar/phar_internal.h
index ccff36770b217eebe50e746e6f9cd6e5c39d486c..63e00bd2600e3dba141d337d0f3e05cb58ba2735 100644 (file)
--- a/ext/phar/phar_internal.h
+++ b/ext/phar/phar_internal.h
@@ -200,10 +200,8 @@ ZEND_EXTERN_MODULE_GLOBALS(phar)
 ZEND_TSRMLS_CACHE_EXTERN();
 #   endif
 #      define PHAR_G(v) ZEND_TSRMG(phar_globals_id, zend_phar_globals *, v)
-#      define PHAR_GLOBALS ((zend_phar_globals *) (*((void ***) ZEND_TSRMLS_CACHE))[TSRM_UNSHUFFLE_RSRC_ID(phar_globals_id)])
 #else
 #      define PHAR_G(v) (phar_globals.v)
-#      define PHAR_GLOBALS (&phar_globals)
 #endif
 
 #ifndef php_uint16
@@ -351,7 +349,7 @@ static inline php_stream *phar_get_entrypfp(phar_entry_info *entry)
        if (!entry->is_persistent) {
                return entry->phar->fp;
        }
-       return PHAR_GLOBALS->cached_fp[entry->phar->phar_pos].fp;
+       return PHAR_G(cached_fp)[entry->phar->phar_pos].fp;
 }
 
 static inline php_stream *phar_get_entrypufp(phar_entry_info *entry)
@@ -359,7 +357,7 @@ static inline php_stream *phar_get_entrypufp(phar_entry_info *entry)
        if (!entry->is_persistent) {
                return entry->phar->ufp;
        }
-       return PHAR_GLOBALS->cached_fp[entry->phar->phar_pos].ufp;
+       return PHAR_G(cached_fp)[entry->phar->phar_pos].ufp;
 }
 
 static inline void phar_set_entrypfp(phar_entry_info *entry, php_stream *fp)
@@ -369,7 +367,7 @@ static inline void phar_set_entrypfp(phar_entry_info *entry, php_stream *fp)
                return;
        }
 
-       PHAR_GLOBALS->cached_fp[entry->phar->phar_pos].fp = fp;
+       PHAR_G(cached_fp)[entry->phar->phar_pos].fp = fp;
 }
 
 static inline void phar_set_entrypufp(phar_entry_info *entry, php_stream *fp)
@@ -379,7 +377,7 @@ static inline void phar_set_entrypufp(phar_entry_info *entry, php_stream *fp)
                return;
        }
 
-       PHAR_GLOBALS->cached_fp[entry->phar->phar_pos].ufp = fp;
+       PHAR_G(cached_fp)[entry->phar->phar_pos].ufp = fp;
 }
 
 static inline php_stream *phar_get_pharfp(phar_archive_data *phar)
@@ -387,7 +385,7 @@ static inline php_stream *phar_get_pharfp(phar_archive_data *phar)
        if (!phar->is_persistent) {
                return phar->fp;
        }
-       return PHAR_GLOBALS->cached_fp[phar->phar_pos].fp;
+       return PHAR_G(cached_fp)[phar->phar_pos].fp;
 }
 
 static inline php_stream *phar_get_pharufp(phar_archive_data *phar)
@@ -395,7 +393,7 @@ static inline php_stream *phar_get_pharufp(phar_archive_data *phar)
        if (!phar->is_persistent) {
                return phar->ufp;
        }
-       return PHAR_GLOBALS->cached_fp[phar->phar_pos].ufp;
+       return PHAR_G(cached_fp)[phar->phar_pos].ufp;
 }
 
 static inline void phar_set_pharfp(phar_archive_data *phar, php_stream *fp)
@@ -405,7 +403,7 @@ static inline void phar_set_pharfp(phar_archive_data *phar, php_stream *fp)
                return;
        }
 
-       PHAR_GLOBALS->cached_fp[phar->phar_pos].fp = fp;
+       PHAR_G(cached_fp)[phar->phar_pos].fp = fp;
 }
 
 static inline void phar_set_pharufp(phar_archive_data *phar, php_stream *fp)
@@ -415,7 +413,7 @@ static inline void phar_set_pharufp(phar_archive_data *phar, php_stream *fp)
                return;
        }
 
-       PHAR_GLOBALS->cached_fp[phar->phar_pos].ufp = fp;
+       PHAR_G(cached_fp)[phar->phar_pos].ufp = fp;
 }
 
 static inline void phar_set_fp_type(phar_entry_info *entry, enum phar_fp_type type, zend_off_t offset)
@@ -427,7 +425,7 @@ static inline void phar_set_fp_type(phar_entry_info *entry, enum phar_fp_type ty
                entry->offset = offset;
                return;
        }
-       data = &(PHAR_GLOBALS->cached_fp[entry->phar->phar_pos].manifest[entry->manifest_pos]);
+       data = &(PHAR_G(cached_fp)[entry->phar->phar_pos].manifest[entry->manifest_pos]);
        data->fp_type = type;
        data->offset = offset;
 }
@@ -437,7 +435,7 @@ static inline enum phar_fp_type phar_get_fp_type(phar_entry_info *entry)
        if (!entry->is_persistent) {
                return entry->fp_type;
        }
-       return PHAR_GLOBALS->cached_fp[entry->phar->phar_pos].manifest[entry->manifest_pos].fp_type;
+       return PHAR_G(cached_fp)[entry->phar->phar_pos].manifest[entry->manifest_pos].fp_type;
 }
 
 static inline zend_off_t phar_get_fp_offset(phar_entry_info *entry)
@@ -445,12 +443,12 @@ static inline zend_off_t phar_get_fp_offset(phar_entry_info *entry)
        if (!entry->is_persistent) {
                return entry->offset;
        }
-       if (PHAR_GLOBALS->cached_fp[entry->phar->phar_pos].manifest[entry->manifest_pos].fp_type == PHAR_FP) {
-               if (!PHAR_GLOBALS->cached_fp[entry->phar->phar_pos].manifest[entry->manifest_pos].offset) {
-                       PHAR_GLOBALS->cached_fp[entry->phar->phar_pos].manifest[entry->manifest_pos].offset = entry->offset;
+       if (PHAR_G(cached_fp)[entry->phar->phar_pos].manifest[entry->manifest_pos].fp_type == PHAR_FP) {
+               if (!PHAR_G(cached_fp)[entry->phar->phar_pos].manifest[entry->manifest_pos].offset) {
+                       PHAR_G(cached_fp)[entry->phar->phar_pos].manifest[entry->manifest_pos].offset = entry->offset;
                }
        }
-       return PHAR_GLOBALS->cached_fp[entry->phar->phar_pos].manifest[entry->manifest_pos].offset;
+       return PHAR_G(cached_fp)[entry->phar->phar_pos].manifest[entry->manifest_pos].offset;
 }
 
 #define PHAR_MIME_PHP '\0'

diff --git a/ext/phar/phar_object.c b/ext/phar/phar_object.c
index d5f84b87dec5337801e299e06136ace1ac3aea72..69bda4bab3e5f8022e291c7af4b53895666e0300 100644 (file)
--- a/ext/phar/phar_object.c
+++ b/ext/phar/phar_object.c
@@ -92,11 +92,11 @@ static void phar_mung_server_vars(char *fname, char *entry, int entry_len, char
                zend_hash_str_update(_SERVER, "PHAR_PATH_TRANSLATED", sizeof("PHAR_PATH_TRANSLATED")-1, &temp);
        }
 
-       if (!PHAR_GLOBALS->phar_SERVER_mung_list) {
+       if (!PHAR_G(phar_SERVER_mung_list)) {
                return;
        }
 
-       if (PHAR_GLOBALS->phar_SERVER_mung_list & PHAR_MUNG_REQUEST_URI) {
+       if (PHAR_G(phar_SERVER_mung_list) & PHAR_MUNG_REQUEST_URI) {
                if (NULL != (stuff = zend_hash_str_find(_SERVER, "REQUEST_URI", sizeof("REQUEST_URI")-1))) {
                        path_info = Z_STRVAL_P(stuff);
                        code = Z_STRLEN_P(stuff);
@@ -108,7 +108,7 @@ static void phar_mung_server_vars(char *fname, char *entry, int entry_len, char
                }
        }
 
-       if (PHAR_GLOBALS->phar_SERVER_mung_list & PHAR_MUNG_PHP_SELF) {
+       if (PHAR_G(phar_SERVER_mung_list) & PHAR_MUNG_PHP_SELF) {
                if (NULL != (stuff = zend_hash_str_find(_SERVER, "PHP_SELF", sizeof("PHP_SELF")-1))) {
                        path_info = Z_STRVAL_P(stuff);
                        code = Z_STRLEN_P(stuff);
@@ -121,7 +121,7 @@ static void phar_mung_server_vars(char *fname, char *entry, int entry_len, char
                }
        }
 
-       if (PHAR_GLOBALS->phar_SERVER_mung_list & PHAR_MUNG_SCRIPT_NAME) {
+       if (PHAR_G(phar_SERVER_mung_list) & PHAR_MUNG_SCRIPT_NAME) {
                if (NULL != (stuff = zend_hash_str_find(_SERVER, "SCRIPT_NAME", sizeof("SCRIPT_NAME")-1))) {
                        ZVAL_STR(&temp, Z_STR_P(stuff));
                        ZVAL_STRINGL(stuff, entry, entry_len);
@@ -129,7 +129,7 @@ static void phar_mung_server_vars(char *fname, char *entry, int entry_len, char
                }
        }
 
-       if (PHAR_GLOBALS->phar_SERVER_mung_list & PHAR_MUNG_SCRIPT_FILENAME) {
+       if (PHAR_G(phar_SERVER_mung_list) & PHAR_MUNG_SCRIPT_FILENAME) {
                if (NULL != (stuff = zend_hash_str_find(_SERVER, "SCRIPT_FILENAME", sizeof("SCRIPT_FILENAME")-1))) {
                        zend_string *str = strpprintf(4096, "phar://%s%s", fname, entry);
 
@@ -357,7 +357,7 @@ static void phar_postprocess_ru_web(char *fname, int fname_len, char **entry, in
        phar_archive_data *pphar;
 
        /* we already know we can retrieve the phar if we reach here */
-       pphar = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_fname_map), fname, fname_len);
+       pphar = zend_hash_str_find_ptr(&(PHAR_G(phar_fname_map)), fname, fname_len);
 
        if (!pphar && PHAR_G(manifest_cached)) {
                pphar = zend_hash_str_find_ptr(&cached_phars, fname, fname_len);
@@ -480,7 +480,7 @@ PHP_METHOD(Phar, mount)
                        return;
                }
 carry_on2:
-               if (NULL == (pphar = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_fname_map), arch, arch_len))) {
+               if (NULL == (pphar = zend_hash_str_find_ptr(&(PHAR_G(phar_fname_map)), arch, arch_len))) {
                        if (PHAR_G(manifest_cached) && NULL != (pphar = zend_hash_str_find_ptr(&cached_phars, arch, arch_len))) {
                                if (SUCCESS == phar_copy_on_write(&pphar)) {
                                        goto carry_on;
@@ -517,7 +517,7 @@ carry_on:
                }
 
                return;
-       } else if (PHAR_GLOBALS->phar_fname_map.u.flags && NULL != (pphar = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_fname_map), fname, fname_len))) {
+       } else if (PHAR_G(phar_fname_map.u.flags) && NULL != (pphar = zend_hash_str_find_ptr(&(PHAR_G(phar_fname_map)), fname, fname_len))) {
                goto carry_on;
        } else if (PHAR_G(manifest_cached) && NULL != (pphar = zend_hash_str_find_ptr(&cached_phars, fname, fname_len))) {
                if (SUCCESS == phar_copy_on_write(&pphar)) {
@@ -881,20 +881,20 @@ PHP_METHOD(Phar, mungServer)
                }
 
                if (Z_STRLEN_P(data) == sizeof("PHP_SELF")-1 && !strncmp(Z_STRVAL_P(data), "PHP_SELF", sizeof("PHP_SELF")-1)) {
-                       PHAR_GLOBALS->phar_SERVER_mung_list |= PHAR_MUNG_PHP_SELF;
+                       PHAR_G(phar_SERVER_mung_list) |= PHAR_MUNG_PHP_SELF;
                }
 
                if (Z_STRLEN_P(data) == sizeof("REQUEST_URI")-1) {
                        if (!strncmp(Z_STRVAL_P(data), "REQUEST_URI", sizeof("REQUEST_URI")-1)) {
-                               PHAR_GLOBALS->phar_SERVER_mung_list |= PHAR_MUNG_REQUEST_URI;
+                               PHAR_G(phar_SERVER_mung_list) |= PHAR_MUNG_REQUEST_URI;
                        }
                        if (!strncmp(Z_STRVAL_P(data), "SCRIPT_NAME", sizeof("SCRIPT_NAME")-1)) {
-                               PHAR_GLOBALS->phar_SERVER_mung_list |= PHAR_MUNG_SCRIPT_NAME;
+                               PHAR_G(phar_SERVER_mung_list) |= PHAR_MUNG_SCRIPT_NAME;
                        }
                }
 
                if (Z_STRLEN_P(data) == sizeof("SCRIPT_FILENAME")-1 && !strncmp(Z_STRVAL_P(data), "SCRIPT_FILENAME", sizeof("SCRIPT_FILENAME")-1)) {
-                       PHAR_GLOBALS->phar_SERVER_mung_list |= PHAR_MUNG_SCRIPT_FILENAME;
+                       PHAR_G(phar_SERVER_mung_list) |= PHAR_MUNG_SCRIPT_FILENAME;
                }
        } ZEND_HASH_FOREACH_END();
 }
@@ -1231,7 +1231,7 @@ PHP_METHOD(Phar, __construct)
                phar_obj->archive->is_data = is_data;
        } else if (!EG(exception)) {
                /* register this guy so we can modify if necessary */
-               zend_hash_str_add_ptr(&PHAR_GLOBALS->phar_persist_map, (const char *) phar_obj->archive, sizeof(phar_obj->archive), phar_obj);
+               zend_hash_str_add_ptr(&PHAR_G(phar_persist_map), (const char *) phar_obj->archive, sizeof(phar_obj->archive), phar_obj);
        }
 
        phar_obj->spl.info_class = phar_ce_entry;
@@ -1375,7 +1375,7 @@ PHP_METHOD(Phar, __destruct)
        phar_archive_object *phar_obj = (phar_archive_object*)((char*)Z_OBJ_P(zobj) - Z_OBJ_P(zobj)->handlers->offset);
 
        if (phar_obj->archive && phar_obj->archive->is_persistent) {
-               zend_hash_str_del(&PHAR_GLOBALS->phar_persist_map, (const char *) phar_obj->archive, sizeof(phar_obj->archive));
+               zend_hash_str_del(&PHAR_G(phar_persist_map), (const char *) phar_obj->archive, sizeof(phar_obj->archive));
        }
 }
 /* }}} */
@@ -2090,7 +2090,7 @@ static zend_object *phar_rename_archive(phar_archive_data *phar, char *ext, zend
                return NULL;
        }
 
-       if (NULL != (pphar = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_fname_map), newpath, phar->fname_len))) {
+       if (NULL != (pphar = zend_hash_str_find_ptr(&(PHAR_G(phar_fname_map)), newpath, phar->fname_len))) {
                if (pphar->fname_len == phar->fname_len && !memcmp(pphar->fname, phar->fname, phar->fname_len)) {
                        if (!zend_hash_num_elements(&phar->manifest)) {
                                pphar->is_tar = phar->is_tar;
@@ -2132,7 +2132,7 @@ its_ok:
                                phar->alias = estrndup(newpath, strlen(newpath));
                                phar->alias_len = strlen(newpath);
                                phar->is_temporary_alias = 1;
-                               zend_hash_str_update_ptr(&(PHAR_GLOBALS->phar_alias_map), newpath, phar->fname_len, phar);
+                               zend_hash_str_update_ptr(&(PHAR_G(phar_alias_map)), newpath, phar->fname_len, phar);
                        }
                }
 
@@ -2148,7 +2148,7 @@ its_ok:
                phar->alias_len = 0;
        }
 
-       if ((!pphar || phar == pphar) && NULL == zend_hash_str_update_ptr(&(PHAR_GLOBALS->phar_fname_map), newpath, phar->fname_len, phar)) {
+       if ((!pphar || phar == pphar) && NULL == zend_hash_str_update_ptr(&(PHAR_G(phar_fname_map)), newpath, phar->fname_len, phar)) {
                efree(oldpath);
                zend_throw_exception_ex(spl_ce_BadMethodCallException, 0, "Unable to add newly converted phar \"%s\" to the list of phars", phar->fname);
                return NULL;
@@ -2676,7 +2676,7 @@ PHP_METHOD(Phar, setAlias)
                if (alias_len == phar_obj->archive->alias_len && memcmp(phar_obj->archive->alias, alias, alias_len) == 0) {
                        RETURN_TRUE;
                }
-               if (alias_len && NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len))) {
+               if (alias_len && NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_G(phar_alias_map)), alias, alias_len))) {
                        spprintf(&error, 0, "alias \"%s\" is already used for archive \"%s\" and cannot be used for other archives", alias, fd_ptr->fname);
                        if (SUCCESS == phar_free_alias(fd_ptr, alias, alias_len)) {
                                efree(error);
@@ -2696,8 +2696,8 @@ valid_alias:
                        zend_throw_exception_ex(phar_ce_PharException, 0, "phar \"%s\" is persistent, unable to copy on write", phar_obj->archive->fname);
                        return;
                }
-               if (phar_obj->archive->alias_len && NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_alias_map), phar_obj->archive->alias, phar_obj->archive->alias_len))) {
-                       zend_hash_str_del(&(PHAR_GLOBALS->phar_alias_map), phar_obj->archive->alias, phar_obj->archive->alias_len);
+               if (phar_obj->archive->alias_len && NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_G(phar_alias_map)), phar_obj->archive->alias, phar_obj->archive->alias_len))) {
+                       zend_hash_str_del(&(PHAR_G(phar_alias_map)), phar_obj->archive->alias, phar_obj->archive->alias_len);
                        readd = 1;
                }
 
@@ -2721,13 +2721,13 @@ valid_alias:
                        phar_obj->archive->is_temporary_alias = old_temp;
                        zend_throw_exception_ex(phar_ce_PharException, 0, "%s", error);
                        if (readd) {
-                               zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_alias_map), oldalias, oldalias_len, phar_obj->archive);
+                               zend_hash_str_add_ptr(&(PHAR_G(phar_alias_map)), oldalias, oldalias_len, phar_obj->archive);
                        }
                        efree(error);
                        RETURN_FALSE;
                }
 
-               zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len, phar_obj->archive);
+               zend_hash_str_add_ptr(&(PHAR_G(phar_alias_map)), alias, alias_len, phar_obj->archive);
 
                if (oldalias) {
                        efree(oldalias);

diff --git a/ext/phar/stream.c b/ext/phar/stream.c
index af18fe0287c20e647ee5f55ec5135c651fcc1628..90cb13cf13262c42cfd5c87f7f268f5b70a8fb92 100644 (file)
--- a/ext/phar/stream.c
+++ b/ext/phar/stream.c
@@ -103,7 +103,7 @@ php_url* phar_parse_url(php_stream_wrapper *wrapper, const char *filename, const
        if (mode[0] == 'w' || (mode[0] == 'r' && mode[1] == '+')) {
                phar_archive_data *pphar = NULL, *phar;
 
-               if (PHAR_GLOBALS->request_init && PHAR_GLOBALS->phar_fname_map.u.flags && NULL == (pphar = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_fname_map), arch, arch_len))) {
+               if (PHAR_G(request_init) && PHAR_G(phar_fname_map.u.flags) && NULL == (pphar = zend_hash_str_find_ptr(&(PHAR_G(phar_fname_map)), arch, arch_len))) {
                        pphar = NULL;
                }
                if (PHAR_G(readonly) && (!pphar || !pphar->is_data)) {
@@ -701,7 +701,7 @@ static int phar_wrapper_unlink(php_stream_wrapper *wrapper, const char *url, int
        host_len = strlen(resource->host);
        phar_request_initialize();
 
-       pphar = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_fname_map), resource->host, host_len);
+       pphar = zend_hash_str_find_ptr(&(PHAR_G(phar_fname_map)), resource->host, host_len);
        if (PHAR_G(readonly) && (!pphar || !pphar->is_data)) {
                php_url_free(resource);
                php_stream_wrapper_log_error(wrapper, options, "phar error: write operations disabled by the php.ini setting phar.readonly");

diff --git a/ext/phar/tar.c b/ext/phar/tar.c
index 0195a515bd789f9d238f1034377cad6e2083cac7..cab6455ffcba0e552d43c223895d93c50d316cbe 100644 (file)
--- a/ext/phar/tar.c
+++ b/ext/phar/tar.c
@@ -615,7 +615,7 @@ bail:
 
        phar_request_initialize();
 
-       if (NULL == (actual = zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_fname_map), myphar->fname, fname_len, myphar))) {
+       if (NULL == (actual = zend_hash_str_add_ptr(&(PHAR_G(phar_fname_map)), myphar->fname, fname_len, myphar))) {
                if (error) {
                        spprintf(error, 4096, "phar error: Unable to add tar-based phar \"%s\" to phar registry", fname);
                }
@@ -631,31 +631,31 @@ bail:
 
                myphar->is_temporary_alias = 0;
 
-               if (NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_alias_map), actual_alias, myphar->alias_len))) {
+               if (NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_G(phar_alias_map)), actual_alias, myphar->alias_len))) {
                        if (SUCCESS != phar_free_alias(fd_ptr, actual_alias, myphar->alias_len)) {
                                if (error) {
                                        spprintf(error, 4096, "phar error: Unable to add tar-based phar \"%s\", alias is already in use", fname);
                                }
-                               zend_hash_str_del(&(PHAR_GLOBALS->phar_fname_map), myphar->fname, fname_len);
+                               zend_hash_str_del(&(PHAR_G(phar_fname_map)), myphar->fname, fname_len);
                                return FAILURE;
                        }
                }
 
-               zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_alias_map), actual_alias, myphar->alias_len, myphar);
+               zend_hash_str_add_ptr(&(PHAR_G(phar_alias_map)), actual_alias, myphar->alias_len, myphar);
        } else {
                phar_archive_data *fd_ptr;
 
                if (alias_len) {
-                       if (NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len))) {
+                       if (NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_G(phar_alias_map)), alias, alias_len))) {
                                if (SUCCESS != phar_free_alias(fd_ptr, alias, alias_len)) {
                                        if (error) {
                                                spprintf(error, 4096, "phar error: Unable to add tar-based phar \"%s\", alias is already in use", fname);
                                        }
-                                       zend_hash_str_del(&(PHAR_GLOBALS->phar_fname_map), myphar->fname, fname_len);
+                                       zend_hash_str_del(&(PHAR_G(phar_fname_map)), myphar->fname, fname_len);
                                        return FAILURE;
                                }
                        }
-                       zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len, myphar);
+                       zend_hash_str_add_ptr(&(PHAR_G(phar_alias_map)), alias, alias_len, myphar);
                        myphar->alias = pestrndup(alias, alias_len, myphar->is_persistent);
                        myphar->alias_len = alias_len;
                } else {

diff --git a/ext/phar/util.c b/ext/phar/util.c
index f769b012e4acb424ae0e0f6c6631baa4cb9b69b8..1b657de67eaa02928a7922ecc604571ec7f16ddc 100644 (file)
--- a/ext/phar/util.c
+++ b/ext/phar/util.c
@@ -327,7 +327,7 @@ splitted:
                        return ret;
                }
 
-               *pphar = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_fname_map), arch, arch_len);
+               *pphar = zend_hash_str_find_ptr(&(PHAR_G(phar_fname_map)), arch, arch_len);
 
                if (!*pphar && PHAR_G(manifest_cached)) {
                        *pphar = zend_hash_str_find_ptr(&cached_phars, arch, arch_len);
@@ -924,8 +924,8 @@ phar_entry_info * phar_open_jit(phar_archive_data *phar, phar_entry_info *entry,
 
 PHP_PHAR_API int phar_resolve_alias(char *alias, int alias_len, char **filename, int *filename_len) /* {{{ */ {
        phar_archive_data *fd_ptr;
-       if (PHAR_GLOBALS->phar_alias_map.u.flags
-                       && NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len))) {
+       if (PHAR_G(phar_alias_map.u.flags)
+                       && NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_G(phar_alias_map)), alias, alias_len))) {
                *filename = fd_ptr->fname;
                *filename_len = fd_ptr->fname_len;
                return SUCCESS;
@@ -941,7 +941,7 @@ int phar_free_alias(phar_archive_data *phar, char *alias, int alias_len) /* {{{
        }
 
        /* this archive has no open references, so emit an E_STRICT and remove it */
-       if (zend_hash_str_del(&(PHAR_GLOBALS->phar_fname_map), phar->fname, phar->fname_len) != SUCCESS) {
+       if (zend_hash_str_del(&(PHAR_G(phar_fname_map)), phar->fname, phar->fname_len) != SUCCESS) {
                return FAILURE;
        }
 
@@ -983,11 +983,11 @@ int phar_get_archive(phar_archive_data **archive, char *fname, int fname_len, ch
                                return FAILURE;
                        }
 
-                       if (PHAR_G(last_phar)->alias_len && NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_alias_map), PHAR_G(last_phar)->alias, PHAR_G(last_phar)->alias_len))) {
-                               zend_hash_str_del(&(PHAR_GLOBALS->phar_alias_map), PHAR_G(last_phar)->alias, PHAR_G(last_phar)->alias_len);
+                       if (PHAR_G(last_phar)->alias_len && NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_G(phar_alias_map)), PHAR_G(last_phar)->alias, PHAR_G(last_phar)->alias_len))) {
+                               zend_hash_str_del(&(PHAR_G(phar_alias_map)), PHAR_G(last_phar)->alias, PHAR_G(last_phar)->alias_len);
                        }
 
-                       zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len, *archive);
+                       zend_hash_str_add_ptr(&(PHAR_G(phar_alias_map)), alias, alias_len, *archive);
                        PHAR_G(last_alias) = alias;
                        PHAR_G(last_alias_len) = alias_len;
                }
@@ -1002,7 +1002,7 @@ int phar_get_archive(phar_archive_data **archive, char *fname, int fname_len, ch
        }
 
        if (alias && alias_len) {
-               if (NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len))) {
+               if (NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_G(phar_alias_map)), alias, alias_len))) {
 alias_success:
                        if (fname && (fname_len != fd_ptr->fname_len || strncmp(fname, fd_ptr->fname, fname_len))) {
                                if (error) {
@@ -1038,7 +1038,7 @@ alias_success:
        save_len = fname_len;
 
        if (fname && fname_len) {
-               if (NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_fname_map), fname, fname_len))) {
+               if (NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_G(phar_fname_map)), fname, fname_len))) {
                        *archive = fd_ptr;
                        fd = fd_ptr;
 
@@ -1050,11 +1050,11 @@ alias_success:
                                        return FAILURE;
                                }
 
-                               if (fd->alias_len && NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_alias_map), fd->alias, fd->alias_len))) {
-                                       zend_hash_str_del(&(PHAR_GLOBALS->phar_alias_map), fd->alias, fd->alias_len);
+                               if (fd->alias_len && NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_G(phar_alias_map)), fd->alias, fd->alias_len))) {
+                                       zend_hash_str_del(&(PHAR_G(phar_alias_map)), fd->alias, fd->alias_len);
                                }
 
-                               zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len, fd);
+                               zend_hash_str_add_ptr(&(PHAR_G(phar_alias_map)), alias, alias_len, fd);
                        }
 
                        PHAR_G(last_phar) = fd;
@@ -1090,7 +1090,7 @@ alias_success:
                        return SUCCESS;
                }
 
-               if (NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_alias_map), save, save_len))) {
+               if (NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_G(phar_alias_map)), save, save_len))) {
                        fd = *archive = fd_ptr;
 
                        PHAR_G(last_phar) = fd;
@@ -1127,13 +1127,13 @@ alias_success:
                phar_unixify_path_separators(fname, fname_len);
 #endif
 
-               if (NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_fname_map), fname, fname_len))) {
+               if (NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_G(phar_fname_map)), fname, fname_len))) {
 realpath_success:
                        *archive = fd_ptr;
                        fd = fd_ptr;
 
                        if (alias && alias_len) {
-                               zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len, fd);
+                               zend_hash_str_add_ptr(&(PHAR_G(phar_alias_map)), alias, alias_len, fd);
                        }
 
                        efree(my_realpath);
@@ -2018,7 +2018,7 @@ static void phar_copy_cached_phar(phar_archive_data **pphar) /* {{{ */
        *pphar = phar;
 
        /* now, scan the list of persistent Phar objects referencing this phar and update the pointers */
-       ZEND_HASH_FOREACH_PTR(&PHAR_GLOBALS->phar_persist_map, objphar) {
+       ZEND_HASH_FOREACH_PTR(&PHAR_G(phar_persist_map), objphar) {
                if (objphar->archive->fname_len == phar->fname_len && !memcmp(objphar->archive->fname, phar->fname, phar->fname_len)) {
                        objphar->archive = phar;
                }
@@ -2032,7 +2032,7 @@ int phar_copy_on_write(phar_archive_data **pphar) /* {{{ */
        phar_archive_data *newpphar;
 
        ZVAL_PTR(&zv, *pphar);
-       if (NULL == (pzv = zend_hash_str_add(&(PHAR_GLOBALS->phar_fname_map), (*pphar)->fname, (*pphar)->fname_len, &zv))) {
+       if (NULL == (pzv = zend_hash_str_add(&(PHAR_G(phar_fname_map)), (*pphar)->fname, (*pphar)->fname_len, &zv))) {
                return FAILURE;
        }
 
@@ -2042,8 +2042,8 @@ int phar_copy_on_write(phar_archive_data **pphar) /* {{{ */
        PHAR_G(last_phar) = NULL;
        PHAR_G(last_phar_name) = PHAR_G(last_alias) = NULL;
 
-       if (newpphar->alias_len && NULL == zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_alias_map), newpphar->alias, newpphar->alias_len, newpphar)) {
-               zend_hash_str_del(&(PHAR_GLOBALS->phar_fname_map), (*pphar)->fname, (*pphar)->fname_len);
+       if (newpphar->alias_len && NULL == zend_hash_str_add_ptr(&(PHAR_G(phar_alias_map)), newpphar->alias, newpphar->alias_len, newpphar)) {
+               zend_hash_str_del(&(PHAR_G(phar_fname_map)), (*pphar)->fname, (*pphar)->fname_len);
                return FAILURE;
        }
 

diff --git a/ext/phar/zip.c b/ext/phar/zip.c
index 4b46f5718332cea32a270d14d28c930ac5c3fcf7..f7d6c25c72f9a1e784c3f5614d8f92e7c63f532e 100644 (file)
--- a/ext/phar/zip.c
+++ b/ext/phar/zip.c
@@ -669,7 +669,7 @@ foundit:
                mydata->is_data = 1;
        }
 
-       zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_fname_map), mydata->fname, fname_len, mydata);
+       zend_hash_str_add_ptr(&(PHAR_G(phar_fname_map)), mydata->fname, fname_len, mydata);
 
        if (actual_alias) {
                phar_archive_data *fd_ptr;
@@ -679,19 +679,19 @@ foundit:
                                spprintf(error, 4096, "phar error: invalid alias \"%s\" in zip-based phar \"%s\"", actual_alias, fname);
                        }
                        efree(actual_alias);
-                       zend_hash_str_del(&(PHAR_GLOBALS->phar_fname_map), mydata->fname, fname_len);
+                       zend_hash_str_del(&(PHAR_G(phar_fname_map)), mydata->fname, fname_len);
                        return FAILURE;
                }
 
                mydata->is_temporary_alias = 0;
 
-               if (NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_alias_map), actual_alias, mydata->alias_len))) {
+               if (NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_G(phar_alias_map)), actual_alias, mydata->alias_len))) {
                        if (SUCCESS != phar_free_alias(fd_ptr, actual_alias, mydata->alias_len)) {
                                if (error) {
                                        spprintf(error, 4096, "phar error: Unable to add zip-based phar \"%s\" with implicit alias, alias is already in use", fname);
                                }
                                efree(actual_alias);
-                               zend_hash_str_del(&(PHAR_GLOBALS->phar_fname_map), mydata->fname, fname_len);
+                               zend_hash_str_del(&(PHAR_G(phar_fname_map)), mydata->fname, fname_len);
                                return FAILURE;
                        }
                }
@@ -702,22 +702,22 @@ foundit:
                        efree(actual_alias);
                }
 
-               zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_alias_map), actual_alias, mydata->alias_len, mydata);
+               zend_hash_str_add_ptr(&(PHAR_G(phar_alias_map)), actual_alias, mydata->alias_len, mydata);
        } else {
                phar_archive_data *fd_ptr;
 
                if (alias_len) {
-                       if (NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len))) {
+                       if (NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_G(phar_alias_map)), alias, alias_len))) {
                                if (SUCCESS != phar_free_alias(fd_ptr, alias, alias_len)) {
                                        if (error) {
                                                spprintf(error, 4096, "phar error: Unable to add zip-based phar \"%s\" with explicit alias, alias is already in use", fname);
                                        }
-                                       zend_hash_str_del(&(PHAR_GLOBALS->phar_fname_map), mydata->fname, fname_len);
+                                       zend_hash_str_del(&(PHAR_G(phar_fname_map)), mydata->fname, fname_len);
                                        return FAILURE;
                                }
                        }
 
-                       zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_alias_map), actual_alias, mydata->alias_len, mydata);
+                       zend_hash_str_add_ptr(&(PHAR_G(phar_alias_map)), actual_alias, mydata->alias_len, mydata);
                        mydata->alias = pestrndup(alias, alias_len, mydata->is_persistent);
                        mydata->alias_len = alias_len;
                } else {