- Create two new macro's. ALLOC_ZVAL() and FREE_ZVAL(z) and make Zend use

  them.

diff --git a/Zend/zend.h b/Zend/zend.h
index 7a984c3ffbfc2ed8db2c8205ce4807725c503d26..a97f473f9e98087f233132cdaa3943640b368af2 100644 (file)
--- a/Zend/zend.h
+++ b/Zend/zend.h
@@ -284,12 +284,16 @@ END_EXTERN_C()
 
 #define INIT_ZVAL(z) z = zval_used_for_init;
 
+#define ALLOC_ZVAL() (zval *) emalloc(sizeof(zval))
+
+#define FREE_ZVAL(z) efree(z)
+
 #define ALLOC_INIT_ZVAL(zp)                                            \
-       (zp) = (zval *) emalloc(sizeof(zval));          \
+       (zp) = ALLOC_ZVAL();            \
        INIT_ZVAL(*zp);
 
 #define MAKE_STD_ZVAL(zv)                               \
-       zv = (zval *) emalloc(sizeof(zval)); \
+       zv = ALLOC_ZVAL(); \
        INIT_PZVAL(zv);
 
 #define SEPARATE_ZVAL(ppzv)                                                                    \
@@ -298,7 +302,7 @@ END_EXTERN_C()
                                                                                                                        \
                if (orig_ptr->refcount>1) {                                                     \
                        orig_ptr->refcount--;                                                   \
-                       *(ppzv) = (zval *) emalloc(sizeof(zval));               \
+                       *(ppzv) = ALLOC_ZVAL();         \
                        **(ppzv) = *orig_ptr;                                                   \
                        zval_copy_ctor(*(ppzv));                                                \
                        (*(ppzv))->refcount=1;                                                  \
@@ -312,7 +316,7 @@ END_EXTERN_C()
                zval_copy_ctor(&(zv));                          \
                (pzv)->refcount--;                                      \
        } else {                                                                \
-               efree(pzv);                                                     \
+               FREE_ZVAL(pzv);                                                 \
        }                                                                               \
        INIT_PZVAL(&(zv));
 

diff --git a/Zend/zend_API.c b/Zend/zend_API.c
index e0d51cf554d10a70e05f5a905be8a21cb3d26f4a..70f891835ff9d71cd2103ba6011dbee4fb2b4422 100644 (file)
--- a/Zend/zend_API.c
+++ b/Zend/zend_API.c
@@ -58,7 +58,7 @@ ZEND_API int zend_get_parameters(int ht, int param_count,...)
                if (!PZVAL_IS_REF(param_ptr) && param_ptr->refcount>1) {
                        zval *new_tmp;
 
-                       new_tmp = (zval *) emalloc(sizeof(zval));
+                       new_tmp = ALLOC_ZVAL();
                        *new_tmp = *param_ptr;
                        zval_copy_ctor(new_tmp);
                        INIT_PZVAL(new_tmp);
@@ -95,7 +95,7 @@ ZEND_API int zend_get_parameters_array(int ht, int param_count, zval **argument_
                if (!PZVAL_IS_REF(param_ptr) && param_ptr->refcount>1) {
                        zval *new_tmp;
 
-                       new_tmp = (zval *) emalloc(sizeof(zval));
+                       new_tmp = ALLOC_ZVAL();
                        *new_tmp = *param_ptr;
                        zval_copy_ctor(new_tmp);
                        INIT_PZVAL(new_tmp);
@@ -230,7 +230,7 @@ ZEND_API inline int add_assoc_function(zval *arg, char *key,void (*function_ptr)
 
 ZEND_API inline int add_assoc_long(zval *arg, char *key, long n)
 {
-       zval *tmp = (zval *) emalloc(sizeof(zval));
+       zval *tmp = ALLOC_ZVAL();
 
        tmp->type = IS_LONG;
        tmp->value.lval = n;
@@ -241,7 +241,7 @@ ZEND_API inline int add_assoc_long(zval *arg, char *key, long n)
 
 ZEND_API inline int add_assoc_bool(zval *arg, char *key, int b)
 {
-       zval *tmp = (zval *) emalloc(sizeof(zval));
+       zval *tmp = ALLOC_ZVAL();
 
        tmp->type = IS_BOOL;
        tmp->value.lval = b;
@@ -252,7 +252,7 @@ ZEND_API inline int add_assoc_bool(zval *arg, char *key, int b)
 
 ZEND_API inline int add_assoc_resource(zval *arg, char *key, int r)
 {
-       zval *tmp = (zval *) emalloc(sizeof(zval));
+       zval *tmp = ALLOC_ZVAL();
 
        tmp->type = IS_RESOURCE;
        tmp->value.lval = r;
@@ -263,7 +263,7 @@ ZEND_API inline int add_assoc_resource(zval *arg, char *key, int r)
 
 ZEND_API inline int add_assoc_double(zval *arg, char *key, double d)
 {
-       zval *tmp = (zval *) emalloc(sizeof(zval));
+       zval *tmp = ALLOC_ZVAL();
 
        tmp->type = IS_DOUBLE;
        tmp->value.dval = d;
@@ -274,7 +274,7 @@ ZEND_API inline int add_assoc_double(zval *arg, char *key, double d)
 
 ZEND_API inline int add_assoc_string(zval *arg, char *key, char *str, int duplicate)
 {
-       zval *tmp = (zval *) emalloc(sizeof(zval));
+       zval *tmp = ALLOC_ZVAL();
 
        tmp->type = IS_STRING;
        tmp->value.str.len = strlen(str);
@@ -290,7 +290,7 @@ ZEND_API inline int add_assoc_string(zval *arg, char *key, char *str, int duplic
 
 ZEND_API inline int add_assoc_stringl(zval *arg, char *key, char *str, uint length, int duplicate)
 {
-       zval *tmp = (zval *) emalloc(sizeof(zval));
+       zval *tmp = ALLOC_ZVAL();
 
        tmp->type = IS_STRING;
        tmp->value.str.len = length;
@@ -306,7 +306,7 @@ ZEND_API inline int add_assoc_stringl(zval *arg, char *key, char *str, uint leng
 
 ZEND_API inline int add_index_long(zval *arg, uint index, long n)
 {
-       zval *tmp = (zval *) emalloc(sizeof(zval));
+       zval *tmp = ALLOC_ZVAL();
 
        tmp->type = IS_LONG;
        tmp->value.lval = n;
@@ -317,7 +317,7 @@ ZEND_API inline int add_index_long(zval *arg, uint index, long n)
 
 ZEND_API inline int add_index_bool(zval *arg, uint index, int b)
 {
-       zval *tmp = (zval *) emalloc(sizeof(zval));
+       zval *tmp = ALLOC_ZVAL();
 
        tmp->type = IS_BOOL;
        tmp->value.lval = b;
@@ -328,7 +328,7 @@ ZEND_API inline int add_index_bool(zval *arg, uint index, int b)
 
 ZEND_API inline int add_index_resource(zval *arg, uint index, int r)
 {
-       zval *tmp = (zval *) emalloc(sizeof(zval));
+       zval *tmp = ALLOC_ZVAL();
 
        tmp->type = IS_RESOURCE;
        tmp->value.lval = r;
@@ -339,7 +339,7 @@ ZEND_API inline int add_index_resource(zval *arg, uint index, int r)
 
 ZEND_API inline int add_index_double(zval *arg, uint index, double d)
 {
-       zval *tmp = (zval *) emalloc(sizeof(zval));
+       zval *tmp = ALLOC_ZVAL();
 
        tmp->type = IS_DOUBLE;
        tmp->value.dval = d;
@@ -350,7 +350,7 @@ ZEND_API inline int add_index_double(zval *arg, uint index, double d)
 
 ZEND_API inline int add_index_string(zval *arg, uint index, char *str, int duplicate)
 {
-       zval *tmp = (zval *) emalloc(sizeof(zval));
+       zval *tmp = ALLOC_ZVAL();
 
        tmp->type = IS_STRING;
        tmp->value.str.len = strlen(str);
@@ -366,7 +366,7 @@ ZEND_API inline int add_index_string(zval *arg, uint index, char *str, int dupli
 
 ZEND_API inline int add_index_stringl(zval *arg, uint index, char *str, uint length, int duplicate)
 {
-       zval *tmp = (zval *) emalloc(sizeof(zval));
+       zval *tmp = ALLOC_ZVAL();
 
        tmp->type = IS_STRING;
        tmp->value.str.len = length;
@@ -382,7 +382,7 @@ ZEND_API inline int add_index_stringl(zval *arg, uint index, char *str, uint len
 
 ZEND_API inline int add_next_index_long(zval *arg, long n)
 {
-       zval *tmp = (zval *) emalloc(sizeof(zval));
+       zval *tmp = ALLOC_ZVAL();
 
        tmp->type = IS_LONG;
        tmp->value.lval = n;
@@ -393,7 +393,7 @@ ZEND_API inline int add_next_index_long(zval *arg, long n)
 
 ZEND_API inline int add_next_index_bool(zval *arg, int b)
 {
-       zval *tmp = (zval *) emalloc(sizeof(zval));
+       zval *tmp = ALLOC_ZVAL();
 
        tmp->type = IS_BOOL;
        tmp->value.lval = b;
@@ -404,7 +404,7 @@ ZEND_API inline int add_next_index_bool(zval *arg, int b)
 
 ZEND_API inline int add_next_index_resource(zval *arg, int r)
 {
-       zval *tmp = (zval *) emalloc(sizeof(zval));
+       zval *tmp = ALLOC_ZVAL();
 
        tmp->type = IS_RESOURCE;
        tmp->value.lval = r;
@@ -415,7 +415,7 @@ ZEND_API inline int add_next_index_resource(zval *arg, int r)
 
 ZEND_API inline int add_next_index_double(zval *arg, double d)
 {
-       zval *tmp = (zval *) emalloc(sizeof(zval));
+       zval *tmp = ALLOC_ZVAL();
 
        tmp->type = IS_DOUBLE;
        tmp->value.dval = d;
@@ -426,7 +426,7 @@ ZEND_API inline int add_next_index_double(zval *arg, double d)
 
 ZEND_API inline int add_next_index_string(zval *arg, char *str, int duplicate)
 {
-       zval *tmp = (zval *) emalloc(sizeof(zval));
+       zval *tmp = ALLOC_ZVAL();
 
        tmp->type = IS_STRING;
        tmp->value.str.len = strlen(str);
@@ -442,7 +442,7 @@ ZEND_API inline int add_next_index_string(zval *arg, char *str, int duplicate)
 
 ZEND_API inline int add_next_index_stringl(zval *arg, char *str, uint length, int duplicate)
 {
-       zval *tmp = (zval *) emalloc(sizeof(zval));
+       zval *tmp = ALLOC_ZVAL();
 
        tmp->type = IS_STRING;
        tmp->value.str.len = length;
@@ -458,7 +458,7 @@ ZEND_API inline int add_next_index_stringl(zval *arg, char *str, uint length, in
 
 ZEND_API inline int add_get_assoc_string(zval *arg, char *key, char *str, void **dest, int duplicate)
 {
-       zval *tmp = (zval *) emalloc(sizeof(zval));
+       zval *tmp = ALLOC_ZVAL();
 
        tmp->type = IS_STRING;
        tmp->value.str.len = strlen(str);
@@ -474,7 +474,7 @@ ZEND_API inline int add_get_assoc_string(zval *arg, char *key, char *str, void *
 
 ZEND_API inline int add_get_assoc_stringl(zval *arg, char *key, char *str, uint length, void **dest, int duplicate)
 {
-       zval *tmp = (zval *) emalloc(sizeof(zval));
+       zval *tmp = ALLOC_ZVAL();
 
        tmp->type = IS_STRING;
        tmp->value.str.len = length;
@@ -490,7 +490,7 @@ ZEND_API inline int add_get_assoc_stringl(zval *arg, char *key, char *str, uint
 
 ZEND_API inline int add_get_index_long(zval *arg, uint index, long l, void **dest)
 {
-       zval *tmp = (zval *) emalloc(sizeof(zval));
+       zval *tmp = ALLOC_ZVAL();
 
        tmp->type = IS_LONG;
        tmp->value.lval = l;
@@ -501,7 +501,7 @@ ZEND_API inline int add_get_index_long(zval *arg, uint index, long l, void **des
 
 ZEND_API inline int add_get_index_double(zval *arg, uint index, double d, void **dest)
 {
-       zval *tmp = (zval *) emalloc(sizeof(zval));
+       zval *tmp = ALLOC_ZVAL();
 
        tmp->type = IS_DOUBLE;
        tmp->value.dval= d;
@@ -512,7 +512,7 @@ ZEND_API inline int add_get_index_double(zval *arg, uint index, double d, void *
 
 ZEND_API inline int add_get_index_string(zval *arg, uint index, char *str, void **dest, int duplicate)
 {
-       zval *tmp = (zval *) emalloc(sizeof(zval));
+       zval *tmp = ALLOC_ZVAL();
 
        tmp->type = IS_STRING;
        tmp->value.str.len = strlen(str);
@@ -528,7 +528,7 @@ ZEND_API inline int add_get_index_string(zval *arg, uint index, char *str, void
 
 ZEND_API inline int add_get_index_stringl(zval *arg, uint index, char *str, uint length, void **dest, int duplicate)
 {
-       zval *tmp = (zval *) emalloc(sizeof(zval));
+       zval *tmp = ALLOC_ZVAL();
 
        tmp->type = IS_STRING;
        tmp->value.str.len = length;
@@ -544,7 +544,7 @@ ZEND_API inline int add_get_index_stringl(zval *arg, uint index, char *str, uint
 
 ZEND_API inline int add_property_long(zval *arg, char *key, long n)
 {
-       zval *tmp = (zval *) emalloc(sizeof(zval));
+       zval *tmp = ALLOC_ZVAL();
 
        tmp->type = IS_LONG;
        tmp->value.lval = n;
@@ -554,7 +554,7 @@ ZEND_API inline int add_property_long(zval *arg, char *key, long n)
 
 ZEND_API inline int add_property_resource(zval *arg, char *key, long n)
 {
-       zval *tmp = (zval *) emalloc(sizeof(zval));
+       zval *tmp = ALLOC_ZVAL();
 
        tmp->type = IS_RESOURCE;
        tmp->value.lval = n;
@@ -565,7 +565,7 @@ ZEND_API inline int add_property_resource(zval *arg, char *key, long n)
 
 ZEND_API inline int add_property_double(zval *arg, char *key, double d)
 {
-       zval *tmp = (zval *) emalloc(sizeof(zval));
+       zval *tmp = ALLOC_ZVAL();
 
        tmp->type = IS_DOUBLE;
        tmp->value.dval = d;
@@ -576,7 +576,7 @@ ZEND_API inline int add_property_double(zval *arg, char *key, double d)
 
 ZEND_API inline int add_property_string(zval *arg, char *key, char *str, int duplicate)
 {
-       zval *tmp = (zval *) emalloc(sizeof(zval));
+       zval *tmp = ALLOC_ZVAL();
 
        tmp->type = IS_STRING;
        tmp->value.str.len = strlen(str);
@@ -592,7 +592,7 @@ ZEND_API inline int add_property_string(zval *arg, char *key, char *str, int dup
 
 ZEND_API inline int add_property_stringl(zval *arg, char *key, char *str, uint length, int duplicate)
 {
-       zval *tmp = (zval *) emalloc(sizeof(zval));
+       zval *tmp = ALLOC_ZVAL();
 
        tmp->type = IS_STRING;
        tmp->value.str.len = length;

diff --git a/Zend/zend_API.h b/Zend/zend_API.h
index 4d9962b032873c7fe5195d2d314fb61318d561d7..701a95d90059819564f0b2af97c3bd2e25a95f57 100644 (file)
--- a/Zend/zend_API.h
+++ b/Zend/zend_API.h
@@ -212,7 +212,7 @@ ZEND_API int zend_set_hash_symbol(zval *symbol, char *name, int name_length,
 
 #define SET_VAR_STRING(n,v)    {                                                                                                                                                               \
                                                                {                                                                                                                                                       \
-                                                                       zval *var = (zval *) emalloc(sizeof(zval));                                                             \
+                                                                       zval *var = ALLOC_ZVAL();                                                               \
                                                                        char *str=(v); /* prevent 'v' from being evaluated more than once */    \
                                                                                                                                                                                                                        \
                                                                        var->value.str.val = (str);                                                                                             \
@@ -224,7 +224,7 @@ ZEND_API int zend_set_hash_symbol(zval *symbol, char *name, int name_length,
 
 #define SET_VAR_STRINGL(n,v,l) {                                                                                                               \
                                                                        {                                                                                                       \
-                                                                               zval *var = (zval *) emalloc(sizeof(zval));             \
+                                                                               zval *var = ALLOC_ZVAL();               \
                                                                                                                                                                                \
                                                                                var->value.str.val = (v);                                               \
                                                                                var->value.str.len = (l);                                               \
@@ -235,7 +235,7 @@ ZEND_API int zend_set_hash_symbol(zval *symbol, char *name, int name_length,
 
 #define SET_VAR_LONG(n,v)      {                                                                                                                       \
                                                                {                                                                                                               \
-                                                                       zval *var = (zval *) emalloc(sizeof(zval));                     \
+                                                                       zval *var = ALLOC_ZVAL();                       \
                                                                                                                                                                                \
                                                                        var->value.lval = (v);                                                          \
                                                                        var->type = IS_LONG;                                                            \
@@ -245,7 +245,7 @@ ZEND_API int zend_set_hash_symbol(zval *symbol, char *name, int name_length,
 
 #define SET_VAR_DOUBLE(n,v)    {                                                                                                                       \
                                                                {                                                                                                               \
-                                                                       zval *var = (zval *) emalloc(sizeof(zval));                     \
+                                                                       zval *var = ALLOC_ZVAL();                       \
                                                                                                                                                                                \
                                                                        var->value.dval = (v);                                                          \
                                                                        var->type = IS_DOUBLE;                                                          \
@@ -275,7 +275,7 @@ ZEND_API int zend_set_hash_symbol(zval *symbol, char *name, int name_length,
                        }                                                                                                                                                                                       \
                        zval_dtor(*orig_var);                                                                                                                                           \
                        **orig_var = *(var);                                                                                                                                            \
-                       efree(var);                                                                                                                                                                     \
+                       FREE_ZVAL(var);                                                                                                                                                                 \
                } else {                                                                                                                                                                                \
                        (var)->is_ref = _is_ref;                                                                                                                                        \
                        if (_refcount) {                                                                                                                                                        \

diff --git a/Zend/zend_builtin_functions.c b/Zend/zend_builtin_functions.c
index 43b08390f598ea968e799e617d69f5c15f34eb52..f7137b912f630c65f1d94f8e9033aa407884cc87 100644 (file)
--- a/Zend/zend_builtin_functions.c
+++ b/Zend/zend_builtin_functions.c
@@ -162,7 +162,7 @@ ZEND_FUNCTION(func_get_args)
        for (i=0; i<arg_count; i++) {
                zval *element;
 
-               element = (zval *) emalloc(sizeof(zval));
+               element = ALLOC_ZVAL();
                *element = **((zval **) (p-(arg_count-i)));
                zval_copy_ctor(element);
                INIT_PZVAL(element);
@@ -239,7 +239,7 @@ ZEND_FUNCTION(each)
 
        /* add value elements */
        if (entry->is_ref) {
-               tmp = (zval *)emalloc(sizeof(zval));
+               tmp = ALLOC_ZVAL();
                *tmp = *entry;
                zval_copy_ctor(tmp);
                tmp->is_ref=0;

diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
index 19c30394115e37c163478875df6b1bab137d6ee6..ac20dfce943ee083e4c6dfe7f8055ea21355722e 100644 (file)
--- a/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@ -1497,7 +1497,7 @@ void do_end_class_declaration(CLS_D)
 void do_declare_property(znode *var_name, znode *value CLS_DC)
 {
        if (value) {
-               zval *property = (zval *) emalloc(sizeof(zval));
+               zval *property = ALLOC_ZVAL();
 
                *property = value->u.constant;
                zend_hash_update(&CG(active_class_entry)->default_properties, var_name->u.constant.value.str.val, var_name->u.constant.value.str.len+1, &property, sizeof(zval *), NULL);
@@ -1686,7 +1686,7 @@ void do_add_array_element(znode *result, znode *expr, znode *offset, int is_ref
 
 void do_add_static_array_element(znode *result, znode *offset, znode *expr)
 {
-       zval *element = (zval *) emalloc(sizeof(zval));
+       zval *element = ALLOC_ZVAL();
 
        *element = expr->u.constant;
        if (offset) {
@@ -1806,7 +1806,7 @@ void do_fetch_global_or_static_variable(znode *varname, znode *static_assignment
        znode lval;
 
        if (fetch_type==ZEND_FETCH_STATIC && static_assignment) {
-               zval *tmp = (zval *) emalloc(sizeof(zval));
+               zval *tmp = ALLOC_ZVAL();
 
                convert_to_string(&varname->u.constant);
                *tmp = static_assignment->u.constant;

diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h
index b7d100ec9140b3553e87c818b19119dae71c5b55..d3dfb5dc79a7c64b62c7070f2b9334713f00b072 100644 (file)
--- a/Zend/zend_compile.h
+++ b/Zend/zend_compile.h
@@ -581,9 +581,9 @@ int zendlex(znode *zendlval CLS_DC);
                                                                EG(garbage)[EG(garbage_ptr)++] = (z);           \
                                                                if (EG(garbage_ptr) == 4) {                                     \
                                                                        zval_dtor(EG(garbage)[0]);                              \
-                                                                       efree(EG(garbage)[0]);                                  \
+                                                                       FREE_ZVAL(EG(garbage)[0]);                                      \
                                                                        zval_dtor(EG(garbage)[1]);                              \
-                                                                       efree(EG(garbage)[1]);                                  \
+                                                                       FREE_ZVAL(EG(garbage)[1]);                                      \
                                                                        EG(garbage)[0] = EG(garbage)[2];                \
                                                                        EG(garbage)[1] = EG(garbage)[3];                \
                                                                        EG(garbage_ptr) -= 2;                                   \

diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c
index dabb0a56338391c4516eaaabe77e43fede0b2fcb..932646265cc7cbba12b6d153f721a9a942ebfb3d 100644 (file)
--- a/Zend/zend_execute.c
+++ b/Zend/zend_execute.c
@@ -354,7 +354,7 @@ static inline void zend_assign_to_variable(znode *result, znode *op1, znode *op2
                                        if (PZVAL_IS_LOCKED(value)) {
                                                zval *orig_value = value;
 
-                                               value = (zval *) emalloc(sizeof(zval));
+                                               value = ALLOC_ZVAL();
                                                *value = *orig_value;
                                                value->refcount=0;
                                                zval_copy_ctor(value);
@@ -392,7 +392,7 @@ static inline void zend_assign_to_variable(znode *result, znode *op1, znode *op2
                                        if (PZVAL_IS_LOCKED(value)) {
                                                zval *orig_value = value;
 
-                                               value = (zval *) emalloc(sizeof(zval));
+                                               value = ALLOC_ZVAL();
                                                *value = *orig_value;
                                                value->refcount=0;
                                                zval_copy_ctor(value);
@@ -401,7 +401,7 @@ static inline void zend_assign_to_variable(znode *result, znode *op1, znode *op2
                                        /* break missing intentionally */
                                case IS_CONST:
                                        if (PZVAL_IS_REF(value) && value->refcount > 0) {
-                                               variable_ptr = *variable_ptr_ptr = (zval *) emalloc(sizeof(zval));
+                                               variable_ptr = *variable_ptr_ptr = ALLOC_ZVAL();
                                                *variable_ptr = *value;
                                                zval_copy_ctor(variable_ptr);
                                                variable_ptr->refcount=1;
@@ -411,7 +411,7 @@ static inline void zend_assign_to_variable(znode *result, znode *op1, znode *op2
                                        value->refcount++;
                                        break;
                                case IS_TMP_VAR:
-                                       (*variable_ptr_ptr) = (zval *) emalloc(sizeof(zval));
+                                       (*variable_ptr_ptr) = ALLOC_ZVAL();
                                        value->refcount=1;
                                        **variable_ptr_ptr = *value;
                                        break;
@@ -661,7 +661,7 @@ static inline void zend_fetch_dimension_address(znode *result, znode *op1, znode
                                if (!PZVAL_IS_REF(container)) {
                                        container->refcount--;
                                        if (container->refcount>0) {
-                                               container = *container_ptr = (zval *) emalloc(sizeof(zval));
+                                               container = *container_ptr = ALLOC_ZVAL();
                                                container->is_ref=0;
                                        }
                                        container->refcount=1;
@@ -675,7 +675,7 @@ static inline void zend_fetch_dimension_address(znode *result, znode *op1, znode
                case IS_ARRAY:
                        if ((type==BP_VAR_W || type==BP_VAR_RW) && container->refcount>1 && !PZVAL_IS_REF(container)) {
                                container->refcount--;
-                               *container_ptr = (zval *) emalloc(sizeof(zval));
+                               *container_ptr = ALLOC_ZVAL();
                                **container_ptr = *container;
                                container = *container_ptr;
                                INIT_PZVAL(container);
@@ -836,7 +836,7 @@ static inline void zend_fetch_property_address(znode *result, znode *op1, znode
                                if (!PZVAL_IS_REF(container)) {
                                        container->refcount--;
                                        if (container->refcount>0) {
-                                               container = *container_ptr = (zval *) emalloc(sizeof(zval));
+                                               container = *container_ptr = ALLOC_ZVAL();
                                                container->is_ref=0;
                                        }
                                        container->refcount=1;
@@ -863,7 +863,7 @@ static inline void zend_fetch_property_address(znode *result, znode *op1, znode
 
        if ((type==BP_VAR_W || type==BP_VAR_RW) && container->refcount>1 && !PZVAL_IS_REF(container)) {
                container->refcount--;
-               *container_ptr = (zval *) emalloc(sizeof(zval));
+               *container_ptr = ALLOC_ZVAL();
                **container_ptr = *container;
                container = *container_ptr;
                INIT_PZVAL(container);
@@ -959,14 +959,14 @@ void execute(zend_op_array *op_array ELS_DC)
 #endif
        
        if (op_array->uses_globals) {
-               zval *globals = (zval *) emalloc(sizeof(zval));
+               zval *globals = ALLOC_ZVAL();
 
                globals->refcount=1;
                globals->is_ref=1;
                globals->type = IS_ARRAY;
                globals->value.ht = &EG(symbol_table);
                if (zend_hash_add(EG(active_symbol_table), "GLOBALS", sizeof("GLOBALS"), &globals, sizeof(zval *), NULL)==FAILURE) {
-                       efree(globals);
+                       FREE_ZVAL(globals);
                }
        }
 
@@ -1089,7 +1089,7 @@ binary_assign_op_addr: {
                                                        zval *orig_var=*var_ptr;
                                                        
                                                        (*var_ptr)->refcount--;
-                                                       *var_ptr = (zval *) emalloc(sizeof(zval));
+                                                       *var_ptr = ALLOC_ZVAL();
                                                        **var_ptr = *orig_var;
                                                        zendi_zval_copy_ctor(**var_ptr);
                                                        (*var_ptr)->refcount=1;
@@ -1134,7 +1134,7 @@ binary_assign_op_addr: {
                                                        zval *orig_var = *var_ptr;
                                                        
                                                        (*var_ptr)->refcount--;
-                                                       *var_ptr = (zval *) emalloc(sizeof(zval));
+                                                       *var_ptr = ALLOC_ZVAL();
                                                        **var_ptr = *orig_var;
                                                        zendi_zval_copy_ctor(**var_ptr);
                                                        (*var_ptr)->refcount=1;
@@ -1502,7 +1502,7 @@ do_fcall_common:
                                        Ts[opline->result.u.var].var.ptr_ptr = &Ts[opline->result.u.var].var.ptr;
 
                                        if (function_state.function->type==ZEND_INTERNAL_FUNCTION) {    
-                                               Ts[opline->result.u.var].var.ptr = (zval *)emalloc(sizeof(zval));
+                                               Ts[opline->result.u.var].var.ptr = ALLOC_ZVAL();
                                                INIT_ZVAL(*(Ts[opline->result.u.var].var.ptr));
                                                ((zend_internal_function *) function_state.function)->handler(opline->extended_value, Ts[opline->result.u.var].var.ptr, &EG(regular_list), &EG(persistent_list), object.ptr, return_value_used);
                                                if (object.ptr) {
@@ -1546,7 +1546,7 @@ do_fcall_common:
                                                zend_execute(EG(active_op_array) ELS_CC);
 
                                                if (return_value_used && !Ts[opline->result.u.var].var.ptr) {
-                                                       Ts[opline->result.u.var].var.ptr = (zval *) emalloc(sizeof(zval));
+                                                       Ts[opline->result.u.var].var.ptr = ALLOC_ZVAL();
                                                        INIT_ZVAL(*Ts[opline->result.u.var].var.ptr);
                                                } else if (!return_value_used && Ts[opline->result.u.var].var.ptr) {
                                                        zval_ptr_dtor(&Ts[opline->result.u.var].var.ptr);
@@ -1563,7 +1563,7 @@ do_fcall_common:
                                                }
                                                EG(active_symbol_table) = calling_symbol_table;
                                        } else { /* ZEND_OVERLOADED_FUNCTION */
-                                               Ts[opline->result.u.var].var.ptr = (zval *)emalloc(sizeof(zval));
+                                               Ts[opline->result.u.var].var.ptr = ALLOC_ZVAL();
                                                INIT_ZVAL(*(Ts[opline->result.u.var].var.ptr));
                                                call_overloaded_function(opline->extended_value, Ts[opline->result.u.var].var.ptr, &EG(regular_list), &EG(persistent_list) ELS_CC);
                                                efree(fbc);
@@ -1602,7 +1602,7 @@ do_fcall_common:
                                        
                                                if (!EG(free_op1)) { /* Not a temp var */
                                                        if (PZVAL_IS_REF(retval_ptr) && retval_ptr->refcount > 0) {
-                                                               *(EG(return_value_ptr_ptr)) = (zval *)emalloc(sizeof(zval));
+                                                               *(EG(return_value_ptr_ptr)) = ALLOC_ZVAL();
                                                                **EG(return_value_ptr_ptr) = *retval_ptr;
                                                                (*EG(return_value_ptr_ptr))->is_ref = 0;
                                                                (*EG(return_value_ptr_ptr))->refcount = 1;
@@ -1612,7 +1612,7 @@ do_fcall_common:
                                                                retval_ptr->refcount++;
                                                        }
                                                } else {
-                                                       *(EG(return_value_ptr_ptr))= (zval *)emalloc(sizeof(zval));
+                                                       *(EG(return_value_ptr_ptr))= ALLOC_ZVAL();
                                                        **EG(return_value_ptr_ptr) = *retval_ptr;
                                                        (*EG(return_value_ptr_ptr))->refcount = 1;
                                                        (*EG(return_value_ptr_ptr))->is_ref = 0;
@@ -1632,7 +1632,7 @@ do_fcall_common:
                                                zend_error(E_ERROR, "Cannot pass parameter %d by reference", opline->op2.u.opline_num);
                                }
                                {
-                                       zval *valptr = (zval *) emalloc(sizeof(zval));
+                                       zval *valptr = ALLOC_ZVAL();
 
                                        *valptr = Ts[opline->op1.u.var].tmp_var;
                                        INIT_PZVAL(valptr);
@@ -1651,13 +1651,13 @@ do_fcall_common:
                                        RESUME_GARBAGE();
 
                                        if (varptr == &EG(uninitialized_zval)) {
-                                               varptr = (zval *) emalloc(sizeof(zval));
+                                               varptr = ALLOC_ZVAL();
                                                INIT_ZVAL(*varptr);
                                                varptr->refcount = 0;
                                        } else if (PZVAL_IS_REF(varptr)) {
                                                zval *original_var = varptr;
 
-                                               varptr = (zval *) emalloc(sizeof(zval));
+                                               varptr = ALLOC_ZVAL();
                                                *varptr = *original_var;
                                                varptr->is_ref = 0;
                                                varptr->refcount = 0;
@@ -1682,7 +1682,7 @@ send_by_ref:
                                                /* code to break away this variable */
                                                if (varptr->refcount>1) {
                                                        varptr->refcount--;
-                                                       *varptr_ptr = (zval *) emalloc(sizeof(zval));
+                                                       *varptr_ptr = ALLOC_ZVAL();
                                                        **varptr_ptr = *varptr;
                                                        varptr = *varptr_ptr;
                                                        varptr->refcount = 1;
@@ -1721,7 +1721,7 @@ send_by_ref:
                                                        break;
                                                }
                                                if (opline->op2.u.constant.type == IS_CONSTANT) {
-                                                       zval *default_value = (zval *) emalloc(sizeof(zval));
+                                                       zval *default_value = ALLOC_ZVAL();
                                                        zval tmp;
 
                                                        *default_value = opline->op2.u.constant;
@@ -1886,7 +1886,7 @@ send_by_ref:
                                                }
                                        }
                                        if (opline->op1.op_type == IS_TMP_VAR) { /* temporary variable */
-                                               zval *new_expr = (zval *) emalloc(sizeof(zval));
+                                               zval *new_expr = ALLOC_ZVAL();
 
                                                *new_expr = *expr_ptr;
                                                expr_ptr = new_expr;
@@ -1900,7 +1900,7 @@ send_by_ref:
                                                        }
                                                        expr_ptr->refcount++;
                                                } else if (PZVAL_IS_REF(expr_ptr)) {
-                                                       zval *new_expr = (zval *) emalloc(sizeof(zval));
+                                                       zval *new_expr = ALLOC_ZVAL();
 
                                                        *new_expr = *expr_ptr;
                                                        expr_ptr = new_expr;
@@ -1994,7 +1994,7 @@ send_by_ref:
                                                        } 
                                                } else { /* return value is used */
                                                        if (!Ts[opline->result.u.var].var.ptr) { /* there was no return statement */
-                                                               Ts[opline->result.u.var].var.ptr = (zval *) emalloc(sizeof(zval));
+                                                               Ts[opline->result.u.var].var.ptr = ALLOC_ZVAL();
                                                                INIT_PZVAL(Ts[opline->result.u.var].var.ptr);
                                                                Ts[opline->result.u.var].var.ptr->value.lval = 1;
                                                                Ts[opline->result.u.var].var.ptr->type = IS_LONG;
@@ -2008,7 +2008,7 @@ send_by_ref:
                                                efree(new_op_array);
                                        } else {
                                                if (return_value_used) {
-                                                       Ts[opline->result.u.var].var.ptr = (zval *) emalloc(sizeof(zval));
+                                                       Ts[opline->result.u.var].var.ptr = ALLOC_ZVAL();
                                                        INIT_ZVAL(*Ts[opline->result.u.var].var.ptr);
                                                }
                                        }
@@ -2104,7 +2104,7 @@ send_by_ref:
                                        (*value)->refcount++;
                                        zend_hash_index_update(result->value.ht, 0, value, sizeof(zval *), NULL);
 
-                                       key = (zval *) emalloc(sizeof(zval));
+                                       key = ALLOC_ZVAL();
                                        INIT_PZVAL(key);
                                        switch (zend_hash_get_current_key(array->value.ht, &str_key, &int_key)) {
                                                case HASH_KEY_IS_STRING:

diff --git a/Zend/zend_execute_API.c b/Zend/zend_execute_API.c
index 116a776fbae1efb388ca7947184dfd97c57e76db..c05da3120521f77aafe3d72bcac59f28ef135df2 100644 (file)
--- a/Zend/zend_execute_API.c
+++ b/Zend/zend_execute_API.c
@@ -145,7 +145,7 @@ void shutdown_executor(ELS_D)
 #endif
        while (EG(garbage_ptr)--) {
                zval_dtor(EG(garbage)[EG(garbage_ptr)]);
-               efree(EG(garbage)[EG(garbage_ptr)]);
+               FREE_ZVAL(EG(garbage)[EG(garbage_ptr)]);
        }
 
        zend_hash_destroy(&EG(imported_files));
@@ -201,7 +201,7 @@ ZEND_API inline void safe_free_zval_ptr(zval *p)
        ELS_FETCH();
 
        if (p!=EG(uninitialized_zval_ptr)) {
-               efree(p);
+               FREE_ZVAL(p);
        }
 }
 
@@ -344,7 +344,7 @@ int call_user_function_ex(HashTable *function_table, zval *object, zval *functio
                                if (no_separation) {
                                        return FAILURE;
                                }
-                               new_zval = (zval *) emalloc(sizeof(zval));
+                               new_zval = ALLOC_ZVAL();
                                *new_zval = **params[i];
                                zval_copy_ctor(new_zval);
                                new_zval->refcount = 1;
@@ -358,7 +358,7 @@ int call_user_function_ex(HashTable *function_table, zval *object, zval *functio
                        (*params[i])->refcount++;
                        param = *params[i];
                } else {
-                       param = (zval *) emalloc(sizeof(zval));
+                       param = ALLOC_ZVAL();
                        *param = **(params[i]);
                        INIT_PZVAL(param);
                }
@@ -373,7 +373,7 @@ int call_user_function_ex(HashTable *function_table, zval *object, zval *functio
                EG(active_symbol_table) = (HashTable *) emalloc(sizeof(HashTable));
                zend_hash_init(EG(active_symbol_table), 0, NULL, ZVAL_PTR_DTOR, 0);
                if (object) {
-                       zval *dummy = (zval *) emalloc(sizeof(zval)), **this_ptr;
+                       zval *dummy = ALLOC_ZVAL(), **this_ptr;
 
                        INIT_ZVAL(*dummy);
                        
@@ -487,14 +487,14 @@ ZEND_API inline void zend_assign_to_variable_reference(znode *result, zval **var
                variable_ptr->refcount--;
                if (variable_ptr->refcount==0) {
                        zendi_zval_dtor(*variable_ptr);
-                       efree(variable_ptr);
+                       FREE_ZVAL(variable_ptr);
                }
 
                if (!PZVAL_IS_REF(value_ptr)) {
                        /* break it away */
                        value_ptr->refcount--;
                        if (value_ptr->refcount>0) {
-                               *value_ptr_ptr = (zval *) emalloc(sizeof(zval));
+                               *value_ptr_ptr = ALLOC_ZVAL();
                                **value_ptr_ptr = *value_ptr;
                                value_ptr = *value_ptr_ptr;
                                zendi_zval_copy_ctor(*value_ptr);

diff --git a/Zend/zend_operators.c b/Zend/zend_operators.c
index ed4be2cc0b6029e18800363bca8e54126565ec3c..60f568a3df15c0a124dff26c71ac82f6147369cb 100644 (file)
--- a/Zend/zend_operators.c
+++ b/Zend/zend_operators.c
@@ -339,7 +339,7 @@ ZEND_API void convert_to_string(zval *op)
 
 static void convert_scalar_to_array(zval *op, int type)
 {
-       zval *entry = (zval *) emalloc(sizeof(zval));
+       zval *entry = ALLOC_ZVAL();
        
        *entry = *op;
        INIT_PZVAL(entry);

diff --git a/Zend/zend_variables.c b/Zend/zend_variables.c
index 72416146b05e0d9c5c3a481fddda911cdc795a25..e415aa4e9b1fe23c7dbed624241471bec15ffd1c 100644 (file)
--- a/Zend/zend_variables.c
+++ b/Zend/zend_variables.c
@@ -94,7 +94,7 @@ void zval_del_ref(zval **p)
        (*p)->refcount--;
        if ((*p)->refcount==0) {
                zval_dtor(*p);
-               efree(*p);
+               FREE_ZVAL(*p);
        }
 }