Commit:    e6b228332f3cd7b9e3a5f3ba8a8e08ae1b01abdf
Author:    Nikita Popov <ni...@php.net>         Fri, 13 Sep 2013 21:21:23 +0200
Parents:   39bd738fbffb1270494e3724a7f9d52b409c56dd
Branches:  master

Link:       
http://git.php.net/?p=php-src.git;a=commitdiff;h=e6b228332f3cd7b9e3a5f3ba8a8e08ae1b01abdf

Log:
Remove PHAR_(Z)STR* usages

Changed paths:
  M  ext/phar/dirstream.c
  M  ext/phar/phar.c
  M  ext/phar/phar_internal.h
  M  ext/phar/stream.c
  M  ext/phar/util.c

diff --git a/ext/phar/dirstream.c b/ext/phar/dirstream.c
index b090577..62b19a7 100644
--- a/ext/phar/dirstream.c
+++ b/ext/phar/dirstream.c
@@ -94,31 +94,23 @@ static size_t phar_dir_read(php_stream *stream, char *buf, 
size_t count TSRMLS_D
 {
        size_t to_read;
        HashTable *data = (HashTable *)stream->abstract;
-       phar_zstr key;
        char *str_key;
        uint keylen;
        ulong unused;
 
-       if (FAILURE == zend_hash_has_more_elements(data)) {
+       if (HASH_KEY_NON_EXISTENT == zend_hash_get_current_key_ex(data, 
&str_key, &keylen, &unused, 0, NULL)) {
                return 0;
        }
 
-       if (HASH_KEY_NON_EXISTENT == zend_hash_get_current_key_ex(data, &key, 
&keylen, &unused, 0, NULL)) {
-               return 0;
-       }
-
-       PHAR_STR(key, str_key);
        zend_hash_move_forward(data);
        to_read = MIN(keylen, count);
 
        if (to_read == 0 || count < keylen) {
-               PHAR_STR_FREE(str_key);
                return 0;
        }
 
        memset(buf, 0, sizeof(php_stream_dirent));
        memcpy(((php_stream_dirent *) buf)->d_name, str_key, to_read);
-       PHAR_STR_FREE(str_key);
        ((php_stream_dirent *) buf)->d_name[to_read + 1] = '\0';
 
        return sizeof(php_stream_dirent);
@@ -193,13 +185,12 @@ static php_stream *phar_make_dirstream(char *dir, 
HashTable *manifest TSRMLS_DC)
 {
        HashTable *data;
        int dirlen = strlen(dir);
-       phar_zstr key;
        char *entry, *found, *save, *str_key;
        uint keylen;
        ulong unused;
 
        ALLOC_HASHTABLE(data);
-       zend_hash_init(data, 64, zend_get_hash_value, NULL, 0);
+       zend_hash_init(data, 64, NULL, NULL, 0);
 
        if ((*dir == '/' && dirlen == 1 && (manifest->nNumOfElements == 0)) || 
(dirlen >= sizeof(".phar")-1 && !memcmp(dir, ".phar", sizeof(".phar")-1))) {
                /* make empty root directory for empty phar */
@@ -211,15 +202,12 @@ static php_stream *phar_make_dirstream(char *dir, 
HashTable *manifest TSRMLS_DC)
        zend_hash_internal_pointer_reset(manifest);
 
        while (FAILURE != zend_hash_has_more_elements(manifest)) {
-               if (HASH_KEY_NON_EXISTENT == 
zend_hash_get_current_key_ex(manifest, &key, &keylen, &unused, 0, NULL)) {
+               if (HASH_KEY_NON_EXISTENT == 
zend_hash_get_current_key_ex(manifest, &str_key, &keylen, &unused, 0, NULL)) {
                        break;
                }
 
-               PHAR_STR(key, str_key);
-
                if (keylen <= (uint)dirlen) {
                        if (keylen < (uint)dirlen || !strncmp(str_key, dir, 
dirlen)) {
-                               PHAR_STR_FREE(str_key);
                                if (SUCCESS != 
zend_hash_move_forward(manifest)) {
                                        break;
                                }
@@ -230,7 +218,6 @@ static php_stream *phar_make_dirstream(char *dir, HashTable 
*manifest TSRMLS_DC)
                if (*dir == '/') {
                        /* root directory */
                        if (keylen >= sizeof(".phar")-1 && !memcmp(str_key, 
".phar", sizeof(".phar")-1)) {
-                               PHAR_STR_FREE(str_key);
                                /* do not add any magic entries to this 
directory */
                                if (SUCCESS != 
zend_hash_move_forward(manifest)) {
                                        break;
@@ -250,19 +237,16 @@ static php_stream *phar_make_dirstream(char *dir, 
HashTable *manifest TSRMLS_DC)
                                entry[keylen] = '\0';
                        }
 
-                       PHAR_STR_FREE(str_key);
                        goto PHAR_ADD_ENTRY;
                } else {
                        if (0 != memcmp(str_key, dir, dirlen)) {
                                /* entry in directory not found */
-                               PHAR_STR_FREE(str_key);
                                if (SUCCESS != 
zend_hash_move_forward(manifest)) {
                                        break;
                                }
                                continue;
                        } else {
                                if (str_key[dirlen] != '/') {
-                                       PHAR_STR_FREE(str_key);
                                        if (SUCCESS != 
zend_hash_move_forward(manifest)) {
                                                break;
                                        }
@@ -289,7 +273,6 @@ static php_stream *phar_make_dirstream(char *dir, HashTable 
*manifest TSRMLS_DC)
                        entry[keylen - dirlen - 1] = '\0';
                        keylen = keylen - dirlen - 1;
                }
-               PHAR_STR_FREE(str_key);
 PHAR_ADD_ENTRY:
                if (keylen) {
                        phar_add_empty(data, entry, keylen);
@@ -324,7 +307,6 @@ php_stream *phar_wrapper_open_dir(php_stream_wrapper 
*wrapper, const char *path,
        php_url *resource = NULL;
        php_stream *ret;
        char *internal_file, *error, *str_key;
-       phar_zstr key;
        uint keylen;
        ulong unused;
        phar_archive_data *phar;
@@ -405,17 +387,14 @@ php_stream *phar_wrapper_open_dir(php_stream_wrapper 
*wrapper, const char *path,
                while (FAILURE != zend_hash_has_more_elements(&phar->manifest)) 
{
                        if (HASH_KEY_NON_EXISTENT != 
                                        zend_hash_get_current_key_ex(
-                                               &phar->manifest, &key, &keylen, 
&unused, 0, NULL)) {
-                               PHAR_STR(key, str_key);
+                                               &phar->manifest, &str_key, 
&keylen, &unused, 0, NULL)) {
                                if (keylen > (uint)i_len && 0 == 
memcmp(str_key, internal_file, i_len)) {
-                                       PHAR_STR_FREE(str_key);
                                        /* directory found */
                                        internal_file = estrndup(internal_file,
                                                        i_len);
                                        php_url_free(resource);
                                        return 
phar_make_dirstream(internal_file, &phar->manifest TSRMLS_CC);
                                }
-                               PHAR_STR_FREE(str_key);
                        }
 
                        if (SUCCESS != zend_hash_move_forward(&phar->manifest)) 
{
@@ -572,7 +551,6 @@ int phar_wrapper_rmdir(php_stream_wrapper *wrapper, const 
char *url, int options
        int arch_len, entry_len;
        php_url *resource = NULL;
        uint host_len;
-       phar_zstr key;
        char *str_key;
        uint key_len;
        ulong unused;
@@ -637,15 +615,12 @@ int phar_wrapper_rmdir(php_stream_wrapper *wrapper, const 
char *url, int options
 
        if (!entry->is_deleted) {
                for (zend_hash_internal_pointer_reset(&phar->manifest);
-               HASH_KEY_NON_EXISTENT != 
zend_hash_get_current_key_ex(&phar->manifest, &key, &key_len, &unused, 0, NULL);
-               zend_hash_move_forward(&phar->manifest)) {
-
-                       PHAR_STR(key, str_key);
-
+                       HASH_KEY_NON_EXISTENT != 
zend_hash_get_current_key_ex(&phar->manifest, &str_key, &key_len, &unused, 0, 
NULL);
+                       zend_hash_move_forward(&phar->manifest)
+               ) {
                        if (key_len > path_len && 
                                memcmp(str_key, resource->path+1, path_len) == 
0 && 
                                IS_SLASH(str_key[path_len])) {
-                               PHAR_STR_FREE(str_key);
                                php_stream_wrapper_log_error(wrapper, options 
TSRMLS_CC, "phar error: Directory not empty");
                                if (entry->is_temp_dir) {
                                        efree(entry->filename);
@@ -654,19 +629,15 @@ int phar_wrapper_rmdir(php_stream_wrapper *wrapper, const 
char *url, int options
                                php_url_free(resource);
                                return 0;
                        }
-                       PHAR_STR_FREE(str_key);
                }
 
                for (zend_hash_internal_pointer_reset(&phar->virtual_dirs);
-                       HASH_KEY_NON_EXISTENT != 
zend_hash_get_current_key_ex(&phar->virtual_dirs, &key, &key_len, &unused, 0, 
NULL);
+                       HASH_KEY_NON_EXISTENT != 
zend_hash_get_current_key_ex(&phar->virtual_dirs, &str_key, &key_len, &unused, 
0, NULL);
                        zend_hash_move_forward(&phar->virtual_dirs)) {
        
-                       PHAR_STR(key, str_key);
-       
                        if (key_len > path_len && 
                                memcmp(str_key, resource->path+1, path_len) == 
0 && 
                                IS_SLASH(str_key[path_len])) {
-                               PHAR_STR_FREE(str_key);
                                php_stream_wrapper_log_error(wrapper, options 
TSRMLS_CC, "phar error: Directory not empty");
                                if (entry->is_temp_dir) {
                                        efree(entry->filename);
@@ -675,7 +646,6 @@ int phar_wrapper_rmdir(php_stream_wrapper *wrapper, const 
char *url, int options
                                php_url_free(resource);
                                return 0;
                        }
-                       PHAR_STR_FREE(str_key);
                }
        }
 
diff --git a/ext/phar/phar.c b/ext/phar/phar.c
index c0d23f1..4de1aed 100644
--- a/ext/phar/phar.c
+++ b/ext/phar/phar.c
@@ -1954,67 +1954,45 @@ woohoo:
                                goto woohoo;
                        }
                } else {
-                       phar_zstr key;
                        char *str_key;
                        uint keylen;
                        ulong unused;
 
-                       
zend_hash_internal_pointer_reset(&(PHAR_GLOBALS->phar_fname_map));
-
-                       while (FAILURE != 
zend_hash_has_more_elements(&(PHAR_GLOBALS->phar_fname_map))) {
-                               if (HASH_KEY_NON_EXISTENT == 
zend_hash_get_current_key_ex(&(PHAR_GLOBALS->phar_fname_map), &key, &keylen, 
&unused, 0, NULL)) {
-                                       break;
-                               }
-
-                               PHAR_STR(key, str_key);
-
+                       for 
(zend_hash_internal_pointer_reset(&(PHAR_GLOBALS->phar_fname_map));
+                               HASH_KEY_NON_EXISTENT != 
zend_hash_get_current_key_ex(&(PHAR_GLOBALS->phar_fname_map), &str_key, 
&keylen, &unused, 0, NULL);
+                               
zend_hash_move_forward(&(PHAR_GLOBALS->phar_fname_map))
+                       ) {
                                if (keylen > (uint) filename_len) {
-                                       
zend_hash_move_forward(&(PHAR_GLOBALS->phar_fname_map));
-                                       PHAR_STR_FREE(str_key);
                                        continue;
                                }
 
                                if (!memcmp(filename, str_key, keylen) && 
((uint)filename_len == keylen
                                        || filename[keylen] == '/' || 
filename[keylen] == '\0')) {
-                                       PHAR_STR_FREE(str_key);
                                        if (FAILURE == 
zend_hash_get_current_data(&(PHAR_GLOBALS->phar_fname_map), (void **) &pphar)) {
                                                break;
                                        }
                                        *ext_str = filename + (keylen - 
(*pphar)->ext_len);
                                        goto woohoo;
                                }
-
-                               PHAR_STR_FREE(str_key);
-                               
zend_hash_move_forward(&(PHAR_GLOBALS->phar_fname_map));
                        }
 
                        if (PHAR_G(manifest_cached)) {
-                               zend_hash_internal_pointer_reset(&cached_phars);
-
-                               while (FAILURE != 
zend_hash_has_more_elements(&cached_phars)) {
-                                       if (HASH_KEY_NON_EXISTENT == 
zend_hash_get_current_key_ex(&cached_phars, &key, &keylen, &unused, 0, NULL)) {
-                                               break;
-                                       }
-
-                                       PHAR_STR(key, str_key);
-
+                               for 
(zend_hash_internal_pointer_reset(&cached_phars);
+                                       HASH_KEY_NON_EXISTENT != 
zend_hash_get_current_key_ex(&cached_phars, &str_key, &keylen, &unused, 0, 
NULL);
+                                       zend_hash_move_forward(&cached_phars)
+                               ) {
                                        if (keylen > (uint) filename_len) {
-                                               
zend_hash_move_forward(&cached_phars);
-                                               PHAR_STR_FREE(str_key);
                                                continue;
                                        }
 
                                        if (!memcmp(filename, str_key, keylen) 
&& ((uint)filename_len == keylen
                                                || filename[keylen] == '/' || 
filename[keylen] == '\0')) {
-                                               PHAR_STR_FREE(str_key);
                                                if (FAILURE == 
zend_hash_get_current_data(&cached_phars, (void **) &pphar)) {
                                                        break;
                                                }
                                                *ext_str = filename + (keylen - 
(*pphar)->ext_len);
                                                goto woohoo;
                                        }
-                                       PHAR_STR_FREE(str_key);
-                                       zend_hash_move_forward(&cached_phars);
                                }
                        }
                }
diff --git a/ext/phar/phar_internal.h b/ext/phar/phar_internal.h
index 431628a..d12de71 100644
--- a/ext/phar/phar_internal.h
+++ b/ext/phar/phar_internal.h
@@ -518,13 +518,6 @@ extern char *(*phar_save_resolve_path)(const char 
*filename, int filename_len TS
 
 #define phar_stream_copy_to_stream(src, dest, maxlen, len)     
_php_stream_copy_to_stream_ex((src), (dest), (maxlen), (len) STREAMS_CC 
TSRMLS_CC)
 
-typedef char *phar_zstr;
-#define PHAR_STR(a, b) \
-       b = a;
-#define PHAR_ZSTR(a, b)        \
-       b = a;
-#define PHAR_STR_FREE(a)
-
 BEGIN_EXTERN_C()
 
 #ifdef PHP_WIN32
diff --git a/ext/phar/stream.c b/ext/phar/stream.c
index 74d7fc4..1b353e0 100644
--- a/ext/phar/stream.c
+++ b/ext/phar/stream.c
@@ -627,21 +627,16 @@ static int phar_wrapper_stat(php_stream_wrapper *wrapper, 
const char *url, int f
        }
        /* check for mounted directories */
        if (phar->mounted_dirs.arBuckets && 
zend_hash_num_elements(&phar->mounted_dirs)) {
-               phar_zstr key;
                char *str_key;
                ulong unused;
                uint keylen;
                HashPosition pos;
 
-               zend_hash_internal_pointer_reset_ex(&phar->mounted_dirs, &pos);
-               while (FAILURE != 
zend_hash_has_more_elements_ex(&phar->mounted_dirs, &pos)) {
-                       if (HASH_KEY_NON_EXISTENT == 
zend_hash_get_current_key_ex(&phar->mounted_dirs, &key, &keylen, &unused, 0, 
&pos)) {
-                               break;
-                       }
-                       PHAR_STR(key, str_key);
+               for (zend_hash_internal_pointer_reset_ex(&phar->mounted_dirs, 
&pos);
+                       HASH_KEY_NON_EXISTENT != 
zend_hash_get_current_key_ex(&phar->mounted_dirs, &str_key, &keylen, &unused, 
0, &pos);
+                       zend_hash_move_forward_ex(&phar->mounted_dirs, &pos)
+               ) {
                        if ((int)keylen >= internal_file_len || 
strncmp(str_key, internal_file, keylen)) {
-                               zend_hash_move_forward_ex(&phar->mounted_dirs, 
&pos);
-                               PHAR_STR_FREE(str_key);
                                continue;
                        } else {
                                char *test;
@@ -649,17 +644,14 @@ static int phar_wrapper_stat(php_stream_wrapper *wrapper, 
const char *url, int f
                                php_stream_statbuf ssbi;
 
                                if (SUCCESS != zend_hash_find(&phar->manifest, 
str_key, keylen, (void **) &entry)) {
-                                       PHAR_STR_FREE(str_key);
                                        goto free_resource;
                                }
-                               PHAR_STR_FREE(str_key);
                                if (!entry->tmp || !entry->is_mounted) {
                                        goto free_resource;
                                }
                                test_len = spprintf(&test, MAXPATHLEN, "%s%s", 
entry->tmp, internal_file + keylen);
                                if (SUCCESS != php_stream_stat_path(test, 
&ssbi)) {
                                        efree(test);
-                                       
zend_hash_move_forward_ex(&phar->mounted_dirs, &pos);
                                        continue;
                                }
                                /* mount the file/directory just in time */
@@ -910,7 +902,6 @@ static int phar_wrapper_rename(php_stream_wrapper *wrapper, 
const char *url_from
        /* Rename directory. Update all nested paths */
        if (is_dir) {
                int key_type;
-               phar_zstr key, new_key;
                char *str_key, *new_str_key;
                uint key_len, new_key_len;
                ulong unused;
@@ -918,12 +909,10 @@ static int phar_wrapper_rename(php_stream_wrapper 
*wrapper, const char *url_from
                uint to_len = strlen(resource_to->path+1);
 
                for (zend_hash_internal_pointer_reset(&phar->manifest);
-                       HASH_KEY_NON_EXISTENT != (key_type = 
zend_hash_get_current_key_ex(&phar->manifest, &key, &key_len, &unused, 0, 
NULL)) &&
+                       HASH_KEY_NON_EXISTENT != (key_type = 
zend_hash_get_current_key_ex(&phar->manifest, &str_key, &key_len, &unused, 0, 
NULL)) &&
                        SUCCESS == zend_hash_get_current_data(&phar->manifest, 
(void **) &entry);
-                       zend_hash_move_forward(&phar->manifest)) {
-
-                       PHAR_STR(key, str_key);
-
+                       zend_hash_move_forward(&phar->manifest)
+               ) {
                        if (!entry->is_deleted &&
                                key_len > from_len &&
                                memcmp(str_key, resource_from->path+1, 
from_len) == 0 &&
@@ -941,18 +930,14 @@ static int phar_wrapper_rename(php_stream_wrapper 
*wrapper, const char *url_from
                                entry->filename = new_str_key;
                                entry->filename_len = new_key_len;
 
-                               PHAR_ZSTR(new_str_key, new_key);
-                               
zend_hash_update_current_key_ex(&phar->manifest, key_type, new_key, 
new_key_len, 0, HASH_UPDATE_KEY_ANYWAY, NULL);
+                               
zend_hash_update_current_key_ex(&phar->manifest, key_type, new_str_key, 
new_key_len, 0, HASH_UPDATE_KEY_ANYWAY, NULL);
                        }
-                       PHAR_STR_FREE(str_key);
                }
 
                for (zend_hash_internal_pointer_reset(&phar->virtual_dirs);
-                       HASH_KEY_NON_EXISTENT != (key_type = 
zend_hash_get_current_key_ex(&phar->virtual_dirs, &key, &key_len, &unused, 0, 
NULL));
-                       zend_hash_move_forward(&phar->virtual_dirs)) {
-
-                       PHAR_STR(key, str_key);
-
+                       HASH_KEY_NON_EXISTENT != (key_type = 
zend_hash_get_current_key_ex(&phar->virtual_dirs, &str_key, &key_len, &unused, 
0, NULL));
+                       zend_hash_move_forward(&phar->virtual_dirs)
+               ) {
                        if (key_len >= from_len &&
                                memcmp(str_key, resource_from->path+1, 
from_len) == 0 &&
                                (key_len == from_len || 
IS_SLASH(str_key[from_len]))) {
@@ -963,20 +948,16 @@ static int phar_wrapper_rename(php_stream_wrapper 
*wrapper, const char *url_from
                                memcpy(new_str_key + to_len, str_key + 
from_len, key_len - from_len);
                                new_str_key[new_key_len] = 0;
 
-                               PHAR_ZSTR(new_str_key, new_key);
-                               
zend_hash_update_current_key_ex(&phar->virtual_dirs, key_type, new_key, 
new_key_len, 0, HASH_UPDATE_KEY_ANYWAY, NULL);
+                               
zend_hash_update_current_key_ex(&phar->virtual_dirs, key_type, new_str_key, 
new_key_len, 0, HASH_UPDATE_KEY_ANYWAY, NULL);
                                efree(new_str_key);
                        }
-                       PHAR_STR_FREE(str_key);
                }
 
                for (zend_hash_internal_pointer_reset(&phar->mounted_dirs);
-                       HASH_KEY_NON_EXISTENT != (key_type = 
zend_hash_get_current_key_ex(&phar->mounted_dirs, &key, &key_len, &unused, 0, 
NULL)) &&
+                       HASH_KEY_NON_EXISTENT != (key_type = 
zend_hash_get_current_key_ex(&phar->mounted_dirs, &str_key, &key_len, &unused, 
0, NULL)) &&
                        SUCCESS == 
zend_hash_get_current_data(&phar->mounted_dirs, (void **) &entry);
-                       zend_hash_move_forward(&phar->mounted_dirs)) {
-
-                       PHAR_STR(key, str_key);
-
+                       zend_hash_move_forward(&phar->mounted_dirs)
+               ) {
                        if (key_len >= from_len &&
                                memcmp(str_key, resource_from->path+1, 
from_len) == 0 &&
                                (key_len == from_len || 
IS_SLASH(str_key[from_len]))) {
@@ -987,11 +968,9 @@ static int phar_wrapper_rename(php_stream_wrapper 
*wrapper, const char *url_from
                                memcpy(new_str_key + to_len, str_key + 
from_len, key_len - from_len);
                                new_str_key[new_key_len] = 0;
 
-                               PHAR_ZSTR(new_str_key, new_key);
-                               
zend_hash_update_current_key_ex(&phar->mounted_dirs, key_type, new_key, 
new_key_len, 0, HASH_UPDATE_KEY_ANYWAY, NULL);
+                               
zend_hash_update_current_key_ex(&phar->mounted_dirs, key_type, new_str_key, 
new_key_len, 0, HASH_UPDATE_KEY_ANYWAY, NULL);
                                efree(new_str_key);
                        }
-                       PHAR_STR_FREE(str_key);
                }
        }
 
diff --git a/ext/phar/util.c b/ext/phar/util.c
index e115d0d..bf094af 100644
--- a/ext/phar/util.c
+++ b/ext/phar/util.c
@@ -1289,21 +1289,17 @@ phar_entry_info 
*phar_get_entry_info_dir(phar_archive_data *phar, char *path, in
        }
 
        if (phar->mounted_dirs.arBuckets && 
zend_hash_num_elements(&phar->mounted_dirs)) {
-               phar_zstr key;
                char *str_key;
                ulong unused;
                uint keylen;
 
                zend_hash_internal_pointer_reset(&phar->mounted_dirs);
                while (FAILURE != 
zend_hash_has_more_elements(&phar->mounted_dirs)) {
-                       if (HASH_KEY_NON_EXISTENT == 
zend_hash_get_current_key_ex(&phar->mounted_dirs, &key, &keylen, &unused, 0, 
NULL)) {
+                       if (HASH_KEY_NON_EXISTENT == 
zend_hash_get_current_key_ex(&phar->mounted_dirs, &str_key, &keylen, &unused, 
0, NULL)) {
                                break;
                        }
 
-                       PHAR_STR(key, str_key);
-
                        if ((int)keylen >= path_len || strncmp(str_key, path, 
keylen)) {
-                               PHAR_STR_FREE(str_key);
                                continue;
                        } else {
                                char *test;
@@ -1314,7 +1310,6 @@ phar_entry_info 
*phar_get_entry_info_dir(phar_archive_data *phar, char *path, in
                                        if (error) {
                                                spprintf(error, 4096, "phar 
internal error: mounted path \"%s\" could not be retrieved from manifest", 
str_key);
                                        }
-                                       PHAR_STR_FREE(str_key);
                                        return NULL;
                                }
 
@@ -1322,10 +1317,8 @@ phar_entry_info 
*phar_get_entry_info_dir(phar_archive_data *phar, char *path, in
                                        if (error) {
                                                spprintf(error, 4096, "phar 
internal error: mounted path \"%s\" is not properly initialized as a mounted 
path", str_key);
                                        }
-                                       PHAR_STR_FREE(str_key);
                                        return NULL;
                                }
-                               PHAR_STR_FREE(str_key);
 
                                test_len = spprintf(&test, MAXPATHLEN, "%s%s", 
entry->tmp, path + keylen);
-- 
PHP CVS Mailing List (http://www.php.net/)
To unsubscribe, visit: http://www.php.net/unsub.php

Reply via email to