Make consistent use of Z_*VAL macros in compiler

diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
index a592586290a059f6760ee8bebf812b4b3a887a28..699231ba5219c28c7527b23b42177ff566732d87 100644 (file)
--- a/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@ -153,12 +153,12 @@ static void build_runtime_defined_function_key(zval *result, const char *name, i
        }
 
        /* NULL, name length, filename length, last accepting char position length */
-       result->value.str.len = 1+name_length+strlen(filename)+char_pos_len;
+       Z_STRLEN_P(result) = 1+name_length+strlen(filename)+char_pos_len;
 
        /* must be binary safe */
-       result->value.str.val = (char *) safe_emalloc(result->value.str.len, 1, 1);
-       result->value.str.val[0] = '\0';
-       sprintf(result->value.str.val+1, "%s%s%s", name, filename, char_pos_buf);
+       Z_STRVAL_P(result) = (char *) safe_emalloc(Z_STRLEN_P(result), 1, 1);
+       Z_STRVAL_P(result)[0] = '\0';
+       sprintf(Z_STRVAL_P(result)+1, "%s%s%s", name, filename, char_pos_buf);
 
        result->type = IS_STRING;
        Z_SET_REFCOUNT_P(result, 1);
@@ -664,14 +664,14 @@ void fetch_simple_variable_ex(znode *result, znode *varname, int bp, zend_uchar
                } else if (IS_INTERNED(Z_STRVAL(varname->u.constant))) {
                        hash = INTERNED_HASH(Z_STRVAL(varname->u.constant));
                }
-               if (!zend_is_auto_global_quick(varname->u.constant.value.str.val, varname->u.constant.value.str.len, hash TSRMLS_CC) &&
-                   !(varname->u.constant.value.str.len == (sizeof("this")-1) &&
-                     !memcmp(varname->u.constant.value.str.val, "this", sizeof("this"))) &&
+               if (!zend_is_auto_global_quick(Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant), hash TSRMLS_CC) &&
+                   !(Z_STRLEN(varname->u.constant) == (sizeof("this")-1) &&
+                     !memcmp(Z_STRVAL(varname->u.constant), "this", sizeof("this"))) &&
                    (CG(active_op_array)->last == 0 ||
                     CG(active_op_array)->opcodes[CG(active_op_array)->last-1].opcode != ZEND_BEGIN_SILENCE)) {
                        result->op_type = IS_CV;
-                       result->u.op.var = lookup_cv(CG(active_op_array), varname->u.constant.value.str.val, varname->u.constant.value.str.len, hash TSRMLS_CC);
-                       varname->u.constant.value.str.val = (char*)CG(active_op_array)->vars[result->u.op.var].name;
+                       result->u.op.var = lookup_cv(CG(active_op_array), Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant), hash TSRMLS_CC);
+                       Z_STRVAL(varname->u.constant) = (char*)CG(active_op_array)->vars[result->u.op.var].name;
                        result->EA = 0;
                        return;
                }
@@ -694,7 +694,7 @@ void fetch_simple_variable_ex(znode *result, znode *varname, int bp, zend_uchar
 
        if (varname->op_type == IS_CONST) {
                CALCULATE_LITERAL_HASH(opline_ptr->op1.constant);
-               if (zend_is_auto_global_quick(varname->u.constant.value.str.val, varname->u.constant.value.str.len, Z_HASH_P(&CONSTANT(opline_ptr->op1.constant)) TSRMLS_CC)) {
+               if (zend_is_auto_global_quick(Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant), Z_HASH_P(&CONSTANT(opline_ptr->op1.constant)) TSRMLS_CC)) {
                        opline_ptr->extended_value = ZEND_FETCH_GLOBAL;
                }
        }
@@ -882,9 +882,9 @@ void zend_do_abstract_method(const znode *function_name, znode *modifiers, const
                method_type = "Abstract";
        }
 
-       if (modifiers->u.constant.value.lval & ZEND_ACC_ABSTRACT) {
-               if(modifiers->u.constant.value.lval & ZEND_ACC_PRIVATE) {
-                       zend_error(E_COMPILE_ERROR, "%s function %s::%s() cannot be declared private", method_type, CG(active_class_entry)->name, function_name->u.constant.value.str.val);
+       if (Z_LVAL(modifiers->u.constant) & ZEND_ACC_ABSTRACT) {
+               if(Z_LVAL(modifiers->u.constant) & ZEND_ACC_PRIVATE) {
+                       zend_error(E_COMPILE_ERROR, "%s function %s::%s() cannot be declared private", method_type, CG(active_class_entry)->name, Z_STRVAL(function_name->u.constant));
                }
                if (Z_LVAL(body->u.constant) == ZEND_ACC_ABSTRACT) {
                        zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
@@ -894,11 +894,11 @@ void zend_do_abstract_method(const znode *function_name, znode *modifiers, const
                        SET_UNUSED(opline->op2);
                } else {
                        /* we had code in the function body */
-                       zend_error(E_COMPILE_ERROR, "%s function %s::%s() cannot contain body", method_type, CG(active_class_entry)->name, function_name->u.constant.value.str.val);
+                       zend_error(E_COMPILE_ERROR, "%s function %s::%s() cannot contain body", method_type, CG(active_class_entry)->name, Z_STRVAL(function_name->u.constant));
                }
        } else {
-               if (body->u.constant.value.lval == ZEND_ACC_ABSTRACT) {
-                       zend_error(E_COMPILE_ERROR, "Non-abstract method %s::%s() must contain body", CG(active_class_entry)->name, function_name->u.constant.value.str.val);
+               if (Z_LVAL(body->u.constant) == ZEND_ACC_ABSTRACT) {
+                       zend_error(E_COMPILE_ERROR, "Non-abstract method %s::%s() must contain body", CG(active_class_entry)->name, Z_STRVAL(function_name->u.constant));
                }
        }
 }
@@ -1526,8 +1526,8 @@ int zend_do_verify_access_types(const znode *current_access_type, const znode *n
 void zend_do_begin_function_declaration(znode *function_token, znode *function_name, int is_method, int return_reference, znode *fn_flags_znode TSRMLS_DC) /* {{{ */
 {
        zend_op_array op_array;
-       char *name = function_name->u.constant.value.str.val;
-       int name_len = function_name->u.constant.value.str.len;
+       char *name = Z_STRVAL(function_name->u.constant);
+       int name_len = Z_STRLEN(function_name->u.constant);
        int function_begin_line = function_token->u.op.opline_num;
        zend_uint fn_flags;
        const char *lcname;
@@ -1537,7 +1537,7 @@ void zend_do_begin_function_declaration(znode *function_token, znode *function_n
        if (is_method) {
                if (CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE) {
                        if ((Z_LVAL(fn_flags_znode->u.constant) & ~(ZEND_ACC_STATIC|ZEND_ACC_PUBLIC))) {
-                               zend_error(E_COMPILE_ERROR, "Access type for interface method %s::%s() must be omitted", CG(active_class_entry)->name, function_name->u.constant.value.str.val);
+                               zend_error(E_COMPILE_ERROR, "Access type for interface method %s::%s() must be omitted", CG(active_class_entry)->name, Z_STRVAL(function_name->u.constant));
                        }
                        Z_LVAL(fn_flags_znode->u.constant) |= ZEND_ACC_ABSTRACT; /* propagates to the rest of the parser */
                }
@@ -1844,7 +1844,7 @@ void zend_do_receive_arg(zend_uchar op, znode *varname, const znode *offset, con
                zend_error(E_COMPILE_ERROR, "Cannot re-assign auto-global variable %s", Z_STRVAL(varname->u.constant));
        } else {
                var.op_type = IS_CV;
-               var.u.op.var = lookup_cv(CG(active_op_array), varname->u.constant.value.str.val, varname->u.constant.value.str.len, 0 TSRMLS_CC);
+               var.u.op.var = lookup_cv(CG(active_op_array), Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant), 0 TSRMLS_CC);
                Z_STRVAL(varname->u.constant) = (char*)CG(active_op_array)->vars[var.u.op.var].name;
                var.EA = 0;
                if (CG(active_op_array)->vars[var.u.op.var].hash_value == THIS_HASHVAL &&
@@ -1871,8 +1871,8 @@ void zend_do_receive_arg(zend_uchar op, znode *varname, const znode *offset, con
        }
        CG(active_op_array)->arg_info = erealloc(CG(active_op_array)->arg_info, sizeof(zend_arg_info)*(CG(active_op_array)->num_args));
        cur_arg_info = &CG(active_op_array)->arg_info[CG(active_op_array)->num_args-1];
-       cur_arg_info->name = zend_new_interned_string(estrndup(varname->u.constant.value.str.val, varname->u.constant.value.str.len), varname->u.constant.value.str.len + 1, 1 TSRMLS_CC);
-       cur_arg_info->name_len = varname->u.constant.value.str.len;
+       cur_arg_info->name = zend_new_interned_string(estrndup(Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant)), Z_STRLEN(varname->u.constant) + 1, 1 TSRMLS_CC);
+       cur_arg_info->name_len = Z_STRLEN(varname->u.constant);
        cur_arg_info->type_hint = 0;
        cur_arg_info->allow_null = 1;
        cur_arg_info->pass_by_reference = pass_by_reference;
@@ -1906,9 +1906,9 @@ void zend_do_receive_arg(zend_uchar op, znode *varname, const znode *offset, con
                                if (ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(class_type->u.constant), Z_STRLEN(class_type->u.constant))) {
                                        zend_resolve_class_name(class_type TSRMLS_CC);
                                }
-                               Z_STRVAL(class_type->u.constant) = (char*)zend_new_interned_string(class_type->u.constant.value.str.val, class_type->u.constant.value.str.len + 1, 1 TSRMLS_CC);
-                               cur_arg_info->class_name = class_type->u.constant.value.str.val;
-                               cur_arg_info->class_name_len = class_type->u.constant.value.str.len;
+                               Z_STRVAL(class_type->u.constant) = (char*)zend_new_interned_string(Z_STRVAL(class_type->u.constant), Z_STRLEN(class_type->u.constant) + 1, 1 TSRMLS_CC);
+                               cur_arg_info->class_name = Z_STRVAL(class_type->u.constant);
+                               cur_arg_info->class_name_len = Z_STRLEN(class_type->u.constant);
                                if (op == ZEND_RECV_INIT) {
                                        if (Z_TYPE(initialization->u.constant) == IS_NULL || (Z_TYPE(initialization->u.constant) == IS_CONSTANT && !strcasecmp(Z_STRVAL(initialization->u.constant), "NULL"))) {
                                                cur_arg_info->allow_null = 1;
@@ -1940,16 +1940,16 @@ int zend_do_begin_function_call(znode *function_name, zend_bool check_namespace
                        return 1;
        }
 
-       lcname = zend_str_tolower_dup(function_name->u.constant.value.str.val, function_name->u.constant.value.str.len);
-       if ((zend_hash_find(CG(function_table), lcname, function_name->u.constant.value.str.len+1, (void **) &function)==FAILURE) ||
+       lcname = zend_str_tolower_dup(Z_STRVAL(function_name->u.constant), Z_STRLEN(function_name->u.constant));
+       if ((zend_hash_find(CG(function_table), lcname, Z_STRLEN(function_name->u.constant)+1, (void **) &function)==FAILURE) ||
                ((CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_FUNCTIONS) &&
                (function->type == ZEND_INTERNAL_FUNCTION))) {
                        zend_do_begin_dynamic_function_call(function_name, 0 TSRMLS_CC);
                        efree(lcname);
                        return 1; /* Dynamic */
        }
-       efree(function_name->u.constant.value.str.val);
-       function_name->u.constant.value.str.val = lcname;
+       efree(Z_STRVAL(function_name->u.constant));
+       Z_STRVAL(function_name->u.constant) = lcname;
 
        zend_stack_push(&CG(function_call_stack), (void *) &function, sizeof(zend_function *));
        if (CG(context).nested_calls + 1 > CG(active_op_array)->nested_calls) {
@@ -2124,7 +2124,7 @@ void zend_do_resolve_class_name(znode *result, znode *class_name, int is_static
        int lctype;
        znode constant_name;
 
-       lcname = zend_str_tolower_dup(Z_STRVAL(class_name->u.constant), class_name->u.constant.value.str.len);
+       lcname = zend_str_tolower_dup(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant));
        lctype = zend_get_class_fetch_type(lcname, strlen(lcname));
        switch (lctype) {
                case ZEND_FETCH_CLASS_SELF:
@@ -2254,7 +2254,7 @@ void zend_do_fetch_class(znode *result, znode *class_name TSRMLS_DC) /* {{{ */
        if (class_name->op_type == IS_CONST) {
                int fetch_type;
 
-               fetch_type = zend_get_class_fetch_type(class_name->u.constant.value.str.val, class_name->u.constant.value.str.len);
+               fetch_type = zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant));
                switch (fetch_type) {
                        case ZEND_FETCH_CLASS_SELF:
                        case ZEND_FETCH_CLASS_PARENT:
@@ -2401,19 +2401,19 @@ void zend_do_build_full_name(znode *result, znode *prefix, znode *name, int is_c
        }
 
        if (is_class_member) {
-               length = sizeof("::")-1 + result->u.constant.value.str.len + name->u.constant.value.str.len;
-               result->u.constant.value.str.val = erealloc(result->u.constant.value.str.val, length+1);
-               memcpy(&result->u.constant.value.str.val[result->u.constant.value.str.len], "::", sizeof("::")-1);
-               memcpy(&result->u.constant.value.str.val[result->u.constant.value.str.len + sizeof("::")-1], name->u.constant.value.str.val, name->u.constant.value.str.len+1);
-               STR_FREE(name->u.constant.value.str.val);
-               result->u.constant.value.str.len = length;
+               length = sizeof("::")-1 + Z_STRLEN(result->u.constant) + Z_STRLEN(name->u.constant);
+               Z_STRVAL(result->u.constant) = erealloc(Z_STRVAL(result->u.constant), length+1);
+               memcpy(&Z_STRVAL(result->u.constant)[Z_STRLEN(result->u.constant)], "::", sizeof("::")-1);
+               memcpy(&Z_STRVAL(result->u.constant)[Z_STRLEN(result->u.constant) + sizeof("::")-1], Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant)+1);
+               STR_FREE(Z_STRVAL(name->u.constant));
+               Z_STRLEN(result->u.constant) = length;
        } else {
-               length = sizeof("\\")-1 + result->u.constant.value.str.len + name->u.constant.value.str.len;
-               result->u.constant.value.str.val = erealloc(result->u.constant.value.str.val, length+1);
-               memcpy(&result->u.constant.value.str.val[result->u.constant.value.str.len], "\\", sizeof("\\")-1);
-               memcpy(&result->u.constant.value.str.val[result->u.constant.value.str.len + sizeof("\\")-1], name->u.constant.value.str.val, name->u.constant.value.str.len+1);
-               STR_FREE(name->u.constant.value.str.val);
-               result->u.constant.value.str.len = length;
+               length = sizeof("\\")-1 + Z_STRLEN(result->u.constant) + Z_STRLEN(name->u.constant);
+               Z_STRVAL(result->u.constant) = erealloc(Z_STRVAL(result->u.constant), length+1);
+               memcpy(&Z_STRVAL(result->u.constant)[Z_STRLEN(result->u.constant)], "\\", sizeof("\\")-1);
+               memcpy(&Z_STRVAL(result->u.constant)[Z_STRLEN(result->u.constant) + sizeof("\\")-1], Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant)+1);
+               STR_FREE(Z_STRVAL(name->u.constant));
+               Z_STRLEN(result->u.constant) = length;
        }
 }
 /* }}} */
@@ -2894,7 +2894,7 @@ void zend_do_begin_catch(znode *catch_token, znode *class_name, znode *catch_var
        opline->op1_type = IS_CONST;
        opline->op1.constant = zend_add_class_name_literal(CG(active_op_array), &catch_class.u.constant TSRMLS_CC);
        opline->op2_type = IS_CV;
-       opline->op2.var = lookup_cv(CG(active_op_array), catch_var->u.constant.value.str.val, catch_var->u.constant.value.str.len, 0 TSRMLS_CC);
+       opline->op2.var = lookup_cv(CG(active_op_array), Z_STRVAL(catch_var->u.constant), Z_STRLEN(catch_var->u.constant), 0 TSRMLS_CC);
        Z_STRVAL(catch_var->u.constant) = (char*)CG(active_op_array)->vars[opline->op2.var].name;
        opline->result.num = 0; /* 1 means it's the last catch in the block */
 
@@ -4955,7 +4955,7 @@ void zend_do_begin_class_declaration(const znode *class_token, znode *class_name
                return;
        }
 
-       lcname = zend_str_tolower_dup(class_name->u.constant.value.str.val, class_name->u.constant.value.str.len);
+       lcname = zend_str_tolower_dup(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant));
 
        if (!(strcmp(lcname, "self") && strcmp(lcname, "parent"))) {
                efree(lcname);
@@ -5274,11 +5274,11 @@ void zend_do_declare_property(const znode *var_name, const znode *value, zend_ui
 
        if (access_type & ZEND_ACC_FINAL) {
                zend_error(E_COMPILE_ERROR, "Cannot declare property %s::$%s final, the final modifier is allowed only for methods and classes",
-                                  CG(active_class_entry)->name, var_name->u.constant.value.str.val);
+                                  CG(active_class_entry)->name, Z_STRVAL(var_name->u.constant));
        }
 
-       if (zend_hash_find(&CG(active_class_entry)->properties_info, var_name->u.constant.value.str.val, var_name->u.constant.value.str.len+1, (void **) &existing_property_info)==SUCCESS) {
-               zend_error(E_COMPILE_ERROR, "Cannot redeclare %s::$%s", CG(active_class_entry)->name, var_name->u.constant.value.str.val);
+       if (zend_hash_find(&CG(active_class_entry)->properties_info, Z_STRVAL(var_name->u.constant), Z_STRLEN(var_name->u.constant)+1, (void **) &existing_property_info)==SUCCESS) {
+               zend_error(E_COMPILE_ERROR, "Cannot redeclare %s::$%s", CG(active_class_entry)->name, Z_STRVAL(var_name->u.constant));
        }
        ALLOC_ZVAL(property);
 
@@ -5296,8 +5296,8 @@ void zend_do_declare_property(const znode *var_name, const znode *value, zend_ui
                CG(doc_comment_len) = 0;
        }
 
-       zend_declare_property_ex(CG(active_class_entry), zend_new_interned_string(var_name->u.constant.value.str.val, var_name->u.constant.value.str.len + 1, 0 TSRMLS_CC), var_name->u.constant.value.str.len, property, access_type, comment, comment_len TSRMLS_CC);
-       efree(var_name->u.constant.value.str.val);
+       zend_declare_property_ex(CG(active_class_entry), zend_new_interned_string(Z_STRVAL(var_name->u.constant), Z_STRLEN(var_name->u.constant) + 1, 0 TSRMLS_CC), Z_STRLEN(var_name->u.constant), property, access_type, comment, comment_len TSRMLS_CC);
+       efree(Z_STRVAL(var_name->u.constant));
 }
 /* }}} */
 
@@ -5319,16 +5319,16 @@ void zend_do_declare_class_constant(znode *var_name, const znode *value TSRMLS_D
        ALLOC_ZVAL(property);
        *property = value->u.constant;
 
-       cname = zend_new_interned_string(var_name->u.constant.value.str.val, var_name->u.constant.value.str.len+1, 0 TSRMLS_CC);
+       cname = zend_new_interned_string(Z_STRVAL(var_name->u.constant), Z_STRLEN(var_name->u.constant)+1, 0 TSRMLS_CC);
 
        if (IS_INTERNED(cname)) {
-               result = zend_hash_quick_add(&CG(active_class_entry)->constants_table, cname, var_name->u.constant.value.str.len+1, INTERNED_HASH(cname), &property, sizeof(zval *), NULL);
+               result = zend_hash_quick_add(&CG(active_class_entry)->constants_table, cname, Z_STRLEN(var_name->u.constant)+1, INTERNED_HASH(cname), &property, sizeof(zval *), NULL);
        } else {
-               result = zend_hash_add(&CG(active_class_entry)->constants_table, cname, var_name->u.constant.value.str.len+1, &property, sizeof(zval *), NULL);
+               result = zend_hash_add(&CG(active_class_entry)->constants_table, cname, Z_STRLEN(var_name->u.constant)+1, &property, sizeof(zval *), NULL);
        }
        if (result == FAILURE) {
                FREE_ZVAL(property);
-               zend_error(E_COMPILE_ERROR, "Cannot redefine class constant %s::%s", CG(active_class_entry)->name, var_name->u.constant.value.str.val);
+               zend_error(E_COMPILE_ERROR, "Cannot redefine class constant %s::%s", CG(active_class_entry)->name, Z_STRVAL(var_name->u.constant));
        }
        FREE_PNODE(var_name);
 
@@ -5773,11 +5773,11 @@ void zend_do_add_static_array_element(znode *result, znode *offset, const znode
                                Z_STRVAL(offset->u.constant) = erealloc(Z_STRVAL(offset->u.constant), Z_STRLEN(offset->u.constant)+3);
                                Z_STRVAL(offset->u.constant)[Z_STRLEN(offset->u.constant)+1] = Z_TYPE(offset->u.constant);
                                Z_STRVAL(offset->u.constant)[Z_STRLEN(offset->u.constant)+2] = 0;
-                               zend_symtable_update(result->u.constant.value.ht, Z_STRVAL(offset->u.constant), Z_STRLEN(offset->u.constant)+3, &element, sizeof(zval *), NULL);
+                               zend_symtable_update(Z_ARRVAL(result->u.constant), Z_STRVAL(offset->u.constant), Z_STRLEN(offset->u.constant)+3, &element, sizeof(zval *), NULL);
                                zval_dtor(&offset->u.constant);
                                break;
                        case IS_STRING:
-                               zend_symtable_update(result->u.constant.value.ht, offset->u.constant.value.str.val, offset->u.constant.value.str.len+1, &element, sizeof(zval *), NULL);
+                               zend_symtable_update(Z_ARRVAL(result->u.constant), Z_STRVAL(offset->u.constant), Z_STRLEN(offset->u.constant)+1, &element, sizeof(zval *), NULL);
                                zval_dtor(&offset->u.constant);
                                break;
                        case IS_NULL:
@@ -5954,7 +5954,7 @@ void zend_do_fetch_static_variable(znode *varname, const znode *static_assignmen
                ALLOC_HASHTABLE(CG(active_op_array)->static_variables);
                zend_hash_init(CG(active_op_array)->static_variables, 2, NULL, ZVAL_PTR_DTOR, 0);
        }
-       zend_hash_update(CG(active_op_array)->static_variables, varname->u.constant.value.str.val, varname->u.constant.value.str.len+1, &tmp, sizeof(zval *), NULL);
+       zend_hash_update(CG(active_op_array)->static_variables, Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant)+1, &tmp, sizeof(zval *), NULL);
 
        if (varname->op_type == IS_CONST) {
                if (Z_TYPE(varname->u.constant) != IS_STRING) {
@@ -6083,7 +6083,7 @@ void zend_do_indirect_references(znode *result, const znode *num_references, zno
        int i;
 
        zend_do_end_variable_parse(variable, BP_VAR_R, 0 TSRMLS_CC);
-       for (i=1; i<num_references->u.constant.value.lval; i++) {
+       for (i=1; i<Z_LVAL(num_references->u.constant); i++) {
                fetch_simple_variable_ex(result, variable, 0, ZEND_FETCH_R TSRMLS_CC);
                *variable = *result;
        }
@@ -6398,10 +6398,10 @@ void zend_do_declare_begin(TSRMLS_D) /* {{{ */
 
 void zend_do_declare_stmt(znode *var, znode *val TSRMLS_DC) /* {{{ */
 {
-       if (!zend_binary_strcasecmp(var->u.constant.value.str.val, var->u.constant.value.str.len, "ticks", sizeof("ticks")-1)) {
+       if (!zend_binary_strcasecmp(Z_STRVAL(var->u.constant), Z_STRLEN(var->u.constant), "ticks", sizeof("ticks")-1)) {
                convert_to_long(&val->u.constant);
                CG(declarables).ticks = val->u.constant;
-       } else if (!zend_binary_strcasecmp(var->u.constant.value.str.val, var->u.constant.value.str.len, "encoding", sizeof("encoding")-1)) {
+       } else if (!zend_binary_strcasecmp(Z_STRVAL(var->u.constant), Z_STRLEN(var->u.constant), "encoding", sizeof("encoding")-1)) {
                if ((Z_TYPE(val->u.constant) & IS_CONSTANT_TYPE_MASK) == IS_CONSTANT) {
                        zend_error(E_COMPILE_ERROR, "Cannot use constants as encoding");
                }
@@ -6433,9 +6433,9 @@ void zend_do_declare_stmt(znode *var, znode *val TSRMLS_DC) /* {{{ */
                        CG(encoding_declared) = 1;
 
                        convert_to_string(&val->u.constant);
-                       new_encoding = zend_multibyte_fetch_encoding(val->u.constant.value.str.val TSRMLS_CC);
+                       new_encoding = zend_multibyte_fetch_encoding(Z_STRVAL(val->u.constant) TSRMLS_CC);
                        if (!new_encoding) {
-                               zend_error(E_COMPILE_WARNING, "Unsupported encoding [%s]", val->u.constant.value.str.val);
+                               zend_error(E_COMPILE_WARNING, "Unsupported encoding [%s]", Z_STRVAL(val->u.constant));
                        } else {
                                old_input_filter = LANG_SCNG(input_filter);
                                old_encoding = LANG_SCNG(script_encoding);
@@ -6452,7 +6452,7 @@ void zend_do_declare_stmt(znode *var, znode *val TSRMLS_DC) /* {{{ */
                }
                zval_dtor(&val->u.constant);
        } else {
-               zend_error(E_COMPILE_WARNING, "Unsupported declare '%s'", var->u.constant.value.str.val);
+               zend_error(E_COMPILE_WARNING, "Unsupported declare '%s'", Z_STRVAL(var->u.constant));
                zval_dtor(&val->u.constant);
        }
        zval_dtor(&var->u.constant);