Step 2:

Rename is_ref to EA

diff --git a/Zend/zend-parser.y b/Zend/zend-parser.y
index 33aefc2bd6b48f8a41e078c28d4137e8f16f6ebc..1a0b3c32d6649ddfc46abc6d93954e22ad141432 100644 (file)
--- a/Zend/zend-parser.y
+++ b/Zend/zend-parser.y
@@ -272,11 +272,11 @@ parameter_list:
 
 
 non_empty_parameter_list:
-               T_VARIABLE                                              { znode tmp;  fetch_simple_variable(&tmp, &$1, 0 CLS_CC); $$.op_type = IS_CONST; $$.u.constant.value.lval=1; $$.u.constant.type=IS_LONG; $$.u.constant.refcount=1; $$.u.constant.is_ref=0; do_receive_arg(ZEND_RECV, &tmp, &$$, NULL, BYREF_NONE CLS_CC); }
-       |       '&' T_VARIABLE                                  { znode tmp;  fetch_simple_variable(&tmp, &$2, 0 CLS_CC); $$.op_type = IS_CONST; $$.u.constant.value.lval=1; $$.u.constant.type=IS_LONG; $$.u.constant.refcount=1; $$.u.constant.is_ref=0; do_receive_arg(ZEND_RECV, &tmp, &$$, NULL, BYREF_FORCE CLS_CC); }
-       |       T_CONST T_VARIABLE                      { znode tmp;  fetch_simple_variable(&tmp, &$2, 0 CLS_CC); $$.op_type = IS_CONST; $$.u.constant.value.lval=1; $$.u.constant.type=IS_LONG; $$.u.constant.refcount=1; $$.u.constant.is_ref=0; do_receive_arg(ZEND_RECV, &tmp, &$$, NULL, BYREF_NONE CLS_CC); }
-       |       T_VARIABLE '=' static_scalar            { znode tmp;  fetch_simple_variable(&tmp, &$1, 0 CLS_CC); $$.op_type = IS_CONST; $$.u.constant.value.lval=1; $$.u.constant.type=IS_LONG; $$.u.constant.refcount=1; $$.u.constant.is_ref=0; do_receive_arg(ZEND_RECV_INIT, &tmp, &$$, &$3, BYREF_NONE CLS_CC); }
-       |       T_VARIABLE '=' T_UNSET          { znode tmp;  fetch_simple_variable(&tmp, &$1, 0 CLS_CC); $$.op_type = IS_CONST; $$.u.constant.value.lval=1; $$.u.constant.type=IS_LONG; $$.u.constant.refcount=1; $$.u.constant.is_ref=0; do_receive_arg(ZEND_RECV_INIT, &tmp, &$$, NULL, BYREF_NONE CLS_CC); }
+               T_VARIABLE                                              { znode tmp;  fetch_simple_variable(&tmp, &$1, 0 CLS_CC); $$.op_type = IS_CONST; $$.u.constant.value.lval=1; $$.u.constant.type=IS_LONG; $$.u.constant.refcount=1; $$.u.constant.EA=0; do_receive_arg(ZEND_RECV, &tmp, &$$, NULL, BYREF_NONE CLS_CC); }
+       |       '&' T_VARIABLE                                  { znode tmp;  fetch_simple_variable(&tmp, &$2, 0 CLS_CC); $$.op_type = IS_CONST; $$.u.constant.value.lval=1; $$.u.constant.type=IS_LONG; $$.u.constant.refcount=1; $$.u.constant.EA=0; do_receive_arg(ZEND_RECV, &tmp, &$$, NULL, BYREF_FORCE CLS_CC); }
+       |       T_CONST T_VARIABLE                      { znode tmp;  fetch_simple_variable(&tmp, &$2, 0 CLS_CC); $$.op_type = IS_CONST; $$.u.constant.value.lval=1; $$.u.constant.type=IS_LONG; $$.u.constant.refcount=1; $$.u.constant.EA=0; do_receive_arg(ZEND_RECV, &tmp, &$$, NULL, BYREF_NONE CLS_CC); }
+       |       T_VARIABLE '=' static_scalar            { znode tmp;  fetch_simple_variable(&tmp, &$1, 0 CLS_CC); $$.op_type = IS_CONST; $$.u.constant.value.lval=1; $$.u.constant.type=IS_LONG; $$.u.constant.refcount=1; $$.u.constant.EA=0; do_receive_arg(ZEND_RECV_INIT, &tmp, &$$, &$3, BYREF_NONE CLS_CC); }
+       |       T_VARIABLE '=' T_UNSET          { znode tmp;  fetch_simple_variable(&tmp, &$1, 0 CLS_CC); $$.op_type = IS_CONST; $$.u.constant.value.lval=1; $$.u.constant.type=IS_LONG; $$.u.constant.refcount=1; $$.u.constant.EA=0; do_receive_arg(ZEND_RECV_INIT, &tmp, &$$, NULL, BYREF_NONE CLS_CC); }
        |       non_empty_parameter_list ',' T_VARIABLE                                                 { znode tmp;  fetch_simple_variable(&tmp, &$3, 0 CLS_CC); $$=$1; $$.u.constant.value.lval++; do_receive_arg(ZEND_RECV, &tmp, &$$, NULL, BYREF_NONE CLS_CC); }
        |       non_empty_parameter_list ',' '&' T_VARIABLE                                     { znode tmp;  fetch_simple_variable(&tmp, &$4, 0 CLS_CC); $$=$1; $$.u.constant.value.lval++; do_receive_arg(ZEND_RECV, &tmp, &$$, NULL, BYREF_FORCE CLS_CC); }
        |       non_empty_parameter_list ',' T_CONST T_VARIABLE                 { znode tmp;  fetch_simple_variable(&tmp, &$4, 0 CLS_CC); $$=$1; $$.u.constant.value.lval++; do_receive_arg(ZEND_RECV, &tmp, &$$, NULL, BYREF_NONE CLS_CC); }
@@ -484,7 +484,7 @@ scalar:
 
 
 static_array_pair_list:
-               /* empty */                                             { $$.op_type = IS_CONST; $$.u.constant.refcount=1; $$.u.constant.is_ref=0; array_init(&$$.u.constant); }
+               /* empty */                                             { $$.op_type = IS_CONST; $$.u.constant.refcount=1; $$.u.constant.EA=0; array_init(&$$.u.constant); }
        |       non_empty_static_array_pair_list        { $$ = $1; }
 ;
 
@@ -492,8 +492,8 @@ static_array_pair_list:
 non_empty_static_array_pair_list:
                non_empty_static_array_pair_list ',' static_scalar T_DOUBLE_ARROW static_scalar { do_add_static_array_element(&$$, &$3, &$5); }
        |       non_empty_static_array_pair_list ',' static_scalar              { do_add_static_array_element(&$$, NULL, &$3); }
-       |       static_scalar T_DOUBLE_ARROW static_scalar      { $$.op_type = IS_CONST; $$.u.constant.refcount=1; $$.u.constant.is_ref=0; array_init(&$$.u.constant); do_add_static_array_element(&$$, &$1, &$3); }
-       |       static_scalar                                                                   { $$.op_type = IS_CONST; $$.u.constant.refcount=1; $$.u.constant.is_ref=0; array_init(&$$.u.constant); do_add_static_array_element(&$$, NULL, &$1); }
+       |       static_scalar T_DOUBLE_ARROW static_scalar      { $$.op_type = IS_CONST; $$.u.constant.refcount=1; $$.u.constant.EA=0; array_init(&$$.u.constant); do_add_static_array_element(&$$, &$1, &$3); }
+       |       static_scalar                                                                   { $$.op_type = IS_CONST; $$.u.constant.refcount=1; $$.u.constant.EA=0; array_init(&$$.u.constant); do_add_static_array_element(&$$, NULL, &$1); }
 ;
 
 expr:

diff --git a/Zend/zend.h b/Zend/zend.h
index 9e377b859ae8ab27304040695aee6d892a138a07..571802fbf0e2ed1861404c9eb4b096f77bd5f09e 100644 (file)
--- a/Zend/zend.h
+++ b/Zend/zend.h
@@ -91,7 +91,7 @@ struct _zval_struct {
        /* Variable information */
        zvalue_value value;             /* value */
        unsigned char type;     /* active type */
-       unsigned char is_ref;
+       unsigned char EA;
        short refcount;
 };
 
@@ -175,7 +175,7 @@ typedef struct _zend_utility_values {
 #define MAKE_STD_ZVAL(zv) \
        zv = (zval *) emalloc(sizeof(zval)); \
        zv->refcount = 1; \
-       zv->is_ref = 0;
+       zv->EA = 0;
 
 
 int zend_startup(zend_utility_functions *utility_functions, char **extensions);

diff --git a/Zend/zend_API.c b/Zend/zend_API.c
index fdda38c1098911ea67e428cb7b1d31c199e5164a..6e6426c83fe71f39ab80278d54feb0633c2c4d90 100644 (file)
--- a/Zend/zend_API.c
+++ b/Zend/zend_API.c
@@ -52,14 +52,14 @@ ZEND_API int getParameters(int ht, int param_count,...)
        while (param_count>0) {
                param = va_arg(ptr, zval **);
                param_ptr = *(p-param_count);
-               if (!param_ptr->is_ref && param_ptr->refcount>1) {
+               if (!param_ptr->EA && param_ptr->refcount>1) {
                        zval *new_tmp;
 
                        new_tmp = (zval *) emalloc(sizeof(zval));
                        *new_tmp = *param_ptr;
                        zval_copy_ctor(new_tmp);
                        new_tmp->refcount = 1;
-                       new_tmp->is_ref = 0;
+                       new_tmp->EA = 0;
                        param_ptr = new_tmp;
                        ((zval *) *(p-param_count))->refcount--;
                        *(p-param_count) = param_ptr;
@@ -90,14 +90,14 @@ ZEND_API int getParametersArray(int ht, int param_count, zval **argument_array)
 
        while (param_count>0) {
                param_ptr = *(p-param_count);
-               if (!param_ptr->is_ref && param_ptr->refcount>1) {
+               if (!param_ptr->EA && param_ptr->refcount>1) {
                        zval *new_tmp;
 
                        new_tmp = (zval *) emalloc(sizeof(zval));
                        *new_tmp = *param_ptr;
                        zval_copy_ctor(new_tmp);
                        new_tmp->refcount = 1;
-                       new_tmp->is_ref = 0;
+                       new_tmp->EA = 0;
                        param_ptr = new_tmp;
                        ((zval *) *(p-param_count))->refcount--;
                        *(p-param_count) = param_ptr;
@@ -175,7 +175,7 @@ ZEND_API int ParameterPassedByReference(int ht, uint n)
                return FAILURE;
        }
        arg = (zval *) *(p-arg_count+n-1);
-       return arg->is_ref;
+       return arg->EA;
 }
 
 
@@ -231,7 +231,7 @@ ZEND_API inline int add_assoc_long(zval *arg, char *key, long n)
        tmp->type = IS_LONG;
        tmp->value.lval = n;
        tmp->refcount=1;
-       tmp->is_ref=0;
+       tmp->EA=0;
        return zend_hash_update(arg->value.ht, key, strlen(key)+1, (void *) &tmp, sizeof(zval *), NULL);
 }
 
@@ -243,7 +243,7 @@ ZEND_API inline int add_assoc_double(zval *arg, char *key, double d)
        tmp->type = IS_DOUBLE;
        tmp->value.dval = d;
        tmp->refcount=1;
-       tmp->is_ref=0;
+       tmp->EA=0;
        return zend_hash_update(arg->value.ht, key, strlen(key)+1, (void *) &tmp, sizeof(zval *), NULL);
 }
 
@@ -260,7 +260,7 @@ ZEND_API inline int add_assoc_string(zval *arg, char *key, char *str, int duplic
                tmp->value.str.val = str;
        }
        tmp->refcount=1;
-       tmp->is_ref=0;
+       tmp->EA=0;
        return zend_hash_update(arg->value.ht, key, strlen(key)+1, (void *) &tmp, sizeof(zval *), NULL);
 }
 
@@ -277,7 +277,7 @@ ZEND_API inline int add_assoc_stringl(zval *arg, char *key, char *str, uint leng
                tmp->value.str.val = str;
        }
        tmp->refcount=1;
-       tmp->is_ref=0;
+       tmp->EA=0;
        return zend_hash_update(arg->value.ht, key, strlen(key)+1, (void *) &tmp, sizeof(zval *), NULL);
 }
 
@@ -296,7 +296,7 @@ ZEND_API inline int add_index_long(zval *arg, uint index, long n)
        tmp->type = IS_LONG;
        tmp->value.lval = n;
        tmp->refcount=1;
-       tmp->is_ref=0;
+       tmp->EA=0;
        return zend_hash_index_update(arg->value.ht, index, (void *) &tmp, sizeof(zval *),NULL);
 }
 
@@ -308,7 +308,7 @@ ZEND_API inline int add_index_double(zval *arg, uint index, double d)
        tmp->type = IS_DOUBLE;
        tmp->value.dval = d;
        tmp->refcount=1;
-       tmp->is_ref=0;
+       tmp->EA=0;
        return zend_hash_index_update(arg->value.ht, index, (void *) &tmp, sizeof(zval *),NULL);
 }
 
@@ -325,7 +325,7 @@ ZEND_API inline int add_index_string(zval *arg, uint index, char *str, int dupli
                tmp->value.str.val = str;
        }
        tmp->refcount=1;
-       tmp->is_ref=0;
+       tmp->EA=0;
        return zend_hash_index_update(arg->value.ht, index, (void *) &tmp, sizeof(zval *), NULL);
 }
 
@@ -342,7 +342,7 @@ ZEND_API inline int add_index_stringl(zval *arg, uint index, char *str, uint len
                tmp->value.str.val = str;
        }
        tmp->refcount=1;
-       tmp->is_ref=0;
+       tmp->EA=0;
        return zend_hash_index_update(arg->value.ht, index, (void *) &tmp, sizeof(zval *),NULL);
 }
 
@@ -354,7 +354,7 @@ ZEND_API inline int add_next_index_long(zval *arg, long n)
        tmp->type = IS_LONG;
        tmp->value.lval = n;
        tmp->refcount=1;
-       tmp->is_ref=0;
+       tmp->EA=0;
        return zend_hash_next_index_insert(arg->value.ht, &tmp, sizeof(zval *), NULL);
 }
 
@@ -366,7 +366,7 @@ ZEND_API inline int add_next_index_double(zval *arg, double d)
        tmp->type = IS_DOUBLE;
        tmp->value.dval = d;
        tmp->refcount=1;
-       tmp->is_ref=0;
+       tmp->EA=0;
        return zend_hash_next_index_insert(arg->value.ht, &tmp, sizeof(zval *), NULL);
 }
 
@@ -383,7 +383,7 @@ ZEND_API inline int add_next_index_string(zval *arg, char *str, int duplicate)
                tmp->value.str.val = str;
        }
        tmp->refcount=1;
-       tmp->is_ref=0;
+       tmp->EA=0;
        return zend_hash_next_index_insert(arg->value.ht, &tmp, sizeof(zval *),NULL);
 }
 
@@ -400,7 +400,7 @@ ZEND_API inline int add_next_index_stringl(zval *arg, char *str, uint length, in
                tmp->value.str.val = str;
        }
        tmp->refcount=1;
-       tmp->is_ref=0;
+       tmp->EA=0;
        return zend_hash_next_index_insert(arg->value.ht, &tmp, sizeof(zval *),NULL);
 }
 
@@ -417,7 +417,7 @@ ZEND_API inline int add_get_assoc_string(zval *arg, char *key, char *str, void *
                tmp->value.str.val = str;
        }
        tmp->refcount=1;
-       tmp->is_ref=0;
+       tmp->EA=0;
        return zend_hash_update(arg->value.ht, key, strlen(key)+1, (void *) &tmp, sizeof(zval *), dest);
 }
 
@@ -434,7 +434,7 @@ ZEND_API inline int add_get_assoc_stringl(zval *arg, char *key, char *str, uint
                tmp->value.str.val = str;
        }
        tmp->refcount=1;
-       tmp->is_ref=0;
+       tmp->EA=0;
        return zend_hash_update(arg->value.ht, key, strlen(key)+1, (void *) &tmp, sizeof(zval *), dest);
 }
 
@@ -446,7 +446,7 @@ ZEND_API inline int add_get_index_long(zval *arg, uint index, long l, void **des
        tmp->type = IS_LONG;
        tmp->value.lval= l;
        tmp->refcount=1;
-       tmp->is_ref=0;
+       tmp->EA=0;
        return zend_hash_index_update(arg->value.ht, index, (void *) &tmp, sizeof(zval *),dest);
 }
 
@@ -458,7 +458,7 @@ ZEND_API inline int add_get_index_double(zval *arg, uint index, double d, void *
        tmp->type = IS_DOUBLE;
        tmp->value.dval= d;
        tmp->refcount=1;
-       tmp->is_ref=0;
+       tmp->EA=0;
        return zend_hash_index_update(arg->value.ht, index, (void *) &tmp, sizeof(zval *),dest);
 }
 
@@ -475,7 +475,7 @@ ZEND_API inline int add_get_index_string(zval *arg, uint index, char *str, void
                tmp->value.str.val = str;
        }
        tmp->refcount=1;
-       tmp->is_ref=0;
+       tmp->EA=0;
        return zend_hash_index_update(arg->value.ht, index, (void *) &tmp, sizeof(zval *),dest);
 }
 
@@ -492,7 +492,7 @@ ZEND_API inline int add_get_index_stringl(zval *arg, uint index, char *str, uint
                tmp->value.str.val = str;
        }
        tmp->refcount=1;
-       tmp->is_ref=0;
+       tmp->EA=0;
        return zend_hash_index_update(arg->value.ht, index, (void *) &tmp, sizeof(zval *),dest);
 }
 
@@ -504,7 +504,7 @@ ZEND_API inline int add_property_long(zval *arg, char *key, long n)
        tmp->type = IS_LONG;
        tmp->value.lval = n;
        tmp->refcount=1;
-       tmp->is_ref=0;
+       tmp->EA=0;
        return zend_hash_update(arg->value.obj.properties, key, strlen(key)+1, (void *) &tmp, sizeof(zval *), NULL);
 }
 
@@ -516,7 +516,7 @@ ZEND_API inline int add_property_double(zval *arg, char *key, double d)
        tmp->type = IS_DOUBLE;
        tmp->value.dval = d;
        tmp->refcount=1;
-       tmp->is_ref=0;
+       tmp->EA=0;
        return zend_hash_update(arg->value.obj.properties, key, strlen(key)+1, (void *) &tmp, sizeof(zval *), NULL);
 }
 
@@ -533,7 +533,7 @@ ZEND_API inline int add_property_string(zval *arg, char *key, char *str, int dup
                tmp->value.str.val = str;
        }
        tmp->refcount=1;
-       tmp->is_ref=0;
+       tmp->EA=0;
        return zend_hash_update(arg->value.obj.properties, key, strlen(key)+1, (void *) &tmp, sizeof(zval *), NULL);
 }
 
@@ -550,7 +550,7 @@ ZEND_API inline int add_property_stringl(zval *arg, char *key, char *str, uint l
                tmp->value.str.val = str;
        }
        tmp->refcount=1;
-       tmp->is_ref=0;
+       tmp->EA=0;
        return zend_hash_update(arg->value.obj.properties, key, strlen(key)+1, (void *) &tmp, sizeof(zval *), NULL);
 }
 

diff --git a/Zend/zend_API.h b/Zend/zend_API.h
index beba58f459bd0487f9806ca8ff5885f96d7c2714..85eb885de37ca178dcd7bcc3e2e5088b87b80433 100644 (file)
--- a/Zend/zend_API.h
+++ b/Zend/zend_API.h
@@ -186,7 +186,7 @@ ZEND_API int add_property_stringl(zval *arg, char *key, char *str, uint length,
                                                                        var->value.str.val = (str); \
                                                                        var->value.str.len = strlen((str)); \
                                                                        var->type = IS_STRING; \
-                                                                       var->is_ref=0; \
+                                                                       var->EA=0; \
                                                                        var->refcount=1; \
                                                                        zend_hash_update(&EG(symbol_table), (n), strlen((n))+1, &var, sizeof(zval *), NULL); \
                                                                } \
@@ -199,7 +199,7 @@ ZEND_API int add_property_stringl(zval *arg, char *key, char *str, uint length,
                                                                                var->value.str.val = (v); \
                                                                                var->value.str.len = (l); \
                                                                                var->type = IS_STRING; \
-                                                                               var->is_ref=0; \
+                                                                               var->EA=0; \
                                                                                var->refcount=1; \
                                                                                zend_hash_update(&EG(symbol_table), name, strlen(name)+1, &var, sizeof(zval *), NULL); \
                                                                        } \
@@ -210,7 +210,7 @@ ZEND_API int add_property_stringl(zval *arg, char *key, char *str, uint length,
                                                                        \
                                                                        var->value.lval = (v); \
                                                                        var->type = IS_LONG; \
-                                                                       var->is_ref=0; \
+                                                                       var->EA=0; \
                                                                        var->refcount=1; \
                                                                        zend_hash_update(&EG(symbol_table), (n), strlen((n))+1, &var, sizeof(zval *), NULL); \
                                                                } \
@@ -221,7 +221,7 @@ ZEND_API int add_property_stringl(zval *arg, char *key, char *str, uint length,
                                                                        \
                                                                        var->value.dval = (v); \
                                                                        var->type = IS_DOUBLE; \
-                                                                       var->is_ref=0; \
+                                                                       var->EA=0; \
                                                                        var->refcount=1; \
                                                                        zend_hash_update(&EG(symbol_table)), (n), strlen((n))+1, &var, sizeof(zval *), NULL); \
                                                                } \

diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
index 10e4b78c162e2c61118d55ba8b6ecc0125a733f5..d12b504a2d1415f85f15a5606dd8c8267f89930c 100644 (file)
--- a/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@ -840,7 +840,7 @@ void do_return(znode *expr CLS_DC)
                var_uninit(&opline->op1.u.constant);
                opline->op1.op_type = IS_CONST;
                opline->op1.u.constant.refcount=1;
-               opline->op1.u.constant.is_ref=0;
+               opline->op1.u.constant.EA=0;
        }
        SET_UNUSED(opline->op2);
 }
@@ -1039,7 +1039,7 @@ void do_brk_cont(int op, znode *expr CLS_DC)
                opline->op2.u.constant.type = IS_LONG;
                opline->op2.u.constant.value.lval = 1;
                opline->op2.u.constant.refcount=1;
-               opline->op2.u.constant.is_ref=0;
+               opline->op2.u.constant.EA=0;
                opline->op2.op_type = IS_CONST;
        }
 }
@@ -1190,7 +1190,7 @@ void do_default_before_statement(znode *case_list, znode *default_token CLS_DC)
        opline->op1.u.constant.type = IS_LONG;
        opline->op1.u.constant.value.lval = 1;
        opline->op1.u.constant.refcount=1;
-       opline->op1.u.constant.is_ref=0;
+       opline->op1.u.constant.EA=0;
        SET_UNUSED(opline->op2);
        switch_entry_ptr->default_case = next_op_number;
 
@@ -1423,7 +1423,7 @@ void do_shell_exec(znode *result, znode *cmd CLS_DC)
        opline->op1.u.constant.value.str.val = estrndup("shell_exec",sizeof("shell_exec")-1);
        opline->op1.u.constant.value.str.len = sizeof("shell_exec")-1;
        opline->op1.u.constant.refcount = 1;
-       opline->op1.u.constant.is_ref = 0;
+       opline->op1.u.constant.EA = 0;
        opline->op1.u.constant.type = IS_STRING;
        opline->op1.op_type = IS_CONST;
        opline->extended_value = 1;
@@ -1562,7 +1562,7 @@ void do_list_end(znode *result, znode *expr CLS_DC)
                        opline->op2.u.constant.type = IS_LONG;
                        opline->op2.u.constant.value.lval = *((int *) dimension->data);
                        opline->op2.u.constant.refcount = 1;
-                       opline->op2.u.constant.is_ref = 0;
+                       opline->op2.u.constant.EA = 0;
                        if (le == CG(list_llist).tail) {
                                opline->extended_value = ZEND_FETCH_STANDARD;
                        } else {
@@ -1973,7 +1973,7 @@ int zendlex(znode *zendlval CLS_DC)
        }
                
        zendlval->u.constant.refcount = 1;
-       zendlval->u.constant.is_ref = 0;
+       zendlval->u.constant.EA = 0;
        zendlval->op_type = IS_CONST;
        return retval;
 }

diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c
index 1254206539752200f1e2c32fe02da29be2840fba..366226b8a651f97d7461d393a5e35f93b1145b6b 100644 (file)
--- a/Zend/zend_execute.c
+++ b/Zend/zend_execute.c
@@ -95,7 +95,7 @@ static inline zval *_get_zval_ptr(znode *node, temp_variable *Ts, int *should_fr
                                        case IS_OVERLOADED_OBJECT:
                                                Ts[node->u.var].tmp_var = get_overloaded_property(ELS_C);
                                                Ts[node->u.var].tmp_var.refcount=1;
-                                               Ts[node->u.var].tmp_var.is_ref=1;
+                                               Ts[node->u.var].tmp_var.EA=1;
                                                return &Ts[node->u.var].tmp_var;
                                                break;
                                        case IS_STRING_OFFSET: {
@@ -114,7 +114,7 @@ static inline zval *_get_zval_ptr(znode *node, temp_variable *Ts, int *should_fr
                                                        }
                                                        zval_ptr_dtor(&str);
                                                        T->tmp_var.refcount=1;
-                                                       T->tmp_var.is_ref=1;
+                                                       T->tmp_var.EA=1;
                                                        T->tmp_var.type = IS_STRING;
                                                        return &T->tmp_var;
                                                }
@@ -264,14 +264,14 @@ static inline void zend_assign_to_variable(znode *result, znode *op1, znode *op2
                return;
        }
        
-       if (variable_ptr->is_ref) {
+       if (variable_ptr->EA) {
                if (variable_ptr!=value) {
                        short refcount=variable_ptr->refcount;
        
                        zendi_zval_dtor(*variable_ptr);
                        *variable_ptr = *value;
                        variable_ptr->refcount = refcount;
-                       variable_ptr->is_ref=1;
+                       variable_ptr->EA=1;
                        if (type!=IS_TMP_VAR) {
                                zendi_zval_copy_ctor(*variable_ptr);
                        }
@@ -284,7 +284,7 @@ static inline void zend_assign_to_variable(znode *result, znode *op1, znode *op2
                                case IS_CONST:
                                        if (variable_ptr==value) {
                                                variable_ptr->refcount++;
-                                       } else if (value->is_ref) {
+                                       } else if (value->EA) {
                                                zval tmp = *value;
 
                                                tmp = *value;
@@ -309,7 +309,7 @@ static inline void zend_assign_to_variable(znode *result, znode *op1, znode *op2
                        switch (type) {
                                case IS_VAR:
                                case IS_CONST:
-                                       if (value->is_ref) {
+                                       if (value->EA) {
                                                variable_ptr = *variable_ptr_ptr = (zval *) emalloc(sizeof(zval));
                                                *variable_ptr = *value;
                                                zval_copy_ctor(variable_ptr);
@@ -326,7 +326,7 @@ static inline void zend_assign_to_variable(znode *result, znode *op1, znode *op2
                                        break;
                        }
                }
-               (*variable_ptr_ptr)->is_ref=0;
+               (*variable_ptr_ptr)->EA=0;
        }
        if (result) {
                Ts[result->u.var].var = variable_ptr_ptr;
@@ -558,11 +558,11 @@ static inline void zend_fetch_dimension_address(znode *result, znode *op1, znode
                switch (type) {
                        case BP_VAR_RW:
                        case BP_VAR_W:
-                               if (!container->is_ref) {
+                               if (!container->EA) {
                                        container->refcount--;
                                        if (container->refcount>0) {
                                                container = *container_ptr = (zval *) emalloc(sizeof(zval));
-                                               container->is_ref=0;
+                                               container->EA=0;
                                        }
                                        container->refcount=1;
                                }
@@ -573,13 +573,13 @@ static inline void zend_fetch_dimension_address(znode *result, znode *op1, znode
 
        switch (container->type) {
                case IS_ARRAY:
-                       if ((type==BP_VAR_W || type==BP_VAR_RW) && container->refcount>1 && !container->is_ref) {
+                       if ((type==BP_VAR_W || type==BP_VAR_RW) && container->refcount>1 && !container->EA) {
                                container->refcount--;
                                *container_ptr = (zval *) emalloc(sizeof(zval));
                                **container_ptr = *container;
                                container = *container_ptr;
                                container->refcount=1;
-                               container->is_ref=0;
+                               container->EA=0;
                                zendi_zval_copy_ctor(*container);
                        }
                        if (op2->op_type == IS_UNUSED) {
@@ -725,11 +725,11 @@ static inline void zend_fetch_property_address(znode *result, znode *op1, znode
                switch (type) {
                        case BP_VAR_RW:
                        case BP_VAR_W:
-                               if (!container->is_ref) {
+                               if (!container->EA) {
                                        container->refcount--;
                                        if (container->refcount>0) {
                                                container = *container_ptr = (zval *) emalloc(sizeof(zval));
-                                               container->is_ref=0;
+                                               container->EA=0;
                                        }
                                        container->refcount=1;
                                }
@@ -754,13 +754,13 @@ static inline void zend_fetch_property_address(znode *result, znode *op1, znode
        }
 
 
-       if ((type==BP_VAR_W || type==BP_VAR_RW) && container->refcount>1 && !container->is_ref) {
+       if ((type==BP_VAR_W || type==BP_VAR_RW) && container->refcount>1 && !container->EA) {
                container->refcount--;
                *container_ptr = (zval *) emalloc(sizeof(zval));
                **container_ptr = *container;
                container = *container_ptr;
                container->refcount=1;
-               container->is_ref=0;
+               container->EA=0;
                zendi_zval_copy_ctor(*container);
        }
        INC_AI_COUNT(result);
@@ -856,7 +856,7 @@ void execute(zend_op_array *op_array ELS_DC)
                zval *globals = (zval *) emalloc(sizeof(zval));
 
                globals->refcount=1;
-               globals->is_ref=1;
+               globals->EA=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) {
@@ -974,7 +974,7 @@ binary_assign_op_addr: {
                                                opline++;
                                                continue;
                                        }
-                                       if (!(*var_ptr)->is_ref) {
+                                       if (!(*var_ptr)->EA) {
                                                if ((*var_ptr)->refcount>1) {
                                                        zval *orig_var=*var_ptr;
                                                        
@@ -1017,7 +1017,7 @@ binary_assign_op_addr: {
                                                        zendi_zval_copy_ctor(Ts[opline->result.u.var].tmp_var);
                                                        break;
                                        }
-                                       if (!(*var_ptr)->is_ref) {
+                                       if (!(*var_ptr)->EA) {
                                                if ((*var_ptr)->refcount>1) {
                                                        zval *orig_var = *var_ptr;
                                                        
@@ -1359,7 +1359,7 @@ do_fcall_common:
 
                                                        var_uninit(dummy);
                                                        dummy->refcount=1;
-                                                       dummy->is_ref=0;
+                                                       dummy->EA=0;
                                                        zend_hash_update_ptr(function_state.function_symbol_table, "this", sizeof("this"), dummy, sizeof(zval *), (void **) &this_ptr);
                                                        zend_assign_to_variable_reference(NULL, this_ptr, object_ptr, NULL ELS_CC);
                                                        object_ptr = NULL;
@@ -1420,7 +1420,7 @@ do_fcall_common:
 
                                        *valptr = Ts[opline->op1.u.var].tmp_var;
                                        valptr->refcount=1;
-                                       valptr->is_ref=0;
+                                       valptr->EA=0;
                                        zend_ptr_stack_push(&EG(argument_stack), valptr);
                                }
                                break;
@@ -1439,13 +1439,13 @@ do_fcall_common:
                                                varptr = (zval *) emalloc(sizeof(zval));
                                                var_uninit(varptr);
                                                varptr->refcount=0;
-                                               varptr->is_ref=0;
-                                       } else if (varptr->is_ref) {
+                                               varptr->EA=0;
+                                       } else if (varptr->EA) {
                                                zval *original_var = varptr;
 
                                                varptr = (zval *) emalloc(sizeof(zval));
                                                *varptr = *original_var;
-                                               varptr->is_ref = 0;
+                                               varptr->EA = 0;
                                                varptr->refcount = 0;
                                                zval_copy_ctor(varptr);
                                        }
@@ -1459,7 +1459,7 @@ send_by_ref:
                                        zval **varptr_ptr = get_zval_ptr_ptr(&opline->op1, Ts, BP_VAR_W);
                                        zval *varptr = *varptr_ptr;
 
-                                       if (!varptr->is_ref) {
+                                       if (!varptr->EA) {
                                                /* code to break away this variable */
                                                if (varptr->refcount>1) {
                                                        varptr->refcount--;
@@ -1469,7 +1469,7 @@ send_by_ref:
                                                        varptr->refcount = 1;
                                                        zval_copy_ctor(varptr);
                                                }
-                                               varptr->is_ref = 1;
+                                               varptr->EA = 1;
                                                /* at the end of this code refcount is always 1 */
                                        }
                                        varptr->refcount++;
@@ -1482,7 +1482,7 @@ send_by_ref:
                                        if (zend_ptr_stack_get_arg(opline->op1.u.constant.value.lval, (void **) &param ELS_CC)==FAILURE) {
                                                zend_error(E_NOTICE, "Missing argument %d for %s()\n", opline->op1.u.constant.value.lval, get_active_function_name());
                                                DEC_AI_COUNT();
-                                       } else if ((*param)->is_ref) {
+                                       } else if ((*param)->EA) {
                                                zend_assign_to_variable_reference(NULL, get_zval_ptr_ptr(&opline->result, Ts, BP_VAR_W), param, NULL ELS_CC);
                                        } else {
                                                zend_assign_to_variable(NULL, &opline->result, NULL, *param, IS_VAR, Ts ELS_CC);
@@ -1509,7 +1509,7 @@ send_by_ref:
                                                                *default_value = tmp;
                                                        }
                                                        default_value->refcount=0;
-                                                       default_value->is_ref=0;
+                                                       default_value->EA=0;
                                                        param = &default_value;
                                                        assignment_value = default_value;
                                                } else {
@@ -1520,7 +1520,7 @@ send_by_ref:
                                                assignment_value = *param;
                                        }
 
-                                       if (assignment_value->is_ref) {
+                                       if (assignment_value->EA) {
                                                zend_assign_to_variable_reference(NULL, get_zval_ptr_ptr(&opline->result, Ts, BP_VAR_W), param, NULL ELS_CC);
                                        } else {
                                                zend_assign_to_variable(NULL, &opline->result, NULL, assignment_value, IS_VAR, Ts ELS_CC);
@@ -1622,16 +1622,16 @@ send_by_ref:
                                                *new_expr = *expr;
                                                expr = new_expr;
                                                expr->refcount=1;
-                                               expr->is_ref=0;
+                                               expr->EA=0;
                                        } else {
-                                               if (expr->is_ref) {
+                                               if (expr->EA) {
                                                        zval *new_expr = (zval *) emalloc(sizeof(zval));
 
                                                        *new_expr = *expr;
                                                        expr = new_expr;
                                                        zendi_zval_copy_ctor(*expr);
                                                        expr->refcount=1;
-                                                       expr->is_ref=0;
+                                                       expr->EA=0;
                                                } else {
                                                        expr->refcount++;
                                                }
@@ -1810,7 +1810,7 @@ send_by_ref:
 
                                        key = (zval *) emalloc(sizeof(zval));
                                        key->refcount=1;
-                                       key->is_ref=0;
+                                       key->EA=0;
                                        switch (zend_hash_get_current_key(array->value.ht, &str_key, &int_key)) {
                                                case HASH_KEY_IS_STRING:
                                                        key->value.str.val = str_key;

diff --git a/Zend/zend_execute_API.c b/Zend/zend_execute_API.c
index 924b9f32cc3a81c49df9f63938d3dbca566e4a22..2ef18a263d777009859bfed1bf34c8961616664f 100644 (file)
--- a/Zend/zend_execute_API.c
+++ b/Zend/zend_execute_API.c
@@ -80,10 +80,10 @@ void init_executor(CLS_D ELS_DC)
        var_uninit(&EG(uninitialized_zval));
        var_uninit(&EG(error_zval));
        EG(uninitialized_zval).refcount = 1;
-       EG(uninitialized_zval).is_ref=0;
+       EG(uninitialized_zval).EA=0;
        EG(uninitialized_zval_ptr)=&EG(uninitialized_zval);
        EG(error_zval).refcount = 1;
-       EG(error_zval).is_ref=0;
+       EG(error_zval).EA=0;
        EG(error_zval_ptr)=&EG(error_zval);
        zend_ptr_stack_init(&EG(arg_types_stack));
        zend_stack_init(&EG(overloaded_objects_stack));
@@ -265,7 +265,7 @@ ZEND_API void zval_update_constant(zval *p)
                        *p = c;
                }
                p->refcount = 1;
-               p->is_ref = 0;
+               p->EA = 0;
        }
 }
 
@@ -300,7 +300,7 @@ int call_user_function(HashTable *function_table, zval *object, zval *function_n
                param = (zval *) emalloc(sizeof(zval));
                *param = *(params[i]);
                param->refcount=1;
-               param->is_ref=0;
+               param->EA=0;
                zval_copy_ctor(param);
                //zend_hash_next_index_insert_ptr(function_state.function_symbol_table, param, sizeof(zval *), NULL);
                zend_ptr_stack_push(&EG(argument_stack), param);
@@ -318,7 +318,7 @@ int call_user_function(HashTable *function_table, zval *object, zval *function_n
 
                        var_uninit(dummy);
                        dummy->refcount=1;
-                       dummy->is_ref=0;
+                       dummy->EA=0;
                        zend_hash_update_ptr(EG(active_symbol_table), "this", sizeof("this"), dummy, sizeof(zval *), (void **) &this_ptr);
                        zend_assign_to_variable_reference(NULL, this_ptr, &object, NULL ELS_CC);
                }
@@ -419,7 +419,7 @@ ZEND_API inline void zend_assign_to_variable_reference(znode *result, zval **var
                        efree(variable_ptr);
                }
 
-               if (!value_ptr->is_ref) {
+               if (!value_ptr->EA) {
                        /* break it away */
                        value_ptr->refcount--;
                        if (value_ptr->refcount>0) {
@@ -429,7 +429,7 @@ ZEND_API inline void zend_assign_to_variable_reference(znode *result, zval **var
                                zendi_zval_copy_ctor(*value_ptr);
                        }
                        value_ptr->refcount=1;
-                       value_ptr->is_ref=1;
+                       value_ptr->EA=1;
                }
 
                *variable_ptr_ptr = value_ptr;

diff --git a/Zend/zend_opcode.c b/Zend/zend_opcode.c
index ba351af1a7f71e2d2f3fe6f879585b3065d7971c..188df4c9137f90755fd550fa30bd6b05ea0f02a4 100644 (file)
--- a/Zend/zend_opcode.c
+++ b/Zend/zend_opcode.c
@@ -294,10 +294,10 @@ void pass_include_eval(zend_op_array *op_array)
 
        while (opline<end) {
                if (opline->op1.op_type==IS_CONST) {
-                       opline->op1.u.constant.is_ref = 1;
+                       opline->op1.u.constant.EA = 1;
                }
                if (opline->op2.op_type==IS_CONST) {
-                       opline->op2.u.constant.is_ref = 1;
+                       opline->op2.u.constant.EA = 1;
                }
                opline++;
        }

diff --git a/Zend/zend_operators.c b/Zend/zend_operators.c
index 181d01eddf109d72520468b1a04c205b4479fd32..35ab1c0197416b051b1a1ea4b5d201405b81792e 100644 (file)
--- a/Zend/zend_operators.c
+++ b/Zend/zend_operators.c
@@ -333,7 +333,7 @@ static void convert_scalar_to_array(zval *op, int type)
        
        *entry = *op;
        entry->refcount = 1;
-       entry->is_ref = 0;
+       entry->EA = 0;
        
        switch (type) {
                case IS_ARRAY:

diff --git a/ext/oci8/oci8.c b/ext/oci8/oci8.c
index 0954034d8adc9adf432623842480fd1e5be6eb70..d2549ffaade9b8cdbbda879965f2e0926a882f2e 100644 (file)
--- a/ext/oci8/oci8.c
+++ b/ext/oci8/oci8.c
@@ -3166,14 +3166,14 @@ PHP_FUNCTION(oci8_fetchinto)
 
 #if PHP_API_VERSION >= 19990421
                element = emalloc(sizeof(pval));
-               element->is_ref=0;
+               element->EA=0;
                element->refcount=1;
 #endif
 
                if ((mode & OCI_NUM) || (! (mode & OCI_ASSOC))) { /* OCI_NUM is default */
                        oci8_make_pval(element,statement,column, "OCIFetchInto",mode);
 #if PHP_API_VERSION >= 19990421
-                       element->is_ref = 0;
+                       element->EA = 0;
                        element->refcount = 1;
                        _php3_hash_index_update(array->value.ht, i, (void *)&element, sizeof(pval*), NULL);
 #else
@@ -3257,14 +3257,14 @@ PHP_FUNCTION(oci8_fetchstatement)
 
 #if PHP_API_VERSION >= 19990421
                tmp = emalloc(sizeof(pval));
-               tmp->is_ref = 0;
+               tmp->EA = 0;
                tmp->refcount = 1;
 #endif
 
                array_init(tmp);
 
 #if PHP_API_VERSION >= 19990421
-               tmp->is_ref = 0;
+               tmp->EA = 0;
                tmp->refcount = 1;
 #endif
 
@@ -3298,7 +3298,7 @@ PHP_FUNCTION(oci8_fetchstatement)
                        _php3_hash_index_update(outarrs[ i ]->value.ht, rows, (void *)element, sizeof(pval), NULL);
 #else
                        element->refcount = 1;
-                       element->is_ref = 0;
+                       element->EA = 0;
                        _php3_hash_index_update((*(outarrs[ i ]))->value.ht, rows, (void *)&element, sizeof(pval*), NULL);
 #endif
                }

diff --git a/ext/oracle/oracle.c b/ext/oracle/oracle.c
index 71851920dce68254187c55bf6c5f58c913885423..2b0a22ae7f1f8206bcee803e6c45794e5a6f2269 100644 (file)
--- a/ext/oracle/oracle.c
+++ b/ext/oracle/oracle.c
@@ -1225,7 +1225,7 @@ void php3_Ora_FetchInto(INTERNAL_FUNCTION_PARAMETERS)
                } else {
 #if PHP_API_VERSION >= 19990421
                        tmp = emalloc(sizeof(pval));
-                       tmp->is_ref = 0;
+                       tmp->EA = 0;
                        tmp->refcount = 1;
 #endif
 

diff --git a/ext/pcre/php_pcre.c b/ext/pcre/php_pcre.c
index ed1245cf021ed537cb5c7414bc2eec25c06a1424..2e80d02f65dd5679917e76d34a5ba0d900d74777 100644 (file)
--- a/ext/pcre/php_pcre.c
+++ b/ext/pcre/php_pcre.c
@@ -394,7 +394,7 @@ static void _pcre_match(INTERNAL_FUNCTION_PARAMETERS, int global)
                for (i=0; i<num_subpats; i++) {
                        match_sets[i] = (zval *)emalloc(sizeof(zval));
                        array_init(match_sets[i]);
-                       match_sets[i]->is_ref = 0;
+                       match_sets[i]->EA = 0;
                        match_sets[i]->refcount = 1;
                }
        }
@@ -444,7 +444,7 @@ static void _pcre_match(INTERNAL_FUNCTION_PARAMETERS, int global)
                                                /* Allocate the result set array */
                                                result_set = emalloc(sizeof(zval));
                                                array_init(result_set);
-                                               result_set->is_ref = 0;
+                                               result_set->EA = 0;
                                                result_set->refcount = 1;
                                                
                                                /* Add all the subpatterns to it */

diff --git a/ext/rpc/com/COM.c b/ext/rpc/com/COM.c
index 404d069fb4fac6a374a7986cc572792eb3c2d592..4bf5d4057266d05e16d9a7a5f27b07ed469d1fc5 100644 (file)
--- a/ext/rpc/com/COM.c
+++ b/ext/rpc/com/COM.c
@@ -837,7 +837,7 @@ void php_COM_call_function_handler(INTERNAL_FUNCTION_PARAMETERS, zend_property_r
                *object_handle = *return_value;
                pval_copy_constructor(object_handle);
                object_handle->refcount = 1;
-               object_handle->is_ref=0;
+               object_handle->EA=0;
                zend_hash_index_update(object->value.obj.properties, 0, &object_handle, sizeof(pval *), NULL);
                pval_destructor(&function_name->element);
        } else {

diff --git a/ext/standard/basic_functions.c b/ext/standard/basic_functions.c
index 6333f7b4d157c05ef9e44d64e3f3558b03309ebc..ac1e7169706d5d5ad6b8303a3c1351da5f919f4c 100644 (file)
--- a/ext/standard/basic_functions.c
+++ b/ext/standard/basic_functions.c
@@ -1082,11 +1082,11 @@ void array_each(INTERNAL_FUNCTION_PARAMETERS)
        entry = *entry_ptr;
 
        /* add value elements */
-       if (entry->is_ref) {
+       if (entry->EA) {
                tmp = (pval *)emalloc(sizeof(pval));
                *tmp = *entry;
                pval_copy_constructor(tmp);
-               tmp->is_ref=0;
+               tmp->EA=0;
                tmp->refcount=0;
                entry=tmp;
        }
@@ -1131,7 +1131,7 @@ void array_reset(INTERNAL_FUNCTION_PARAMETERS)
        *return_value = **entry;
        pval_copy_constructor(return_value);
        return_value->refcount=1;
-       return_value->is_ref=0;
+       return_value->EA=0;
 }
 
 void array_current(INTERNAL_FUNCTION_PARAMETERS)
@@ -2362,7 +2362,7 @@ PHP_FUNCTION(extract)
                                        data = (zval *)emalloc(sizeof(zval));
                                        *data = *entry;
                                        zval_copy_ctor(data);
-                                       data->is_ref = 0;
+                                       data->EA = 0;
                                        data->refcount = 1;
 
                                        zend_hash_update(EG(active_symbol_table), finalname,
@@ -2392,7 +2392,7 @@ static void _compact_var(HashTable *eg_active_symbol_table, zval *return_value,
                        data = (zval *)emalloc(sizeof(zval));
                        *data = *value;
                        zval_copy_ctor(data);
-                       data->is_ref = 0;
+                       data->EA = 0;
                        data->refcount = 1;
                        
                        zend_hash_update(return_value->value.ht, entry->value.str.val,
@@ -2604,7 +2604,7 @@ static void _phpi_pop(INTERNAL_FUNCTION_PARAMETERS, int off_the_end)
        *return_value = **val;
        zval_copy_ctor(return_value);
        return_value->refcount=1;
-       return_value->is_ref=0;
+       return_value->EA=0;
        
        /* Delete the first or last value */
        new_hash = _phpi_splice(stack->value.ht, (off_the_end) ? -1 : 0, 1, NULL, 0, NULL);
@@ -2919,7 +2919,7 @@ PHP_FUNCTION(array_keys)
        zend_hash_internal_pointer_reset(input->value.ht);
        while(zend_hash_get_current_data(input->value.ht, (void **)&entry) == SUCCESS) {
                new_val = (zval *)emalloc(sizeof(zval));
-               new_val->is_ref = 0;
+               new_val->EA = 0;
                new_val->refcount = 1;
                
                switch (zend_hash_get_current_key(input->value.ht, &string_key, &num_key)) {

diff --git a/ext/standard/fsock.c b/ext/standard/fsock.c
index 1e863aa2c504690a2a9415714069ced725a44aec..4469eab1220cfde1e29f801ed97de87769df3669 100644 (file)
--- a/ext/standard/fsock.c
+++ b/ext/standard/fsock.c
@@ -715,9 +715,10 @@ size_t _php3_sock_fread(char *ptr, size_t size, int socket)
 
        /* {{{ _php3_sock_destroy */
 #ifndef ZTS
-static void _php3_msock_destroy(int *data)
+static int _php3_msock_destroy(int *data)
 {
        close(*data);
+       return 1;
 }
 #endif
 /* }}} */
@@ -727,7 +728,7 @@ int php3_minit_fsock(INIT_FUNC_ARGS)
 {
 #ifndef ZTS
        _php3_hash_init(&PG(ht_fsock_keys), 0, NULL, NULL, 1);
-       _php3_hash_init(&PG(ht_fsock_socks), 0, NULL, (void (*)(void *))_php3_msock_destroy, 1);
+       _php3_hash_init(&PG(ht_fsock_socks), 0, NULL, (int (*)(void *))_php3_msock_destroy, 1);
 #endif
        return SUCCESS;
 }

diff --git a/ext/standard/iptc.c b/ext/standard/iptc.c
index 7b017ebb7a23e6002ceb2fa7a1ba593f52aab950..78843059f45f4b08d689e7d90e8fb76c8faeecaa 100644 (file)
--- a/ext/standard/iptc.c
+++ b/ext/standard/iptc.c
@@ -368,7 +368,7 @@ PHP_FUNCTION(iptcparse)
 
                if (_php3_hash_find(return_value->value.ht,key,strlen(key) + 1,(void **) &element) == FAILURE) {
                        values = emalloc(sizeof(pval));
-                       values->is_ref = 0;
+                       values->EA = 0;
                        values->refcount = 1;
                        if (array_init(values) == FAILURE) {
                                php3_error(E_ERROR, "Unable to initialize array");

diff --git a/ext/standard/post.c b/ext/standard/post.c
index 168357f7d5e62db0a06dcedf33078c85f436c05e..8d23632a736e22d98ae48190ae6ffcd47f56e8f4 100644 (file)
--- a/ext/standard/post.c
+++ b/ext/standard/post.c
@@ -144,7 +144,7 @@ static char *php3_getpost(pval *http_post_vars PLS_DC)
                postdata_ptr->value.str.val = (char *) estrdup(buf);
                postdata_ptr->value.str.len = cnt;
                postdata_ptr->refcount=1;
-               postdata_ptr->is_ref=0;
+               postdata_ptr->EA=0;
                _php3_hash_add(&symbol_table, "HTTP_FDF_DATA", sizeof("HTTP_FDF_DATA"), postdata_ptr, sizeof(pval *),NULL);
        }
 #endif
@@ -225,7 +225,7 @@ void _php3_parse_gpc_data(char *val, char *var, pval *track_vars_array)
                if (_php3_hash_find(EG(active_symbol_table), var, var_len+1, (void **) &arr_ptr) == FAILURE) {
                        arr1 = (pval *) emalloc(sizeof(pval));
                        arr1->refcount=1;
-                       arr1->is_ref=0;
+                       arr1->EA=0;
                        if (array_init(arr1)==FAILURE) {
                                return;
                        }
@@ -233,7 +233,7 @@ void _php3_parse_gpc_data(char *val, char *var, pval *track_vars_array)
                        if (track_vars_array) {
                                arr2 = (pval *) emalloc(sizeof(pval));
                                arr2->refcount=1;
-                               arr2->is_ref=0;
+                               arr2->EA=0;
                                if (array_init(arr2)==FAILURE) {
                                        return;
                                }
@@ -244,7 +244,7 @@ void _php3_parse_gpc_data(char *val, char *var, pval *track_vars_array)
                                if (--(*arr_ptr) > 0) {
                                        *arr_ptr = (pval *) emalloc(sizeof(pval));
                                        (*arr_ptr)->refcount=1;
-                                       (*arr_ptr)->is_ref=0;
+                                       (*arr_ptr)->EA=0;
                                } else {
                                        pval_destructor(*arr_ptr);
                                }
@@ -254,7 +254,7 @@ void _php3_parse_gpc_data(char *val, char *var, pval *track_vars_array)
                                if (track_vars_array) {
                                        arr2 = (pval *) emalloc(sizeof(pval));
                                        arr2->refcount=1;
-                                       arr2->is_ref=0;
+                                       arr2->EA=0;
                                        if (array_init(arr2)==FAILURE) {
                                                return;
                                        }
@@ -270,7 +270,7 @@ void _php3_parse_gpc_data(char *val, char *var, pval *track_vars_array)
                /* Now create the element */
                entry = (pval *) emalloc(sizeof(pval));
                entry->refcount=1;
-               entry->is_ref=0;
+               entry->EA=0;
                entry->value.str.val = val;
                entry->value.str.len = val_len;
                entry->type = IS_STRING;
@@ -304,7 +304,7 @@ void _php3_parse_gpc_data(char *val, char *var, pval *track_vars_array)
                
                entry->type = IS_STRING;
                entry->refcount=1;
-               entry->is_ref=0;
+               entry->EA=0;
                entry->value.str.val = val;
                entry->value.str.len = val_len;
                _php3_hash_update(EG(active_symbol_table), var, var_len+1, (void *) &entry, sizeof(pval *),NULL);
@@ -333,7 +333,7 @@ void php3_treat_data(int arg, char *str)
                                array_ptr = (pval *) emalloc(sizeof(pval));
                                array_init(array_ptr);
                                array_ptr->refcount=1;
-                               array_ptr->is_ref=0;
+                               array_ptr->EA=0;
                                switch (arg) {
                                        case PARSE_POST:
                                                _php3_hash_add(&EG(symbol_table), "HTTP_POST_VARS", sizeof("HTTP_POST_VARS"), &array_ptr, sizeof(pval *),NULL);

diff --git a/ext/standard/var.c b/ext/standard/var.c
index c370439e2289d6255727af6f96d1f3305530ab90..c05b7a6dec3cd68320b34620997393b1eb3c54e1 100644 (file)
--- a/ext/standard/var.c
+++ b/ext/standard/var.c
@@ -325,7 +325,7 @@ int php3api_var_unserialize(pval **rval, const char **p, const char *max)
                                (*rval)->type = IS_LONG;
                        }
                        (*rval)->refcount = 1;
-                       (*rval)->is_ref = 0;
+                       (*rval)->EA = 0;
                        (*rval)->value.lval = atol(q + 2);
                        return 1;
 
@@ -343,7 +343,7 @@ int php3api_var_unserialize(pval **rval, const char **p, const char *max)
                        (*p)++;
                        (*rval)->type = IS_DOUBLE;
                        (*rval)->refcount = 1;
-                       (*rval)->is_ref = 0;
+                       (*rval)->EA = 0;
                        (*rval)->value.dval = atof(q + 2);
                        return 1;
 
@@ -375,14 +375,14 @@ int php3api_var_unserialize(pval **rval, const char **p, const char *max)
                        (*rval)->value.str.val = str;
                        (*rval)->value.str.len = i;
                        (*rval)->refcount = 1;
-                       (*rval)->is_ref = 0;
+                       (*rval)->EA = 0;
                        return 1;
 
                case 'a':
                        (*rval)->type = IS_ARRAY;
 
                        (*rval)->refcount = 1;
-                       (*rval)->is_ref = 0;
+                       (*rval)->EA = 0;
                        (*p) += 2;
                        i = atoi(*p);
                        (*rval)->value.ht = (HashTable *) emalloc(sizeof(HashTable));
@@ -424,7 +424,7 @@ int php3api_var_unserialize(pval **rval, const char **p, const char *max)
                        (*rval)->type = IS_OBJECT;
 
                        (*rval)->refcount = 1;
-                       (*rval)->is_ref = 0;
+                       (*rval)->EA = 0;
                        (*p) += 2;
                        i = atoi(*p);
                        (*rval)->value.obj.properties = (HashTable *) emalloc(sizeof(HashTable));

diff --git a/ext/xml/xml.c b/ext/xml/xml.c
index e3a6634f0eef806db293f67732f96e41634fdc0a..4734fc46d74fc43d050d0f5b276f5b1fb852d1ef 100644 (file)
--- a/ext/xml/xml.c
+++ b/ext/xml/xml.c
@@ -109,7 +109,7 @@ static pval *php3i_long_pval(long value)
  
     ret->type = IS_LONG;
     ret->value.lval = value;
-       ret->is_ref = 0;
+       ret->EA = 0;
        ret->refcount = 1;
     return ret;
 }
@@ -121,7 +121,7 @@ static pval *php3i_string_pval(const char *str)
  
     ret->type = IS_STRING;
     ret->value.str.len = len;
-       ret->is_ref = 0;
+       ret->EA = 0;
        ret->refcount = 1;
     ret->value.str.val = estrndup(str, len);
     return ret;
@@ -647,7 +647,7 @@ static void php3i_add_to_info(xml_parser *parser,char *name)
                        return;
                }
 
-               values->is_ref = 0;
+               values->EA = 0;
                values->refcount = 1;
                
                _php3_hash_update(parser->info->value.ht, name, strlen(name)+1, (void *) &values, sizeof(pval*), (void **) &element);
@@ -712,11 +712,11 @@ void php3i_xml_startElementHandler(void *userData, const char *name,
                        int atcnt = 0;
 
                        tag = emalloc(sizeof(pval));
-                       tag->is_ref = 0;
+                       tag->EA = 0;
                        tag->refcount = 1;
 
                        atr = emalloc(sizeof(pval));
-                       atr->is_ref = 0;
+                       atr->EA = 0;
                        atr->refcount = 1;
 
                        array_init(tag);
@@ -802,7 +802,7 @@ void php3i_xml_endElementHandler(void *userData, const char *name)
                                tag = emalloc(sizeof(pval));
 
                                array_init(tag);
-                               tag->is_ref = 0;
+                               tag->EA = 0;
                                tag->refcount = 1;
                                  
                                php3i_add_to_info(parser,((char *) name) + parser->toffset);

diff --git a/main/main.c b/main/main.c
index 71bc4d603f714c4af144ea466474d49832473fcb..1373a3c0f5c97dc4b67f3cf7fc535e0bc350a03e 100644 (file)
--- a/main/main.c
+++ b/main/main.c
@@ -945,7 +945,7 @@ int _php3_hash_environment(PLS_D ELS_DC)
                tmp->value.str.val = estrndup(p + 1, tmp->value.str.len);
                tmp->type = IS_STRING;
                tmp->refcount=1;
-               tmp->is_ref=0;
+               tmp->EA=0;
                /* environmental variables never take precedence over get/post/cookie variables */
                _php3_hash_add(&EG(symbol_table), t, p - *env + 1, &tmp, sizeof(pval *), NULL);
                efree(t);
@@ -971,7 +971,7 @@ int _php3_hash_environment(PLS_D ELS_DC)
                                tmp->value.str.val = empty_string;
                        }
                        tmp->refcount=1;
-                       tmp->is_ref=0;
+                       tmp->EA=0;
                        tmp->type = IS_STRING;
                        _php3_hash_update(&EG(symbol_table), t, strlen(t)+1, &tmp, sizeof(pval *), NULL);
                }
@@ -984,7 +984,7 @@ int _php3_hash_environment(PLS_D ELS_DC)
                tmp->value.str.len = strlen(((request_rec *) SG(server_context))->uri);
                tmp->value.str.val = estrndup(((request_rec *) SG(server_context))->uri, tmp->value.str.len);
                tmp->refcount=1;
-               tmp->is_ref=0;
+               tmp->EA=0;
                tmp->type = IS_STRING;
                _php3_hash_update(&EG(symbol_table), "PHP_SELF", sizeof("PHP_SELF"), (void *) &tmp, sizeof(pval *), NULL);
        }
@@ -999,7 +999,7 @@ int _php3_hash_environment(PLS_D ELS_DC)
                tmp->value.str.len = _php3_sprintf(tmp->value.str.val, "%s", (pi ? pi : ""));   /* SAFE */
                tmp->type = IS_STRING;
                tmp->refcount=1;
-               tmp->is_ref=0;
+               tmp->EA=0;
 #else
                int l = 0;
                char *sn;
@@ -1018,7 +1018,7 @@ int _php3_hash_environment(PLS_D ELS_DC)
                tmp->value.str.len = _php3_sprintf(tmp->value.str.val, "%s%s", (sn ? sn : ""), (pi ? pi : "")); /* SAFE */
                tmp->type = IS_STRING;
                tmp->refcount=1;
-               tmp->is_ref=0;
+               tmp->EA=0;
 #endif
                _php3_hash_update(&EG(symbol_table), "PHP_SELF", sizeof("PHP_SELF"), (void *) & tmp, sizeof(pval *), NULL);
        }
@@ -1044,7 +1044,7 @@ void _php3_build_argv(char *s ELS_DC)
        } else {
                arr->type = IS_ARRAY;
                arr->refcount=1;
-               arr->is_ref=0;
+               arr->EA=0;
                _php3_hash_update(&EG(symbol_table), "argv", sizeof("argv"), &arr, sizeof(pval *), NULL);
        }
        /* now pick out individual entries */
@@ -1060,7 +1060,7 @@ void _php3_build_argv(char *s ELS_DC)
                tmp->value.str.len = strlen(ss);
                tmp->value.str.val = estrndup(ss, tmp->value.str.len);
                tmp->refcount=1;
-               tmp->is_ref=0;
+               tmp->EA=0;
                count++;
                if (_php3_hash_next_index_insert(arr->value.ht, &tmp, sizeof(pval *), NULL)==FAILURE) {
                        if (tmp->type == IS_STRING) {
@@ -1078,7 +1078,7 @@ void _php3_build_argv(char *s ELS_DC)
        tmp->value.lval = count;
        tmp->type = IS_LONG;
        tmp->refcount=1;
-       tmp->is_ref=0;
+       tmp->EA=0;
        _php3_hash_add(&EG(symbol_table), "argc", sizeof("argc"), &tmp, sizeof(pval *), NULL);
 }
 

diff --git a/main/rfc1867.c b/main/rfc1867.c
index a284e6ff939449e0c95b119d3bfc5707451ace69..86f07fbbf7b264e7ea8995adaa855e7ab1f4700f 100644 (file)
--- a/main/rfc1867.c
+++ b/main/rfc1867.c
@@ -62,7 +62,7 @@ void php_mime_split(char *buf, int cnt, char *boundary)
                http_post_vars = (pval *) emalloc(sizeof(pval));
                array_init(http_post_vars);
                http_post_vars->refcount=1;
-               http_post_vars->is_ref=0;
+               http_post_vars->EA=0;
                
                zend_hash_add(&EG(symbol_table), "HTTP_POST_VARS", sizeof("HTTP_POST_VARS"), &http_post_vars, sizeof(pval *), NULL);
        }