1 files changed, 116 insertions, 117 deletions

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index f49bf2b6b4..e72b16c470 100644
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -298,7 +298,7 @@ ZEND_VM_HELPER_EX(zend_binary_assign_op_obj_helper, VAR|UNUSED|CV, CONST|TMP|VAR
 	make_real_object(object_ptr TSRMLS_CC);
 	object = *object_ptr;
 
-	if (object->type != IS_OBJECT) {
+	if (Z_TYPE_P(object) != IS_OBJECT) {
 		zend_error(E_WARNING, "Attempt to assign property of non-object");
 		FREE_OP2();
 		FREE_OP(free_op_data1);
@@ -345,7 +345,7 @@ ZEND_VM_HELPER_EX(zend_binary_assign_op_obj_helper, VAR|UNUSED|CV, CONST|TMP|VAR
 					break;
 			}
 			if (z) {
-				if (z->type == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
+				if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
 					zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
 
 					if (z->refcount == 0) {
@@ -412,7 +412,7 @@ ZEND_VM_HELPER_EX(zend_binary_assign_op_helper, VAR|UNUSED|CV, CONST|TMP|VAR|UNU
 					(*object_ptr)->refcount++;  /* undo the effect of get_obj_zval_ptr_ptr() */
 				}
 
-				if ((*object_ptr)->type == IS_OBJECT) {
+				if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
 					ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_obj_helper, binary_op, binary_op);
 				} else {
 					zend_op *op_data = opline+1;
@@ -548,7 +548,7 @@ ZEND_VM_HELPER_EX(zend_pre_incdec_property_helper, VAR|UNUSED|CV, CONST|TMP|VAR|
 	make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
 	object = *object_ptr;
 
-	if (object->type != IS_OBJECT) {
+	if (Z_TYPE_P(object) != IS_OBJECT) {
 		zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
 		FREE_OP2();
 		if (!RETURN_VALUE_UNUSED(&opline->result)) {
@@ -583,7 +583,7 @@ ZEND_VM_HELPER_EX(zend_pre_incdec_property_helper, VAR|UNUSED|CV, CONST|TMP|VAR|
 		if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
 			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_RW TSRMLS_CC);
 
-			if (z->type == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
+			if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
 				zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
 
 				if (z->refcount == 0) {
@@ -640,7 +640,7 @@ ZEND_VM_HELPER_EX(zend_post_incdec_property_helper, VAR|UNUSED|CV, CONST|TMP|VAR
 	make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
 	object = *object_ptr;
 
-	if (object->type != IS_OBJECT) {
+	if (Z_TYPE_P(object) != IS_OBJECT) {
 		zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
 		FREE_OP2();
 		*retval = *EG(uninitialized_zval_ptr);
@@ -673,7 +673,7 @@ ZEND_VM_HELPER_EX(zend_post_incdec_property_helper, VAR|UNUSED|CV, CONST|TMP|VAR
 			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_RW TSRMLS_CC);
 			zval *z_copy;
 
-			if (z->type == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
+			if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
 				zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
 
 				if (z->refcount == 0) {
@@ -884,7 +884,6 @@ ZEND_VM_HANDLER(40, ZEND_ECHO, CONST|TMP|VAR|CV, ANY)
 {
 	zend_op *opline = EX(opline);
 	zend_free_op free_op1;
-	zval z_copy;
 	zval *z = GET_OP1_ZVAL_PTR(BP_VAR_R);
 	UErrorCode status = U_ZERO_ERROR;
 
@@ -897,8 +896,8 @@ ZEND_VM_HANDLER(40, ZEND_ECHO, CONST|TMP|VAR|CV, ANY)
 		if (zend_set_converter_encoding(&script_enc_conv, EX(op_array)->script_encoding) == FAILURE) {
 			zend_error(E_ERROR, "Unsupported encoding [%d]", EX(op_array)->script_encoding);
 		}
-		zend_convert_encodings(ZEND_U_CONVERTER(UG(output_encoding_conv)), script_enc_conv, &z_conv.value.str.val, &z_conv.value.str.len, z->value.str.val, z->value.str.len, &status);
-		z_conv.type = IS_STRING;
+		zend_convert_encodings(ZEND_U_CONVERTER(UG(output_encoding_conv)), script_enc_conv, &Z_STRVAL(z_conv), &Z_STRLEN(z_conv), Z_STRVAL_P(z), Z_STRLEN_P(z), &status);
+		Z_TYPE(z_conv) = IS_STRING;
 		if (U_SUCCESS(status)) {
 			zend_print_variable(&z_conv);
 		} else {
@@ -918,8 +917,8 @@ ZEND_VM_HANDLER(41, ZEND_PRINT, CONST|TMP|VAR|CV, ANY)
 {
 	zend_op *opline = EX(opline);
 
-	EX_T(opline->result.u.var).tmp_var.value.lval = 1;
-	EX_T(opline->result.u.var).tmp_var.type = IS_LONG;
+	Z_LVAL(EX_T(opline->result.u.var).tmp_var) = 1;
+	Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_LONG;
 
 	ZEND_VM_DISPATCH_TO_HANDLER(ZEND_ECHO);
 }
@@ -933,7 +932,7 @@ ZEND_VM_HELPER_EX(zend_fetch_var_address_helper, CONST|TMP|VAR|CV, ANY, int type
 	zval tmp_varname;
 	HashTable *target_symbol_table;
 
- 	if (varname->type != IS_STRING && varname->type != IS_UNICODE) {
+ 	if (Z_TYPE_P(varname) != IS_STRING && Z_TYPE_P(varname) != IS_UNICODE) {
 		tmp_varname = *varname;
 		zval_copy_ctor(&tmp_varname);
 		convert_to_text(&tmp_varname);
@@ -1176,7 +1175,7 @@ ZEND_VM_HELPER_EX(zend_fetch_property_address_read_helper, VAR|UNUSED|CV, CONST|
 	}
 
 
-	if (container->type != IS_OBJECT || !Z_OBJ_HT_P(container)->read_property) {
+	if (Z_TYPE_P(container) != IS_OBJECT || !Z_OBJ_HT_P(container)->read_property) {
 		zend_error(E_NOTICE, "Trying to get property of non-object");
 		*retval = EG(uninitialized_zval_ptr);
 		SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
@@ -1327,7 +1326,7 @@ ZEND_VM_HANDLER(98, ZEND_FETCH_DIM_TMP_VAR, TMP, CONST)
 	zend_free_op free_op1;
 	zval *container = GET_OP1_ZVAL_PTR(BP_VAR_R);
 
-	if (container->type != IS_ARRAY) {
+	if (Z_TYPE_P(container) != IS_ARRAY) {
 		if (!RETURN_VALUE_UNUSED(&opline->result)) {
 			EX_T(opline->result.u.var).var.ptr_ptr = &EG(uninitialized_zval_ptr);
 			PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
@@ -1336,7 +1335,7 @@ ZEND_VM_HANDLER(98, ZEND_FETCH_DIM_TMP_VAR, TMP, CONST)
 		zend_free_op free_op2;
 		zval *dim = GET_OP2_ZVAL_PTR(BP_VAR_R);
 
-		EX_T(opline->result.u.var).var.ptr_ptr = zend_fetch_dimension_address_inner(container->value.ht, dim, BP_VAR_R TSRMLS_CC);
+		EX_T(opline->result.u.var).var.ptr_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, BP_VAR_R TSRMLS_CC);
 		SELECTIVE_PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &opline->result);
 		FREE_OP2();
 	}
@@ -1372,7 +1371,7 @@ ZEND_VM_HANDLER(147, ZEND_ASSIGN_DIM, VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV)
 		object_ptr = NULL;
 	}
 
-	if (object_ptr && (*object_ptr)->type == IS_OBJECT) {
+	if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
 		zend_assign_to_object(&opline->result, object_ptr, &opline->op2, &op_data->op1, EX(Ts), ZEND_ASSIGN_DIM TSRMLS_CC);
 	} else {
 		zend_free_op free_op2, free_op_data1;
@@ -1512,8 +1511,8 @@ ZEND_VM_HANDLER(46, ZEND_JMPZ_EX, CONST|TMP|VAR|CV, ANY)
 	int retval = i_zend_is_true(GET_OP1_ZVAL_PTR(BP_VAR_R));
 
 	FREE_OP1();
-	EX_T(opline->result.u.var).tmp_var.value.lval = retval;
-	EX_T(opline->result.u.var).tmp_var.type = IS_BOOL;
+	Z_LVAL(EX_T(opline->result.u.var).tmp_var) = retval;
+	Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
 	if (!retval) {
 #if DEBUG_ZEND>=2
 		printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
@@ -1530,8 +1529,8 @@ ZEND_VM_HANDLER(47, ZEND_JMPNZ_EX, CONST|TMP|VAR|CV, ANY)
 	int retval = i_zend_is_true(GET_OP1_ZVAL_PTR(BP_VAR_R));
 
 	FREE_OP1();
-	EX_T(opline->result.u.var).tmp_var.value.lval = retval;
-	EX_T(opline->result.u.var).tmp_var.type = IS_BOOL;
+	Z_LVAL(EX_T(opline->result.u.var).tmp_var) = retval;
+	Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
 	if (retval) {
 #if DEBUG_ZEND>=2
 		printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
@@ -1552,15 +1551,15 @@ ZEND_VM_HANDLER(53, ZEND_INIT_STRING, ANY, ANY)
 	zval *tmp = &EX_T(EX(opline)->result.u.var).tmp_var;
 
 	if (EX(opline)->extended_value == IS_UNICODE) {
-		tmp->value.ustr.val = eumalloc(1);
-		tmp->value.ustr.val[0] = 0;
-		tmp->value.ustr.len = 0;
-		tmp->type = IS_UNICODE;
+		Z_USTRVAL_P(tmp) = eumalloc(1);
+		Z_USTRVAL_P(tmp)[0] = 0;
+		Z_USTRLEN_P(tmp) = 0;
+		Z_TYPE_P(tmp) = IS_UNICODE;
 	} else {
-		tmp->value.str.val = emalloc(1);
-		tmp->value.str.val[0] = 0;
-		tmp->value.str.len = 0;
-		tmp->type = EX(opline)->extended_value;
+		Z_STRVAL_P(tmp) = emalloc(1);
+		Z_STRVAL_P(tmp)[0] = 0;
+		Z_STRLEN_P(tmp) = 0;
+		Z_TYPE_P(tmp) = EX(opline)->extended_value;
 	}
 	tmp->refcount = 1;
 	tmp->is_ref = 0;
@@ -1637,7 +1636,7 @@ ZEND_VM_HANDLER(109, ZEND_FETCH_CLASS, ANY, CONST|TMP|VAR|UNUSED|CV)
 
 	class_name = GET_OP2_ZVAL_PTR(BP_VAR_R);
 
-	switch (class_name->type) {
+	switch (Z_TYPE_P(class_name)) {
 		case IS_OBJECT:
 			EX_T(opline->result.u.var).class_entry = Z_OBJCE_P(class_name);
 			break;
@@ -1677,7 +1676,7 @@ ZEND_VM_HANDLER(112, ZEND_INIT_METHOD_CALL, TMP|VAR|UNUSED|CV, CONST|TMP|VAR|CV)
 
 	EX(object) = GET_OP1_OBJ_ZVAL_PTR(BP_VAR_R);
 
-	if (EX(object) && EX(object)->type == IS_OBJECT) {
+	if (EX(object) && Z_TYPE_P(EX(object)) == IS_OBJECT) {
 		if (Z_OBJ_HT_P(EX(object))->get_method == NULL) {
 			zend_error_noreturn(E_ERROR, "Object does not support method calls");
 		}
@@ -2072,7 +2071,7 @@ ZEND_VM_C_LABEL(return_by_value):
 				zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %v",  Z_OBJCE_P(retval_ptr)->name);
 			}
 			zend_error(E_STRICT, "Implicit cloning object of class '%v' because of 'zend.ze1_compatibility_mode'", Z_OBJCE_P(retval_ptr)->name);
-			ret->value.obj = Z_OBJ_HT_P(retval_ptr)->clone_obj(retval_ptr TSRMLS_CC);
+			Z_OBJVAL_P(ret) = Z_OBJ_HT_P(retval_ptr)->clone_obj(retval_ptr TSRMLS_CC);
 			*EG(return_value_ptr_ptr) = ret;
 			if (!dup) {
 				efree(class_name);
@@ -2111,7 +2110,7 @@ ZEND_VM_HANDLER(108, ZEND_THROW, CONST|TMP|VAR|CV, ANY)
 
 	value = GET_OP1_ZVAL_PTR(BP_VAR_R);
 
-	if (value->type != IS_OBJECT) {
+	if (Z_TYPE_P(value) != IS_OBJECT) {
 		zend_error_noreturn(E_ERROR, "Can only throw objects");
 	}
 	/* Not sure if a complete copy is what we want here */
@@ -2280,7 +2279,7 @@ ZEND_VM_HANDLER(63, ZEND_RECV, ANY, ANY)
 {
 	zend_op *opline = EX(opline);
 	zval **param;
-	zend_uint arg_num = opline->op1.u.constant.value.lval;
+	zend_uint arg_num = Z_LVAL(opline->op1.u.constant);
 
 	if (zend_ptr_stack_get_arg(arg_num, (void **) &param TSRMLS_CC)==FAILURE) {
 		char *space;
@@ -2289,9 +2288,9 @@ ZEND_VM_HANDLER(63, ZEND_RECV, ANY, ANY)
 
 		zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, NULL TSRMLS_CC);
 		if(ptr && ptr->op_array) {
-			zend_error(E_WARNING, "Missing argument %ld for %v%s%v(), called in %s on line %d and defined", opline->op1.u.constant.value.lval, class_name, space, get_active_function_name(TSRMLS_C), ptr->op_array->filename, ptr->opline->lineno);
+			zend_error(E_WARNING, "Missing argument %ld for %v%s%v(), called in %s on line %d and defined", Z_LVAL(opline->op1.u.constant), class_name, space, get_active_function_name(TSRMLS_C), ptr->op_array->filename, ptr->opline->lineno);
 		} else {
-			zend_error(E_WARNING, "Missing argument %ld for %v%s%v()", opline->op1.u.constant.value.lval, class_name, space, get_active_function_name(TSRMLS_C));
+			zend_error(E_WARNING, "Missing argument %ld for %v%s%v()", Z_LVAL(opline->op1.u.constant), class_name, space, get_active_function_name(TSRMLS_C));
 		}
 		if (opline->result.op_type == IS_VAR) {
 			PZVAL_UNLOCK_FREE(*EX_T(opline->result.u.var).var.ptr_ptr);
@@ -2316,16 +2315,16 @@ ZEND_VM_HANDLER(64, ZEND_RECV_INIT, ANY, CONST)
 {
 	zend_op *opline = EX(opline);
 	zval **param, *assignment_value;
-	zend_uint arg_num = opline->op1.u.constant.value.lval;
+	zend_uint arg_num = Z_LVAL(opline->op1.u.constant);
 	zend_free_op free_res;
 
 	if (zend_ptr_stack_get_arg(arg_num, (void **) &param TSRMLS_CC)==FAILURE) {
-		if (opline->op2.u.constant.type == IS_CONSTANT || opline->op2.u.constant.type==IS_CONSTANT_ARRAY) {
+		if (Z_TYPE(opline->op2.u.constant) == IS_CONSTANT || Z_TYPE(opline->op2.u.constant)==IS_CONSTANT_ARRAY) {
 			zval *default_value;
 
 			ALLOC_ZVAL(default_value);
 			*default_value = opline->op2.u.constant;
-			if (opline->op2.u.constant.type==IS_CONSTANT_ARRAY) {
+			if (Z_TYPE(opline->op2.u.constant)==IS_CONSTANT_ARRAY) {
 				zval_copy_ctor(default_value);
 			}
 			default_value->refcount=1;
@@ -2361,8 +2360,8 @@ ZEND_VM_HANDLER(52, ZEND_BOOL, CONST|TMP|VAR|CV, ANY)
 	zend_free_op free_op1;
 
 	/* PHP 3.0 returned "" for false and 1 for true, here we use 0 and 1 for now */
-	EX_T(opline->result.u.var).tmp_var.value.lval = i_zend_is_true(GET_OP1_ZVAL_PTR(BP_VAR_R));
-	EX_T(opline->result.u.var).tmp_var.type = IS_BOOL;
+	Z_LVAL(EX_T(opline->result.u.var).tmp_var) = i_zend_is_true(GET_OP1_ZVAL_PTR(BP_VAR_R));
+	Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
 	FREE_OP1();
 
 	ZEND_VM_NEXT_OPCODE();
@@ -2502,24 +2501,24 @@ ZEND_VM_HANDLER(110, ZEND_CLONE, CONST|TMP|VAR|UNUSED|CV, ANY)
 			/* Ensure that if we're calling a private function, we're allowed to do so.
 			 */
 			if (ce != EG(scope)) {
-				zend_error_noreturn(E_ERROR, "Call to private %v::__clone() from context '%v'", ce->name, EG(scope) ? EG(scope)->name : EMPTY_STR);
+				zend_error_noreturn(E_ERROR, "Call to private %v::__clone() from context '%v'", ce->name, EG(scope) ? EG(scope)->name : (char*)EMPTY_STR);
 			}
 		} else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) {
 			/* Ensure that if we're calling a protected function, we're allowed to do so.
 			 */
 			if (!zend_check_protected(clone->common.scope, EG(scope))) {
-				zend_error_noreturn(E_ERROR, "Call to protected %v::__clone() from context '%v'", ce->name, EG(scope) ? EG(scope)->name : EMPTY_STR);
+				zend_error_noreturn(E_ERROR, "Call to protected %v::__clone() from context '%v'", ce->name, EG(scope) ? EG(scope)->name : (char*)EMPTY_STR);
 			}
 		}
 	}
 
 	EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
 	ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
-	EX_T(opline->result.u.var).var.ptr->value.obj = clone_call(obj TSRMLS_CC);
+	Z_OBJVAL_P(EX_T(opline->result.u.var).var.ptr) = clone_call(obj TSRMLS_CC);
 	if (EG(exception)) {
 		FREE_ZVAL(EX_T(opline->result.u.var).var.ptr);
 	} else {
-		EX_T(opline->result.u.var).var.ptr->type = IS_OBJECT;
+		Z_TYPE_P(EX_T(opline->result.u.var).var.ptr) = IS_OBJECT;
 		EX_T(opline->result.u.var).var.ptr->refcount=1;
 		EX_T(opline->result.u.var).var.ptr->is_ref=1;
 	}
@@ -2537,7 +2536,7 @@ ZEND_VM_HANDLER(99, ZEND_FETCH_CONSTANT, CONST|UNUSED, CONST)
 /* This seems to be a reminant of namespaces
 		if (EG(scope)) {
 			ce = EG(scope);
-			if (zend_hash_find(&ce->constants_table, opline->op2.u.constant.value.str.val, opline->op2.u.constant.value.str.len+1, (void **) &value) == SUCCESS) {
+			if (zend_hash_find(&ce->constants_table, Z_STRVAL(opline->op2.u.constant), Z_STRLEN(opline->op2.u.constant)+1, (void **) &value) == SUCCESS) {
 				zval_update_constant(value, (void *) 1 TSRMLS_CC);
 				EX_T(opline->result.u.var).tmp_var = **value;
 				zval_copy_ctor(&EX_T(opline->result.u.var).tmp_var);
@@ -2614,20 +2613,20 @@ ZEND_VM_HANDLER(72, ZEND_ADD_ARRAY_ELEMENT, CONST|TMP|VAR|UNUSED|CV, CONST|TMP|V
 		}
 	}
 	if (offset) {
-		switch (offset->type) {
+		switch (Z_TYPE_P(offset)) {
 			case IS_DOUBLE:
-				zend_hash_index_update(array_ptr->value.ht, (long) offset->value.dval, &expr_ptr, sizeof(zval *), NULL);
+				zend_hash_index_update(Z_ARRVAL_P(array_ptr), (long) Z_DVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
 				break;
 			case IS_LONG:
 			case IS_BOOL:
-				zend_hash_index_update(array_ptr->value.ht, offset->value.lval, &expr_ptr, sizeof(zval *), NULL);
+				zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
 				break;
 			case IS_STRING:
 			case IS_UNICODE:
-				zend_u_symtable_update(array_ptr->value.ht, Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
+				zend_u_symtable_update(Z_ARRVAL_P(array_ptr), Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
 				break;
 			case IS_NULL:
-				zend_hash_update(array_ptr->value.ht, "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
+				zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
 				break;
 			default:
 				zend_error(E_WARNING, "Illegal offset type");
@@ -2637,7 +2636,7 @@ ZEND_VM_HANDLER(72, ZEND_ADD_ARRAY_ELEMENT, CONST|TMP|VAR|UNUSED|CV, CONST|TMP|V
 		}
 		FREE_OP2();
 	} else {
-		zend_hash_next_index_insert(array_ptr->value.ht, &expr_ptr, sizeof(zval *), NULL);
+		zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
 	}
 	if (opline->extended_value) {
 		FREE_OP1_VAR_PTR();
@@ -2720,14 +2719,14 @@ ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMP|VAR|CV, ANY)
 	zval tmp_inc_filename;
 	zend_bool failure_retval=0;
 
-	if (UG(unicode) && opline->op2.u.constant.value.lval == ZEND_EVAL) {
-		if (inc_filename->type != IS_UNICODE) {
+	if (UG(unicode) && Z_LVAL(opline->op2.u.constant) == ZEND_EVAL) {
+		if (Z_TYPE_P(inc_filename) != IS_UNICODE) {
 			tmp_inc_filename = *inc_filename;
 			zval_copy_ctor(&tmp_inc_filename);
 			convert_to_unicode(&tmp_inc_filename);
 			inc_filename = &tmp_inc_filename;
 		}
-	} else if (inc_filename->type!=IS_STRING) {
+	} else if (Z_TYPE_P(inc_filename)!=IS_STRING) {
 		tmp_inc_filename = *inc_filename;
 		zval_copy_ctor(&tmp_inc_filename);
 		convert_to_string(&tmp_inc_filename);
@@ -2736,30 +2735,30 @@ ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMP|VAR|CV, ANY)
 
 	return_value_used = RETURN_VALUE_USED(opline);
 
-	switch (opline->op2.u.constant.value.lval) {
+	switch (Z_LVAL(opline->op2.u.constant)) {
 		case ZEND_INCLUDE_ONCE:
 		case ZEND_REQUIRE_ONCE: {
 				int dummy = 1;
 				zend_file_handle file_handle;
 
-				if (SUCCESS == zend_stream_open(inc_filename->value.str.val, &file_handle TSRMLS_CC)) {
+				if (SUCCESS == zend_stream_open(Z_STRVAL_P(inc_filename), &file_handle TSRMLS_CC)) {
 
 					if (!file_handle.opened_path) {
-						file_handle.opened_path = estrndup(inc_filename->value.str.val, inc_filename->value.str.len);
+						file_handle.opened_path = estrndup(Z_STRVAL_P(inc_filename), Z_STRLEN_P(inc_filename));
 					}
 
 					if (zend_hash_add(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)+1, (void *)&dummy, sizeof(int), NULL)==SUCCESS) {
-						new_op_array = zend_compile_file(&file_handle, (opline->op2.u.constant.value.lval==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE) TSRMLS_CC);
+						new_op_array = zend_compile_file(&file_handle, (Z_LVAL(opline->op2.u.constant)==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE) TSRMLS_CC);
 						zend_destroy_file_handle(&file_handle TSRMLS_CC);
 					} else {
 						zend_file_handle_dtor(&file_handle);
 						failure_retval=1;
 					}
 				} else {
-					if (opline->op2.u.constant.value.lval==ZEND_INCLUDE_ONCE) {
-						zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, inc_filename->value.str.val);
+					if (Z_LVAL(opline->op2.u.constant)==ZEND_INCLUDE_ONCE) {
+						zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename));
 					} else {
-						zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, inc_filename->value.str.val);
+						zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename));
 					}
 				}
 				break;
@@ -2767,7 +2766,7 @@ ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMP|VAR|CV, ANY)
 			break;
 		case ZEND_INCLUDE:
 		case ZEND_REQUIRE:
-			new_op_array = compile_filename(opline->op2.u.constant.value.lval, inc_filename TSRMLS_CC);
+			new_op_array = compile_filename(Z_LVAL(opline->op2.u.constant), inc_filename TSRMLS_CC);
 			break;
 		case ZEND_EVAL: {
 				char *eval_desc = zend_make_compiled_string_description("eval()'d code" TSRMLS_CC);
@@ -2809,8 +2808,8 @@ ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMP|VAR|CV, ANY)
 			if (!EX_T(opline->result.u.var).var.ptr) { /* there was no return statement */
 				ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
 				INIT_PZVAL(EX_T(opline->result.u.var).var.ptr);
-				EX_T(opline->result.u.var).var.ptr->value.lval = 1;
-				EX_T(opline->result.u.var).var.ptr->type = IS_BOOL;
+				Z_LVAL_P(EX_T(opline->result.u.var).var.ptr) = 1;
+				Z_TYPE_P(EX_T(opline->result.u.var).var.ptr) = IS_BOOL;
 			}
 		}
 
@@ -2826,8 +2825,8 @@ ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMP|VAR|CV, ANY)
 		if (return_value_used) {
 			ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
 			INIT_ZVAL(*EX_T(opline->result.u.var).var.ptr);
-			EX_T(opline->result.u.var).var.ptr->value.lval = failure_retval;
-			EX_T(opline->result.u.var).var.ptr->type = IS_BOOL;
+			Z_LVAL_P(EX_T(opline->result.u.var).var.ptr) = failure_retval;
+			Z_TYPE_P(EX_T(opline->result.u.var).var.ptr) = IS_BOOL;
 		}
 	}
 	FREE_OP1();
@@ -2844,7 +2843,7 @@ ZEND_VM_HANDLER(74, ZEND_UNSET_VAR, CONST|TMP|VAR|CV, ANY)
 
 	varname = GET_OP1_ZVAL_PTR(BP_VAR_R);
 
-	if (varname->type != IS_STRING && varname->type != IS_UNICODE) {
+	if (Z_TYPE_P(varname) != IS_STRING && Z_TYPE_P(varname) != IS_UNICODE) {
 		tmp = *varname;
 		zval_copy_ctor(&tmp);
 		convert_to_text(&tmp);
@@ -2900,15 +2899,15 @@ ZEND_VM_HANDLER(75, ZEND_UNSET_DIM, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
 			case IS_ARRAY: {
 				HashTable *ht = Z_ARRVAL_PP(container);
 
-				switch (offset->type) {
+				switch (Z_TYPE_P(offset)) {
 					case IS_DOUBLE:
 					case IS_RESOURCE:
 					case IS_BOOL:
 					case IS_LONG:
-						if (offset->type == IS_DOUBLE) {
-							index = (long) offset->value.dval;
+						if (Z_TYPE_P(offset) == IS_DOUBLE) {
+							index = (long) Z_DVAL_P(offset);
 						} else {
-							index = offset->value.lval;
+							index = Z_LVAL_P(offset);
 						}
 
 						zend_hash_index_del(ht, index);
@@ -2919,7 +2918,7 @@ ZEND_VM_HANDLER(75, ZEND_UNSET_DIM, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
 						int  offset_len  = Z_UNILEN_P(offset);
 						int free_offset = 0;
 
-						if (UG(unicode) && ht == &EG(symbol_table) && offset->type == IS_UNICODE) {
+						if (UG(unicode) && ht == &EG(symbol_table) && Z_TYPE_P(offset) == IS_UNICODE) {
 							/* Identifier normalization */
 							UChar *norm;
 							int32_t norm_len;
@@ -3282,18 +3281,18 @@ ZEND_VM_HANDLER(78, ZEND_FE_FETCH, VAR, ANY)
 
 		switch (key_type) {
 			case HASH_KEY_IS_STRING:
-				key->value.str.val = str_key;
-				key->value.str.len = str_key_len-1;
-				key->type = IS_STRING;
+				Z_STRVAL_P(key) = str_key;
+				Z_STRLEN_P(key) = str_key_len-1;
+				Z_TYPE_P(key) = IS_STRING;
 				break;
 			case HASH_KEY_IS_UNICODE:
-				key->value.ustr.val = (UChar*)str_key;
-				key->value.ustr.len = str_key_len-1;
-				key->type = IS_UNICODE;
+				Z_USTRVAL_P(key) = (UChar*)str_key;
+				Z_USTRLEN_P(key) = str_key_len-1;
+				Z_TYPE_P(key) = IS_UNICODE;
 				break;
 			case HASH_KEY_IS_LONG:
-				key->value.lval = int_key;
-				key->type = IS_LONG;
+				Z_LVAL_P(key) = int_key;
+				Z_TYPE_P(key) = IS_LONG;
 				break;
 			EMPTY_SWITCH_DEFAULT_CASE()
 		}
@@ -3312,7 +3311,7 @@ ZEND_VM_HANDLER(114, ZEND_ISSET_ISEMPTY_VAR, CONST|TMP|VAR|CV, ANY)
 	zend_bool isset = 1;
 	HashTable *target_symbol_table;
 
-	if (varname->type != IS_STRING && varname->type != IS_UNICODE) {
+	if (Z_TYPE_P(varname) != IS_STRING && Z_TYPE_P(varname) != IS_UNICODE) {
 		tmp = *varname;
 		zval_copy_ctor(&tmp);
 		convert_to_text(&tmp);
@@ -3331,21 +3330,21 @@ ZEND_VM_HANDLER(114, ZEND_ISSET_ISEMPTY_VAR, CONST|TMP|VAR|CV, ANY)
 		}
 	}
 
-	EX_T(opline->result.u.var).tmp_var.type = IS_BOOL;
+	Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
 
 	switch (opline->extended_value) {
 		case ZEND_ISSET:
 			if (isset && Z_TYPE_PP(value) == IS_NULL) {
-				EX_T(opline->result.u.var).tmp_var.value.lval = 0;
+				Z_LVAL(EX_T(opline->result.u.var).tmp_var) = 0;
 			} else {
-				EX_T(opline->result.u.var).tmp_var.value.lval = isset;
+				Z_LVAL(EX_T(opline->result.u.var).tmp_var) = isset;
 			}
 			break;
 		case ZEND_ISEMPTY:
 			if (!isset || !i_zend_is_true(*value)) {
-				EX_T(opline->result.u.var).tmp_var.value.lval = 1;
+				Z_LVAL(EX_T(opline->result.u.var).tmp_var) = 1;
 			} else {
-				EX_T(opline->result.u.var).tmp_var.value.lval = 0;
+				Z_LVAL(EX_T(opline->result.u.var).tmp_var) = 0;
 			}
 			break;
 	}
@@ -3371,21 +3370,21 @@ ZEND_VM_HELPER_EX(zend_isset_isempty_dim_prop_obj_handler, VAR|UNUSED|CV, CONST|
 		zend_free_op free_op2;
 		zval *offset = GET_OP2_ZVAL_PTR(BP_VAR_R);
 
-		if ((*container)->type == IS_ARRAY) {
+		if (Z_TYPE_PP(container) == IS_ARRAY) {
 			HashTable *ht;
 			int isset = 0;
 
-			ht = (*container)->value.ht;
+			ht = Z_ARRVAL_PP(container);
 
-			switch (offset->type) {
+			switch (Z_TYPE_P(offset)) {
 				case IS_DOUBLE:
 				case IS_RESOURCE:
 				case IS_BOOL:
 				case IS_LONG:
-					if (offset->type == IS_DOUBLE) {
-						index = (long) offset->value.dval;
+					if (Z_TYPE_P(offset) == IS_DOUBLE) {
+						index = (long) Z_DVAL_P(offset);
 					} else {
-						index = offset->value.lval;
+						index = Z_LVAL_P(offset);
 					}
 					if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
 						isset = 1;
@@ -3447,7 +3446,7 @@ ZEND_VM_HELPER_EX(zend_isset_isempty_dim_prop_obj_handler, VAR|UNUSED|CV, CONST|
 					break;
 			}
 			FREE_OP2();
-		} else if ((*container)->type == IS_OBJECT) {
+		} else if (Z_TYPE_PP(container) == IS_OBJECT) {
 			if (IS_OP2_TMP_FREE()) {
 				MAKE_REAL_ZVAL_PTR(offset);
 			}
@@ -3461,30 +3460,30 @@ ZEND_VM_HELPER_EX(zend_isset_isempty_dim_prop_obj_handler, VAR|UNUSED|CV, CONST|
 			} else {
 				FREE_OP2();
 			}
-		} else if (((*container)->type == IS_STRING ||
-		            (*container)->type == IS_UNICODE) && !prop_dim) { /* string offsets */
+		} else if ((Z_TYPE_PP(container) == IS_STRING ||
+		            Z_TYPE_PP(container) == IS_UNICODE) && !prop_dim) { /* string offsets */
 			zval tmp;
 
-			if (offset->type != IS_LONG) {
+			if (Z_TYPE_P(offset) != IS_LONG) {
 				tmp = *offset;
 				zval_copy_ctor(&tmp);
 				convert_to_long(&tmp);
 				offset = &tmp;
 			}
-			if (offset->type == IS_LONG) {
+			if (Z_TYPE_P(offset) == IS_LONG) {
 				switch (opline->extended_value) {
 					case ZEND_ISSET:
-						if (offset->value.lval >= 0 &&
-						    offset->value.lval < Z_UNILEN_PP(container)) {
+						if (Z_LVAL_P(offset) >= 0 &&
+						    Z_LVAL_P(offset) < Z_UNILEN_PP(container)) {
 							result = 1;
 						}
 						break;
 					case ZEND_ISEMPTY:
-						if (offset->value.lval >= 0 &&
-						    offset->value.lval < Z_UNILEN_PP(container) &&
+						if (Z_LVAL_P(offset) >= 0 &&
+						    Z_LVAL_P(offset) < Z_UNILEN_PP(container) &&
 						    ((Z_TYPE_PP(container) == IS_UNICODE)?
-						      (Z_USTRVAL_PP(container)[offset->value.lval] != 0):
-						      (Z_STRVAL_PP(container)[offset->value.lval] != '0'))) {
+						      (Z_USTRVAL_PP(container)[Z_LVAL_P(offset)] != 0):
+						      (Z_STRVAL_PP(container)[Z_LVAL_P(offset)] != '0'))) {
 							result = 1;
 						}
 						break;
@@ -3496,14 +3495,14 @@ ZEND_VM_HELPER_EX(zend_isset_isempty_dim_prop_obj_handler, VAR|UNUSED|CV, CONST|
 		}
 	}
 
-	EX_T(opline->result.u.var).tmp_var.type = IS_BOOL;
+	Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_BOOL;
 
 	switch (opline->extended_value) {
 		case ZEND_ISSET:
-			EX_T(opline->result.u.var).tmp_var.value.lval = result;
+			Z_LVAL(EX_T(opline->result.u.var).tmp_var) = result;
 			break;
 		case ZEND_ISEMPTY:
-			EX_T(opline->result.u.var).tmp_var.value.lval = !result;
+			Z_LVAL(EX_T(opline->result.u.var).tmp_var) = !result;
 			break;
 	}
 
@@ -3544,8 +3543,8 @@ ZEND_VM_HANDLER(57, ZEND_BEGIN_SILENCE, ANY, ANY)
 {
 	zend_op *opline = EX(opline);
 	
-	EX_T(opline->result.u.var).tmp_var.value.lval = EG(error_reporting);
-	EX_T(opline->result.u.var).tmp_var.type = IS_LONG;  /* shouldn't be necessary */
+	Z_LVAL(EX_T(opline->result.u.var).tmp_var) = EG(error_reporting);
+	Z_TYPE(EX_T(opline->result.u.var).tmp_var) = IS_LONG;  /* shouldn't be necessary */
 	if (EX(old_error_reporting) == NULL) {
 		EX(old_error_reporting) = &EX_T(opline->result.u.var).tmp_var;
 	}
@@ -3567,9 +3566,9 @@ ZEND_VM_HANDLER(58, ZEND_END_SILENCE, TMP, ANY)
 	zend_op *opline = EX(opline);
 	zval restored_error_reporting;
 
-	if (!EG(error_reporting) && EX_T(opline->op1.u.var).tmp_var.value.lval != 0) {
-		restored_error_reporting.type = IS_LONG;
-		restored_error_reporting.value.lval = EX_T(opline->op1.u.var).tmp_var.value.lval;
+	if (!EG(error_reporting) && Z_LVAL(EX_T(opline->op1.u.var).tmp_var) != 0) {
+		Z_TYPE(restored_error_reporting) = IS_LONG;
+		Z_LVAL(restored_error_reporting) = Z_LVAL(EX_T(opline->op1.u.var).tmp_var);
 		convert_to_string(&restored_error_reporting);
 		zend_alter_ini_entry("error_reporting", sizeof("error_reporting"), Z_STRVAL(restored_error_reporting), Z_STRLEN(restored_error_reporting), ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME);
 		zendi_zval_dtor(restored_error_reporting);
@@ -3644,10 +3643,10 @@ ZEND_VM_HANDLER(105, ZEND_TICKS, CONST, ANY)
 {
 	zend_op *opline = EX(opline);
 
-	if (++EG(ticks_count)>=opline->op1.u.constant.value.lval) {
+	if (++EG(ticks_count)>=Z_LVAL(opline->op1.u.constant)) {
 		EG(ticks_count)=0;
 		if (zend_ticks_function) {
-			zend_ticks_function(opline->op1.u.constant.value.lval);
+			zend_ticks_function(Z_LVAL(opline->op1.u.constant));
 		}
 	}
 	ZEND_VM_NEXT_OPCODE();
@@ -3737,9 +3736,9 @@ ZEND_VM_HANDLER(149, ZEND_HANDLE_EXCEPTION, ANY, ANY)
 	}
 
 	/* restore previous error_reporting value */
-	if (!EG(error_reporting) && EX(old_error_reporting) != NULL && EX(old_error_reporting)->value.lval != 0) {
-		restored_error_reporting.type = IS_LONG;
-		restored_error_reporting.value.lval = EX(old_error_reporting)->value.lval;
+	if (!EG(error_reporting) && EX(old_error_reporting) != NULL && Z_LVAL_P(EX(old_error_reporting)) != 0) {
+		Z_TYPE(restored_error_reporting) = IS_LONG;
+		Z_LVAL(restored_error_reporting) = Z_LVAL_P(EX(old_error_reporting));
 		convert_to_string(&restored_error_reporting);
 		zend_alter_ini_entry("error_reporting", sizeof("error_reporting"), Z_STRVAL(restored_error_reporting), Z_STRLEN(restored_error_reporting), ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME);
 		zendi_zval_dtor(restored_error_reporting);