Unicode support

1 files changed, 597 insertions, 94 deletions

diff --git a/Zend/zend_API.c b/Zend/zend_API.c
index 537cb9086e..852821c817 100644
--- a/Zend/zend_API.c
+++ b/Zend/zend_API.c
@@ -208,7 +208,7 @@ ZEND_API void zend_wrong_param_count(TSRMLS_D)
 	char *space;
 	char *class_name = get_active_class_name(&space TSRMLS_CC);
 	
-	zend_error(E_WARNING, "Wrong parameter count for %s%s%s()", class_name, space, get_active_function_name(TSRMLS_C));
+	zend_error(E_WARNING, "Wrong parameter count for %v%s%v()", class_name, space, get_active_function_name(TSRMLS_C));
 }
 
 
@@ -241,6 +241,12 @@ ZEND_API char *zend_zval_type_name(zval *arg)
 		case IS_RESOURCE:
 			return "resource";
 
+		case IS_UNICODE:
+			return "Unicode string";
+
+		case IS_BINARY:
+			return "binary data";
+
 		default:
 			return "unknown";
 	}
@@ -270,8 +276,22 @@ ZEND_API int zend_get_object_classname(zval *object, char **class_name, zend_uin
 	return 0;
 }
 
+#define RETURN_AS_STRING(arg, p, pl, type) \
+	*(char**)p = Z_STRVAL_PP(arg); \
+	*pl = Z_STRLEN_PP(arg); \
+	*type = IS_STRING; 
+
+#define RETURN_AS_BINARY(arg, p, pl, type) \
+	*(char**)p = Z_BINVAL_PP(arg); \
+	*pl = Z_BINLEN_PP(arg); \
+	*type = IS_BINARY; 
 
-static char *zend_parse_arg_impl(zval **arg, va_list *va, char **spec TSRMLS_DC)
+#define RETURN_AS_UNICODE(arg, p, pl, type) \
+	*(UChar**)p = Z_USTRVAL_PP(arg); \
+	*pl = Z_USTRLEN_PP(arg); \
+	*type = IS_UNICODE;
+
+static char *zend_parse_arg_impl(zval **arg, va_list *va, char **spec, char T_arg_type TSRMLS_DC)
 {
 	char *spec_walk = *spec;
 	char c = *spec_walk++;
@@ -304,6 +324,19 @@ static char *zend_parse_arg_impl(zval **arg, va_list *va, char **spec TSRMLS_DC)
 						}
 						break;
 
+					case IS_UNICODE:
+						{
+							double d;
+							int type;
+
+							if ((type = is_numeric_unicode(Z_USTRVAL_PP(arg), Z_USTRLEN_PP(arg), p, &d, 0)) == 0) {
+								return "long";
+							} else if (type == IS_DOUBLE) {
+								*p = (long) d;
+							}
+						}
+						break;
+
 					case IS_NULL:
 					case IS_LONG:
 					case IS_DOUBLE:
@@ -338,6 +371,19 @@ static char *zend_parse_arg_impl(zval **arg, va_list *va, char **spec TSRMLS_DC)
 						}
 						break;
 
+					case IS_UNICODE:
+						{
+							long l;
+							int type;
+
+							if ((type = is_numeric_unicode(Z_USTRVAL_PP(arg), Z_USTRLEN_PP(arg), &l, p, 0)) == 0) {
+								return "double";
+							} else if (type == IS_LONG) {
+								*p = (double) l;
+							}
+						}
+						break;
+
 					case IS_NULL:
 					case IS_LONG:
 					case IS_DOUBLE:
@@ -372,10 +418,17 @@ static char *zend_parse_arg_impl(zval **arg, va_list *va, char **spec TSRMLS_DC)
 					case IS_LONG:
 					case IS_DOUBLE:
 					case IS_BOOL:
+					case IS_UNICODE:
 						convert_to_string_ex(arg);
 						*p = Z_STRVAL_PP(arg);
 						*pl = Z_STRLEN_PP(arg);
 						break;
+
+					case IS_BINARY:
+						*p = Z_BINVAL_PP(arg);
+						*pl = Z_BINLEN_PP(arg);
+						break;
+
 					case IS_OBJECT: {
 						if (Z_OBJ_HANDLER_PP(arg, cast_object)) {
 							SEPARATE_ZVAL_IF_NOT_REF(arg);
@@ -383,6 +436,8 @@ static char *zend_parse_arg_impl(zval **arg, va_list *va, char **spec TSRMLS_DC)
 								*pl = Z_STRLEN_PP(arg);
 								*p = Z_STRVAL_PP(arg);
 								break;
+							} else {
+								return "string";
 							}
 						}
 					}
@@ -395,6 +450,175 @@ static char *zend_parse_arg_impl(zval **arg, va_list *va, char **spec TSRMLS_DC)
 			}
 			break;
 
+		case 'u':
+			{
+				UChar **p = va_arg(*va, UChar **);
+				int32_t *pl = va_arg(*va, int32_t *);
+				switch (Z_TYPE_PP(arg)) {
+					case IS_NULL:
+						if (return_null) {
+							*p = NULL;
+							*pl = 0;
+							break;
+						}
+						/* break omitted intentionally */
+
+					case IS_STRING:
+					case IS_LONG:
+					case IS_DOUBLE:
+					case IS_BOOL:
+					case IS_UNICODE:
+						convert_to_unicode_ex(arg);
+						*p = Z_USTRVAL_PP(arg);
+						*pl = Z_USTRLEN_PP(arg);
+						break;
+
+					case IS_OBJECT: {
+						if (Z_OBJ_HANDLER_PP(arg, cast_object)) {
+							SEPARATE_ZVAL_IF_NOT_REF(arg);
+							if (Z_OBJ_HANDLER_PP(arg, cast_object)(*arg, *arg, IS_UNICODE, 0 TSRMLS_CC) == SUCCESS) {
+								*pl = Z_USTRLEN_PP(arg);
+								*p = Z_USTRVAL_PP(arg);
+								break;
+							} else {
+								return "string";
+							}
+						}
+					}
+						
+					case IS_ARRAY:
+					case IS_RESOURCE:
+					default:
+						return "string";
+				}
+			}
+			break;
+
+		case 'T':
+			if (T_arg_type != -1)
+			{
+				void **p = va_arg(*va, void **);
+				int32_t *pl = va_arg(*va, int32_t *);
+				zend_uchar *type = va_arg(*va, zend_uchar *);
+				switch (Z_TYPE_PP(arg)) {
+					case IS_NULL:
+						if (return_null) {
+							*p = NULL;
+							*pl = 0;
+							*type = T_arg_type;
+							break;
+						}
+						/* break omitted intentionally */
+
+					case IS_LONG:
+					case IS_DOUBLE:
+					case IS_BOOL:
+					case IS_STRING:
+					case IS_UNICODE:
+					case IS_BINARY:
+						if (T_arg_type == IS_UNICODE) {
+							convert_to_unicode_ex(arg);
+							RETURN_AS_UNICODE(arg, p, pl, type);
+						} else if (T_arg_type == IS_STRING) {
+							convert_to_string_ex(arg);
+							RETURN_AS_STRING(arg, p, pl, type);
+						} else {
+							convert_to_binary_ex(arg);
+							RETURN_AS_BINARY(arg, p, pl, type);
+						}
+						break;
+
+					case IS_OBJECT: {
+						if (Z_OBJ_HANDLER_PP(arg, cast_object)) {
+							SEPARATE_ZVAL_IF_NOT_REF(arg);
+							if (Z_OBJ_HANDLER_PP(arg, cast_object)(*arg, *arg, T_arg_type, 0 TSRMLS_CC) == SUCCESS) {
+								*(char**)p = Z_UNIVAL_PP(arg);
+								*pl = Z_UNILEN_PP(arg);
+								*type = Z_TYPE_PP(arg);
+								RETURN_AS_UNICODE(arg, p, pl, type);
+								break;
+							}
+						}
+					}
+						
+					case IS_ARRAY:
+					case IS_RESOURCE:
+					default:
+						return "string (legacy, Unicode, or binary)";
+				}
+
+				break;
+			}
+			/* break omitted intentionally */
+
+		case 't':
+			{
+				void **p = va_arg(*va, void **);
+				int32_t *pl = va_arg(*va, int32_t *);
+				zend_uchar *type = va_arg(*va, zend_uchar *);
+				switch (Z_TYPE_PP(arg)) {
+					case IS_NULL:
+						if (return_null) {
+							*p = NULL;
+							*pl = 0;
+							if (UG(unicode)) {
+								*type = IS_UNICODE;
+							} else {
+								*type = IS_STRING;
+							}
+							break;
+						}
+						/* break omitted intentionally */
+
+					case IS_LONG:
+					case IS_DOUBLE:
+					case IS_BOOL:
+						if (UG(unicode)) {
+							convert_to_unicode_ex(arg);
+							RETURN_AS_UNICODE(arg, p, pl, type);
+						} else {
+							convert_to_string_ex(arg);
+							RETURN_AS_STRING(arg, p, pl, type);
+						}
+						break;
+
+					case IS_STRING:
+						RETURN_AS_STRING(arg, p, pl, type);
+						break;
+
+					case IS_BINARY:
+						RETURN_AS_BINARY(arg, p, pl, type);
+						break;
+
+					case IS_UNICODE:
+						RETURN_AS_UNICODE(arg, p, pl, type);
+						break;
+
+					case IS_OBJECT: {
+						if (Z_OBJ_HANDLER_PP(arg, cast_object)) {
+							SEPARATE_ZVAL_IF_NOT_REF(arg);
+							if (UG(unicode)) {
+								if (Z_OBJ_HANDLER_PP(arg, cast_object)(*arg, *arg, IS_UNICODE, 0 TSRMLS_CC) == SUCCESS) {
+									RETURN_AS_UNICODE(arg, p, pl, type);
+									break;
+								}
+							} else {
+								if (Z_OBJ_HANDLER_PP(arg, cast_object)(*arg, *arg, IS_STRING, 0 TSRMLS_CC) == SUCCESS) {
+									RETURN_AS_STRING(arg, p, pl, type);
+									break;
+								}
+							}
+						}
+					}
+						
+					case IS_ARRAY:
+					case IS_RESOURCE:
+					default:
+						return "string (legacy, Unicode, or binary)";
+				}
+			}
+			break;
+
 		case 'b':
 			{
 				zend_bool *p = va_arg(*va, zend_bool *);
@@ -506,17 +730,17 @@ static char *zend_parse_arg_impl(zval **arg, va_list *va, char **spec TSRMLS_DC)
 	return NULL;
 }
 
-static int zend_parse_arg(int arg_num, zval **arg, va_list *va, char **spec, int quiet TSRMLS_DC)
+static int zend_parse_arg(int arg_num, zval **arg, va_list *va, char **spec, int quiet, char T_arg_type TSRMLS_DC)
 {
 	char *expected_type = NULL;
 
-	expected_type = zend_parse_arg_impl(arg, va, spec TSRMLS_CC);
+	expected_type = zend_parse_arg_impl(arg, va, spec, T_arg_type TSRMLS_CC);
 	if (expected_type) {
 		if (!quiet) {
 			char *space;
 			char *class_name = get_active_class_name(&space TSRMLS_CC);
 
-			zend_error(E_WARNING, "%s%s%s() expects parameter %d to be %s, %s given",
+			zend_error(E_WARNING, "%v%s%v() expects parameter %d to be %s, %s given",
 					class_name, space, get_active_function_name(TSRMLS_C), arg_num, expected_type,
 					zend_zval_type_name(*arg));
 		}
@@ -536,15 +760,22 @@ static int zend_parse_va_args(int num_args, char *type_spec, va_list *va, int fl
 	void **p;
 	int arg_count;
 	int quiet = flags & ZEND_PARSE_PARAMS_QUIET;
+	zend_bool T_present = 0;
+	char T_arg_type = -1;
 
 	for (spec_walk = type_spec; *spec_walk; spec_walk++) {
 		c = *spec_walk;
 		switch (c) {
+			case 'T':
+				T_present++;
+				/* break omitted intentionally */
 			case 'l': case 'd':
 			case 's': case 'b':
 			case 'r': case 'a':
 			case 'o': case 'O':
 			case 'z': case 'Z':
+			case 't':
+			case 'u':
 				max_num_args++;
 				break;
 
@@ -560,8 +791,8 @@ static int zend_parse_va_args(int num_args, char *type_spec, va_list *va, int fl
 			default:
 				if (!quiet) {
 					zend_function *active_function = EG(function_state_ptr)->function;
-					char *class_name = active_function->common.scope ? active_function->common.scope->name : "";
-					zend_error(E_WARNING, "%s%s%s(): bad type specifier while parsing parameters", 
+					char *class_name = active_function->common.scope ? active_function->common.scope->name : EMPTY_STR;
+					zend_error(E_WARNING, "%v%s%v(): bad type specifier while parsing parameters", 
 							class_name,
 							class_name[0] ? "::" : "",
 							get_active_function_name(TSRMLS_C));
@@ -577,8 +808,8 @@ static int zend_parse_va_args(int num_args, char *type_spec, va_list *va, int fl
 	if (num_args < min_num_args || num_args > max_num_args) {
 		if (!quiet) {
 			zend_function *active_function = EG(function_state_ptr)->function;
-			char *class_name = active_function->common.scope ? active_function->common.scope->name : "";
-			zend_error(E_WARNING, "%s%s%s() expects %s %d parameter%s, %d given",
+			char *class_name = active_function->common.scope ? active_function->common.scope->name : EMPTY_STR;
+			zend_error(E_WARNING, "%v%s%v() expects %s %d parameter%s, %d given",
 					class_name,
 					class_name[0] ? "::" : "",
 					get_active_function_name(TSRMLS_C),
@@ -594,18 +825,48 @@ static int zend_parse_va_args(int num_args, char *type_spec, va_list *va, int fl
 	arg_count = (ulong) *p;
 
 	if (num_args > arg_count) {
-		zend_error(E_WARNING, "%s(): could not obtain parameters for parsing",
-				   get_active_function_name(TSRMLS_C));
+		zend_error(E_WARNING, "%v(): could not obtain parameters for parsing",
+			get_active_function_name(TSRMLS_C));
 		return FAILURE;
 	}
 
+	if (T_present > 1) {
+		/* determine 'T' target argument type */
+		for (spec_walk = type_spec, i = 0; *spec_walk && i < num_args; spec_walk++) {
+			switch (*spec_walk) {
+				case 'T':
+					arg = (zval **) p - (arg_count-i);
+					if (Z_TYPE_PP(arg) == IS_BINARY) {
+						/* we can always convert to binary */
+						T_arg_type = IS_BINARY;
+					} else if (Z_TYPE_PP(arg) == IS_UNICODE && (T_arg_type == -1 || T_arg_type == IS_STRING)) {
+						/* we can upgrade from strings to Unicode */
+						T_arg_type = IS_UNICODE;
+					} else if (Z_TYPE_PP(arg) == IS_STRING && T_arg_type == -1) {
+						T_arg_type = IS_STRING;
+					}
+					i++;
+					break;
+	
+				case '|': case '!':
+				case '/':
+					/* pass */
+					break;
+
+				default:
+					i++;
+					break;
+			}
+		}
+	}
+
 	i = 0;
 	while (num_args-- > 0) {
 		arg = (zval **) p - (arg_count-i);
 		if (*type_spec == '|') {
 			type_spec++;
 		}
-		if (zend_parse_arg(i+1, arg, va, &type_spec, quiet TSRMLS_CC) == FAILURE) {
+		if (zend_parse_arg(i+1, arg, va, &type_spec, quiet, T_arg_type TSRMLS_CC) == FAILURE) {
 			return FAILURE;
 		}
 		i++;
@@ -658,7 +919,7 @@ ZEND_API int zend_parse_method_parameters(int num_args TSRMLS_DC, zval *this_ptr
 		ce = va_arg(va, zend_class_entry *);
 		*object = this_ptr;
 		if (ce && !instanceof_function(Z_OBJCE_P(this_ptr), ce TSRMLS_CC)) {
-			zend_error(E_CORE_ERROR, "%s::%s() must be derived from %s::%s",
+			zend_error(E_CORE_ERROR, "%v::%v() must be derived from %v::%v",
 				ce->name, get_active_function_name(TSRMLS_C), Z_OBJCE_P(this_ptr)->name, get_active_function_name(TSRMLS_C));
 		}
 
@@ -691,7 +952,7 @@ ZEND_API int zend_parse_method_parameters_ex(int flags, int num_args TSRMLS_DC,
 		*object = this_ptr;
 		if (ce && !instanceof_function(Z_OBJCE_P(this_ptr), ce TSRMLS_CC)) {
 			if (!quiet) {
-				zend_error(E_CORE_ERROR, "%s::%s() must be derived from %s::%s",
+				zend_error(E_CORE_ERROR, "%v::%v() must be derived from %v::%v",
 					ce->name, get_active_function_name(TSRMLS_C), Z_OBJCE_P(this_ptr)->name, get_active_function_name(TSRMLS_C));
 			}
 			return FAILURE;
@@ -709,9 +970,11 @@ ZEND_API int zend_parse_method_parameters_ex(int flags, int num_args TSRMLS_DC,
 
 ZEND_API int _array_init(zval *arg ZEND_FILE_LINE_DC)
 {
+	TSRMLS_FETCH();
+
 	ALLOC_HASHTABLE_REL(arg->value.ht);
 
-	_zend_hash_init(arg->value.ht, 0, NULL, ZVAL_PTR_DTOR, 0 ZEND_FILE_LINE_RELAY_CC);
+	zend_u_hash_init(arg->value.ht, 0, NULL, ZVAL_PTR_DTOR, 0, UG(unicode));
 	arg->type = IS_ARRAY;
 	return SUCCESS;
 }
@@ -726,7 +989,7 @@ static int zend_merge_property(zval **value, int num_args, va_list args, zend_ha
 		zval member;
 		TSRMLS_FETCH();
 
-		ZVAL_STRINGL(&member, hash_key->arKey, hash_key->nKeyLength-1, 0);
+		ZVAL_STRINGL(&member, hash_key->u.string, hash_key->nKeyLength-1, 0);
 		obj_ht->write_property(obj, &member, *value TSRMLS_CC);
 	}
 	return ZEND_HASH_APPLY_KEEP;
@@ -777,7 +1040,7 @@ ZEND_API int _object_and_properties_init(zval *arg, zend_class_entry *class_type
 
 	if (class_type->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_IMPLICIT_ABSTRACT_CLASS|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS)) {
 		char *what = class_type->ce_flags & ZEND_ACC_INTERFACE ? "interface" : "abstract class";
-		zend_error(E_ERROR, "Cannot instantiate %s %s", what, class_type->name);
+		zend_error(E_ERROR, "Cannot instantiate %s %v", what, class_type->name);
 	}
 
 	zend_update_class_constants(class_type TSRMLS_CC);
@@ -789,7 +1052,7 @@ ZEND_API int _object_and_properties_init(zval *arg, zend_class_entry *class_type
 			object->properties = properties;
 		} else {
 			ALLOC_HASHTABLE_REL(object->properties);
-			zend_hash_init(object->properties, 0, NULL, ZVAL_PTR_DTOR, 0);
+			zend_u_hash_init(object->properties, 0, NULL, ZVAL_PTR_DTOR, 0, UG(unicode));
 			zend_hash_copy(object->properties, &class_type->default_properties, (copy_ctor_func_t) zval_add_ref, (void *) &tmp, sizeof(zval *));
 		}
 	} else {
@@ -889,11 +1152,36 @@ ZEND_API int add_assoc_stringl_ex(zval *arg, char *key, uint key_len, char *str,
 	return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL);
 }
 
+ZEND_API int add_assoc_unicode_ex(zval *arg, char *key, uint key_len, void *str, int duplicate)
+{
+	zval *tmp;
+	
+	MAKE_STD_ZVAL(tmp);
+	ZVAL_UNICODE(tmp, str, duplicate);
+
+	return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL);
+}
+
+
+ZEND_API int add_assoc_unicodel_ex(zval *arg, char *key, uint key_len, void *str, uint length, int duplicate)
+{
+	zval *tmp;
+	
+	MAKE_STD_ZVAL(tmp);
+	ZVAL_UNICODEL(tmp, str, length, duplicate);
+
+	return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL);
+}
+
 ZEND_API int add_assoc_zval_ex(zval *arg, char *key, uint key_len, zval *value)
 {
 	return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &value, sizeof(zval *), NULL);
 }
 
+ZEND_API int add_u_assoc_zval_ex(zval *arg, zend_uchar type, void *key, uint key_len, zval *value)
+{
+	return zend_u_symtable_update(Z_ARRVAL_P(arg), type, key, key_len, (void *) &value, sizeof(zval *), NULL);
+}
 
 ZEND_API int add_index_long(zval *arg, uint index, long n)
 {
@@ -971,6 +1259,50 @@ ZEND_API int add_index_stringl(zval *arg, uint index, char *str, uint length, in
 }
 
 
+ZEND_API int add_index_binary(zval *arg, uint index, char *str, int duplicate)
+{
+	zval *tmp;
+	
+	MAKE_STD_ZVAL(tmp);
+	ZVAL_BINARY(tmp, str, duplicate);
+
+	return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &tmp, sizeof(zval *), NULL);
+}
+
+
+ZEND_API int add_index_binaryl(zval *arg, uint index, char *str, uint length, int duplicate)
+{
+	zval *tmp;
+	
+	MAKE_STD_ZVAL(tmp);
+	ZVAL_BINARYL(tmp, str, length, duplicate);
+	
+	return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &tmp, sizeof(zval *), NULL);
+}
+
+
+ZEND_API int add_index_unicode(zval *arg, uint index, UChar *str, int duplicate)
+{
+	zval *tmp;
+	
+	MAKE_STD_ZVAL(tmp);
+	ZVAL_UNICODE(tmp, str, duplicate);
+
+	return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &tmp, sizeof(zval *), NULL);
+}
+
+
+ZEND_API int add_index_unicodel(zval *arg, uint index, UChar *str, uint length, int duplicate)
+{
+	zval *tmp;
+	
+	MAKE_STD_ZVAL(tmp);
+	ZVAL_UNICODEL(tmp, str, length, duplicate);
+	
+	return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &tmp, sizeof(zval *), NULL);
+}
+
+
 ZEND_API int add_index_zval(zval *arg, uint index, zval *value)
 {
 	return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &value, sizeof(zval *), NULL);
@@ -1054,6 +1386,51 @@ ZEND_API int add_next_index_stringl(zval *arg, char *str, uint length, int dupli
 }
 
 
+ZEND_API int add_next_index_binary(zval *arg, char *str, int duplicate)
+{
+	zval *tmp;
+	TSRMLS_FETCH();
+
+	MAKE_STD_ZVAL(tmp);
+	ZVAL_BINARY(tmp, str, duplicate);
+
+	return zend_hash_next_index_insert(Z_ARRVAL_P(arg), &tmp, sizeof(zval *), NULL);
+}
+
+
+ZEND_API int add_next_index_binaryl(zval *arg, char *str, uint length, int duplicate)
+{
+	zval *tmp;
+	TSRMLS_FETCH();
+
+	MAKE_STD_ZVAL(tmp);
+	ZVAL_BINARYL(tmp, str, length, duplicate);
+
+	return zend_hash_next_index_insert(Z_ARRVAL_P(arg), &tmp, sizeof(zval *), NULL);
+}
+
+ZEND_API int add_next_index_unicode(zval *arg, UChar *str, int duplicate)
+{
+	zval *tmp;
+
+	MAKE_STD_ZVAL(tmp);
+	ZVAL_UNICODE(tmp, str, duplicate);
+
+	return zend_hash_next_index_insert(Z_ARRVAL_P(arg), &tmp, sizeof(zval *), NULL);
+}
+
+
+ZEND_API int add_next_index_unicodel(zval *arg, UChar *str, uint length, int duplicate)
+{
+	zval *tmp;
+
+	MAKE_STD_ZVAL(tmp);
+	ZVAL_UNICODEL(tmp, str, length, duplicate);
+
+	return zend_hash_next_index_insert(Z_ARRVAL_P(arg), &tmp, sizeof(zval *), NULL);
+}
+
+
 ZEND_API int add_next_index_zval(zval *arg, zval *value)
 {
 	return zend_hash_next_index_insert(Z_ARRVAL_P(arg), &value, sizeof(zval *), NULL);
@@ -1125,6 +1502,50 @@ ZEND_API int add_get_index_stringl(zval *arg, uint index, char *str, uint length
 	return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &tmp, sizeof(zval *), dest);
 }
 
+ZEND_API int add_get_index_binary(zval *arg, uint index, char *str, void **dest, int duplicate)
+{
+	zval *tmp;
+	TSRMLS_FETCH();
+	
+	MAKE_STD_ZVAL(tmp);
+	ZVAL_BINARY(tmp, str, duplicate);
+	
+	return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &tmp, sizeof(zval *), dest);
+}
+
+
+ZEND_API int add_get_index_binaryl(zval *arg, uint index, char *str, uint length, void **dest, int duplicate)
+{
+	zval *tmp;
+	TSRMLS_FETCH();
+	
+	MAKE_STD_ZVAL(tmp);
+	ZVAL_BINARYL(tmp, str, length, duplicate);
+	
+	return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &tmp, sizeof(zval *), dest);
+}
+
+
+ZEND_API int add_get_index_unicode(zval *arg, uint index, UChar *str, void **dest, int duplicate)
+{
+	zval *tmp;
+	
+	MAKE_STD_ZVAL(tmp);
+	ZVAL_UNICODE(tmp, str, duplicate);
+	
+	return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &tmp, sizeof(zval *), dest);
+}
+
+
+ZEND_API int add_get_index_unicodel(zval *arg, uint index, UChar *str, uint length, void **dest, int duplicate)
+{
+	zval *tmp;
+	
+	MAKE_STD_ZVAL(tmp);
+	ZVAL_UNICODEL(tmp, str, length, duplicate);
+	
+	return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &tmp, sizeof(zval *), dest);
+}
 
 ZEND_API int add_property_long_ex(zval *arg, char *key, uint key_len, long n TSRMLS_DC)
 {
@@ -1391,30 +1812,43 @@ ZEND_API zend_module_entry* zend_register_internal_module(zend_module_entry *mod
 
 ZEND_API void zend_check_magic_method_implementation(zend_class_entry *ce, zend_function *fptr, int error_type TSRMLS_DC)
 {
-	char lcname[16];
+	unsigned int lcname_len;
+	char *lcname;
 	int name_len;
+	zend_uchar utype = UG(unicode)?IS_UNICODE:IS_STRING;
 
 	/* we don't care if the function name is longer, in fact lowercasing only 
 	 * the beginning of the name speeds up the check process */
-	name_len = strlen(fptr->common.function_name);
-	zend_str_tolower_copy(lcname, fptr->common.function_name, MIN(name_len, sizeof(lcname)-1));
-	lcname[sizeof(lcname)-1] = '\0'; /* zend_str_tolower_copy won't necessarily set the zero byte */
-
-	if (name_len == sizeof(ZEND_DESTRUCTOR_FUNC_NAME) - 1 && !memcmp(lcname, ZEND_DESTRUCTOR_FUNC_NAME, sizeof(ZEND_DESTRUCTOR_FUNC_NAME)) && fptr->common.num_args != 0) {
-		zend_error(error_type, "Destuctor %s::%s() cannot take arguments", ce->name, ZEND_DESTRUCTOR_FUNC_NAME);
-	} else if (name_len == sizeof(ZEND_CLONE_FUNC_NAME) - 1 && !memcmp(lcname, ZEND_CLONE_FUNC_NAME, sizeof(ZEND_CLONE_FUNC_NAME)) && fptr->common.num_args != 0) {
-		zend_error(error_type, "Method %s::%s() cannot accept any arguments", ce->name, ZEND_CLONE_FUNC_NAME);
-	} else if (name_len == sizeof(ZEND_GET_FUNC_NAME) - 1 && !memcmp(lcname, ZEND_GET_FUNC_NAME, sizeof(ZEND_GET_FUNC_NAME)) && fptr->common.num_args != 1) {
-		zend_error(error_type, "Method %s::%s() must take exactly 1 argument", ce->name, ZEND_GET_FUNC_NAME);
-	} else if (name_len == sizeof(ZEND_SET_FUNC_NAME) - 1 && !memcmp(lcname, ZEND_SET_FUNC_NAME, sizeof(ZEND_SET_FUNC_NAME)) && fptr->common.num_args != 2) {
-		zend_error(error_type, "Method %s::%s() must take exactly 2 arguments", ce->name, ZEND_SET_FUNC_NAME);
-	} else if (name_len == sizeof(ZEND_UNSET_FUNC_NAME) - 1 && !memcmp(lcname, ZEND_UNSET_FUNC_NAME, sizeof(ZEND_UNSET_FUNC_NAME)) && fptr->common.num_args != 1) {
-		zend_error(error_type, "Method %s::%s() must take exactly 1 argument", ce->name, ZEND_UNSET_FUNC_NAME);
-	} else if (name_len == sizeof(ZEND_ISSET_FUNC_NAME) - 1 && !memcmp(lcname, ZEND_ISSET_FUNC_NAME, sizeof(ZEND_ISSET_FUNC_NAME)) && fptr->common.num_args != 1) {
-		zend_error(error_type, "Method %s::%s() must take exactly 1 argument", ce->name, ZEND_ISSET_FUNC_NAME);
-	} else if (name_len == sizeof(ZEND_CALL_FUNC_NAME) - 1 && !memcmp(lcname, ZEND_CALL_FUNC_NAME, sizeof(ZEND_CALL_FUNC_NAME)) && fptr->common.num_args != 2) {
-		zend_error(error_type, "Method %s::%s() must take exactly 2 arguments", ce->name, ZEND_CALL_FUNC_NAME);
+	if (UG(unicode)) {
+		name_len = u_strlen((UChar*)fptr->common.function_name);
+	} else {
+		name_len = strlen(fptr->common.function_name);
+	}
+	lcname = zend_u_str_case_fold(utype, fptr->common.function_name, name_len, 0, &lcname_len);
+
+	if (lcname_len == sizeof(ZEND_DESTRUCTOR_FUNC_NAME) - 1 && 
+	    ZEND_U_EQUAL(utype, lcname, lcname_len, ZEND_DESTRUCTOR_FUNC_NAME, sizeof(ZEND_DESTRUCTOR_FUNC_NAME)-1) && fptr->common.num_args != 0) {
+		zend_error(error_type, "Destuctor %v::%s() cannot take arguments", ce->name, ZEND_DESTRUCTOR_FUNC_NAME);
+	} else if (lcname_len == sizeof(ZEND_CLONE_FUNC_NAME) - 1 &&
+	    ZEND_U_EQUAL(utype, lcname, lcname_len, ZEND_CLONE_FUNC_NAME, sizeof(ZEND_CLONE_FUNC_NAME)-1) && fptr->common.num_args != 0) {
+		zend_error(error_type, "Method %v::%s() cannot accept any arguments", ce->name, ZEND_CLONE_FUNC_NAME);
+	} else if (lcname_len == sizeof(ZEND_GET_FUNC_NAME) - 1 &&
+	    ZEND_U_EQUAL(utype, lcname, lcname_len, ZEND_GET_FUNC_NAME, sizeof(ZEND_GET_FUNC_NAME)-1) && fptr->common.num_args != 1) {
+		zend_error(error_type, "Method %v::%s() must take exactly 1 argument", ce->name, ZEND_GET_FUNC_NAME);
+	} else if (lcname_len == sizeof(ZEND_SET_FUNC_NAME) - 1 &&
+	    ZEND_U_EQUAL(utype, lcname, lcname_len, ZEND_SET_FUNC_NAME, sizeof(ZEND_SET_FUNC_NAME)-1) && fptr->common.num_args != 2) {
+		zend_error(error_type, "Method %v::%s() must take exactly 2 arguments", ce->name, ZEND_SET_FUNC_NAME);
+	} else if (lcname_len == sizeof(ZEND_UNSET_FUNC_NAME) - 1 &&
+	    ZEND_U_EQUAL(utype, lcname, lcname_len, ZEND_UNSET_FUNC_NAME, sizeof(ZEND_UNSET_FUNC_NAME)-1) && fptr->common.num_args != 1) {
+		zend_error(error_type, "Method %v::%s() must take exactly 1 arguments", ce->name, ZEND_UNSET_FUNC_NAME);
+	} else if (lcname_len == sizeof(ZEND_ISSET_FUNC_NAME) - 1 &&
+	    ZEND_U_EQUAL(utype, lcname, lcname_len, ZEND_ISSET_FUNC_NAME, sizeof(ZEND_ISSET_FUNC_NAME)-1) && fptr->common.num_args != 1) {
+		zend_error(error_type, "Method %v::%s() must take exactly 1 arguments", ce->name, ZEND_ISSET_FUNC_NAME);
+	} else if (lcname_len == sizeof(ZEND_CALL_FUNC_NAME) - 1 &&
+	    ZEND_U_EQUAL(utype, lcname, lcname_len, ZEND_CALL_FUNC_NAME, sizeof(ZEND_CALL_FUNC_NAME)-1) && fptr->common.num_args != 2) {
+		zend_error(error_type, "Method %v::%s() must take exactly 2 arguments", ce->name, ZEND_CALL_FUNC_NAME);
 	}
+	efree(lcname);
 }
 
 /* registers all functions in *library_functions in the function hash */
@@ -1444,7 +1878,7 @@ ZEND_API int zend_register_functions(zend_class_entry *scope, zend_function_entr
 	internal_function->type = ZEND_INTERNAL_FUNCTION;
 	
 	if (scope) {
-		class_name_len = strlen(scope->name);
+		class_name_len = scope->name_length;
 		lc_class_name = zend_str_tolower_dup(scope->name, class_name_len);
 	}
 
@@ -1473,7 +1907,7 @@ ZEND_API int zend_register_functions(zend_class_entry *scope, zend_function_entr
 		}
 		if (ptr->flags) {
 			if (!(ptr->flags & ZEND_ACC_PPP_MASK)) {
-				zend_error(error_type, "Invalid access level for %s%s%s() - access must be exactly one of public, protected or private", scope ? scope->name : "", scope ? "::" : "", ptr->fname);
+				zend_error(error_type, "Invalid access level for %s%s%s() - access must be exactly one of public, protected or private", scope ? scope->name : EMPTY_STR, scope ? "::" : "", ptr->fname);
 				internal_function->fn_flags = ZEND_ACC_PUBLIC;
 			} else {
 				internal_function->fn_flags = ptr->flags;
@@ -1498,7 +1932,7 @@ ZEND_API int zend_register_functions(zend_class_entry *scope, zend_function_entr
 				return FAILURE;
 			}
 			if (!internal_function->handler) {
-				zend_error(error_type, "Method %s%s%s() cannot be a NULL function", scope ? scope->name : "", scope ? "::" : "", ptr->fname);
+				zend_error(error_type, "Method %s%s%s() cannot be a NULL function", scope ? scope->name : EMPTY_STR, scope ? "::" : "", ptr->fname);
 				zend_unregister_functions(functions, count, target_function_table TSRMLS_CC);
 				return FAILURE;
 			}
@@ -1550,11 +1984,11 @@ ZEND_API int zend_register_functions(zend_class_entry *scope, zend_function_entr
 	}
 	if (unload) { /* before unloading, display all remaining bad function in the module */
 		if (scope) {
-			efree(lc_class_name);
+			free_alloca(lc_class_name);
 		}
 		while (ptr->fname) {
 			if (zend_hash_exists(target_function_table, ptr->fname, strlen(ptr->fname)+1)) {
-				zend_error(error_type, "Function registration failed - duplicate name - %s%s%s", scope ? scope->name : "", scope ? "::" : "", ptr->fname);
+				zend_error(error_type, "Function registration failed - duplicate name - %s%s%s", scope ? scope->name : EMPTY_STR, scope ? "::" : "", ptr->fname);
 			}
 			ptr++;
 		}
@@ -1694,9 +2128,9 @@ void module_destructor(zend_module_entry *module)
 
 #if HAVE_LIBDL || defined(HAVE_MACH_O_DYLD_H)
 #if !(defined(NETWARE) && defined(APACHE_1_BUILD))
-        if (module->handle) {
-            DL_UNLOAD(module->handle);
-        }
+	if (module->handle) {
+		DL_UNLOAD(module->handle);
+	}
 #endif
 #endif
 }
@@ -1832,21 +2266,21 @@ ZEND_API zend_class_entry *zend_register_internal_interface(zend_class_entry *or
 ZEND_API int zend_set_hash_symbol(zval *symbol, char *name, int name_length,
                                   zend_bool is_ref, int num_symbol_tables, ...)
 {
-    HashTable  *symbol_table;
-    va_list     symbol_table_list;
+	HashTable  *symbol_table;
+	va_list     symbol_table_list;
 
-    if (num_symbol_tables <= 0) return FAILURE;
+	if (num_symbol_tables <= 0) return FAILURE;
 
-    symbol->is_ref = is_ref;
+	symbol->is_ref = is_ref;
 
-    va_start(symbol_table_list, num_symbol_tables);
-    while (num_symbol_tables-- > 0) {
-        symbol_table = va_arg(symbol_table_list, HashTable *);
-        zend_hash_update(symbol_table, name, name_length + 1, &symbol, sizeof(zval *), NULL);
-        zval_add_ref(&symbol);
-    }
-    va_end(symbol_table_list);
-    return SUCCESS;
+	va_start(symbol_table_list, num_symbol_tables);
+	while (num_symbol_tables-- > 0) {
+		symbol_table = va_arg(symbol_table_list, HashTable *);
+		zend_hash_update(symbol_table, name, name_length + 1, &symbol, sizeof(zval *), NULL);
+		zval_add_ref(&symbol);
+	}
+	va_end(symbol_table_list);
+	return SUCCESS;
 }
 
 
@@ -1856,7 +2290,7 @@ ZEND_API int zend_set_hash_symbol(zval *symbol, char *name, int name_length,
 
 ZEND_API ZEND_FUNCTION(display_disabled_function)
 {
-	zend_error(E_WARNING, "%s() has been disabled for security reasons", get_active_function_name(TSRMLS_C));
+	zend_error(E_WARNING, "%v() has been disabled for security reasons", get_active_function_name(TSRMLS_C));
 }
 
 
@@ -1881,8 +2315,8 @@ static zend_object_value display_disabled_class(zend_class_entry *class_type TSR
 	zend_object *intern;
 	retval = zend_objects_new(&intern, class_type TSRMLS_CC);
 	ALLOC_HASHTABLE(intern->properties);
-	zend_hash_init(intern->properties, 0, NULL, ZVAL_PTR_DTOR, 0);
-	zend_error(E_WARNING, "%s() has been disabled for security reasons", class_type->name);
+	zend_u_hash_init(intern->properties, 0, NULL, ZVAL_PTR_DTOR, 0, UG(unicode));
+	zend_error(E_WARNING, "%v() has been disabled for security reasons", class_type->name);
 	return retval;
 }
 
@@ -1907,6 +2341,7 @@ ZEND_API int zend_disable_class(char *class_name, uint class_name_length TSRMLS_
 
 ZEND_API zend_bool zend_is_callable_ex(zval *callable, uint check_flags, char **callable_name, int *callable_name_len, zend_function **fptr_ptr, zval ***zobj_ptr_ptr TSRMLS_DC)
 {
+	unsigned int lcname_len;
 	char *lcname;
 	zend_bool retval = 0; 
 	int callable_name_len_local;
@@ -1927,16 +2362,22 @@ ZEND_API zend_bool zend_is_callable_ex(zval *callable, uint check_flags, char **
 
 	switch (Z_TYPE_P(callable)) {
 		case IS_STRING:
+		case IS_UNICODE:
 			if (callable_name) {
-				*callable_name = estrndup(Z_STRVAL_P(callable), Z_STRLEN_P(callable));
-				*callable_name_len = Z_STRLEN_P(callable);
+				/* UTODO: we need to return callable name type as well */
+				if (Z_TYPE_P(callable) == IS_UNICODE) {
+					*callable_name = (char*)eustrndup(Z_USTRVAL_P(callable), Z_USTRLEN_P(callable));
+				} else {
+					*callable_name = estrndup(Z_STRVAL_P(callable), Z_STRLEN_P(callable));
+				}
+				*callable_name_len = Z_UNILEN_P(callable);
 			}
 			if (check_flags & IS_CALLABLE_CHECK_SYNTAX_ONLY) {
 				return 1;
 			}
 
-			lcname = zend_str_tolower_dup(Z_STRVAL_P(callable), Z_STRLEN_P(callable));
-			if (zend_hash_find(EG(function_table), lcname, Z_STRLEN_P(callable)+1, (void**)fptr_ptr) == SUCCESS) {
+			lcname = zend_u_str_case_fold(Z_TYPE_P(callable), Z_UNIVAL_P(callable), Z_UNILEN_P(callable), 1, &lcname_len);
+			if (zend_u_hash_find(EG(function_table), Z_TYPE_P(callable), lcname, lcname_len+1, (void**)fptr_ptr) == SUCCESS) {
 				retval = 1;
 			}
 			efree(lcname);
@@ -1951,10 +2392,13 @@ ZEND_API zend_bool zend_is_callable_ex(zval *callable, uint check_flags, char **
 				if (zend_hash_num_elements(Z_ARRVAL_P(callable)) == 2 &&
 					zend_hash_index_find(Z_ARRVAL_P(callable), 0, (void **) &obj) == SUCCESS &&
 					zend_hash_index_find(Z_ARRVAL_P(callable), 1, (void **) &method) == SUCCESS &&
-					(Z_TYPE_PP(obj) == IS_OBJECT || Z_TYPE_PP(obj) == IS_STRING) &&
-					Z_TYPE_PP(method) == IS_STRING) {
+					(Z_TYPE_PP(obj) == IS_OBJECT ||
+					Z_TYPE_PP(obj) == IS_STRING ||
+					Z_TYPE_PP(obj) == IS_UNICODE) &&
+					(Z_TYPE_PP(method) == IS_STRING ||
+					 Z_TYPE_PP(method) == IS_UNICODE)) {
 
-					if (Z_TYPE_PP(obj) == IS_STRING) {
+					if (Z_TYPE_PP(obj) == IS_STRING || Z_TYPE_PP(obj) == IS_UNICODE) {
 						if (callable_name) {
 							char *ptr;
 
@@ -1970,13 +2414,17 @@ ZEND_API zend_bool zend_is_callable_ex(zval *callable, uint check_flags, char **
 						if (check_flags & IS_CALLABLE_CHECK_SYNTAX_ONLY)
 							return 1;
 
-						lcname = zend_str_tolower_dup(Z_STRVAL_PP(obj), Z_STRLEN_PP(obj));
+						lcname = zend_u_str_case_fold(Z_TYPE_PP(obj), Z_UNIVAL_PP(obj), Z_UNILEN_PP(obj), 1, &lcname_len);
 
-						if (EG(active_op_array) && strcmp(lcname, "self") == 0) {
+						if (EG(active_op_array) &&
+						    lcname_len == sizeof("self")-1 &&
+						    ZEND_U_EQUAL(Z_TYPE_PP(obj), lcname, lcname_len, "self", sizeof("self")-1)) {
 							ce = EG(active_op_array)->scope;
-						} else if (strcmp(lcname, "parent") == 0 && EG(active_op_array) && EG(active_op_array)->scope) {
+						} else if (EG(active_op_array) && EG(active_op_array)->scope &&
+						    lcname_len == sizeof("parent")-1 &&
+						    ZEND_U_EQUAL(Z_TYPE_PP(obj), lcname, lcname_len, "parent", sizeof("parent")-1)) {
 							ce = EG(active_op_array)->scope->parent;
-						} else if (zend_lookup_class(Z_STRVAL_PP(obj), Z_STRLEN_PP(obj), &pce TSRMLS_CC) == SUCCESS) {
+						} else if (zend_u_lookup_class(Z_TYPE_PP(obj), Z_UNIVAL_PP(obj), Z_UNILEN_PP(obj), &pce TSRMLS_CC) == SUCCESS) {
 							ce = *pce;
 						}
 						
@@ -2005,8 +2453,8 @@ ZEND_API zend_bool zend_is_callable_ex(zval *callable, uint check_flags, char **
 					if (ce) {
 						zend_function *fbc;
 
-						lcname = zend_str_tolower_dup(Z_STRVAL_PP(method), Z_STRLEN_PP(method));
-						if (zend_hash_find(&ce->function_table, lcname, Z_STRLEN_PP(method)+1, (void **)&fbc) == SUCCESS) {
+						lcname = zend_u_str_case_fold(Z_TYPE_PP(method), Z_STRVAL_PP(method), Z_STRLEN_PP(method), 1, &lcname_len);
+						if (zend_u_hash_find(&ce->function_table, Z_TYPE_PP(method), lcname, lcname_len+1, (void **)&fbc) == SUCCESS) {
  							retval = 1;
 							if ((check_flags & IS_CALLABLE_CHECK_NO_ACCESS) == 0) {
 								if (fbc->op_array.fn_flags & ZEND_ACC_PRIVATE) {
@@ -2105,19 +2553,13 @@ ZEND_API char *zend_get_module_version(char *module_name)
 	zend_module_entry *module;
 
 	if (zend_hash_find(&module_registry, module_name, strlen(module_name) + 1,
-                       (void**)&module) == FAILURE) {
+	                   (void**)&module) == FAILURE) {
 		return NULL;
 	}
-    return module->version;
-}
-
-
-ZEND_API int zend_declare_property(zend_class_entry *ce, char *name, int name_length, zval *property, int access_type TSRMLS_DC)
-{
-	return zend_declare_property_ex(ce, name, name_length, property, access_type, NULL, 0 TSRMLS_CC);
+	return module->version;
 }
 
-ZEND_API int zend_declare_property_ex(zend_class_entry *ce, char *name, int name_length, zval *property, int access_type, char *doc_comment, int doc_comment_len TSRMLS_DC)
+ZEND_API int zend_u_declare_property_ex(zend_class_entry *ce, zend_uchar type, void *name, int name_length, zval *property, int access_type, char *doc_comment, int doc_comment_len TSRMLS_DC)
 {
 	zend_property_info property_info;
 	HashTable *target_symbol_table;
@@ -2147,8 +2589,8 @@ ZEND_API int zend_declare_property_ex(zend_class_entry *ce, char *name, int name
 				char *priv_name;
 				int priv_name_length;
 
-				zend_mangle_property_name(&priv_name, &priv_name_length, ce->name, ce->name_length, name, name_length, ce->type & ZEND_INTERNAL_CLASS);
-				zend_hash_update(target_symbol_table, priv_name, priv_name_length+1, &property, sizeof(zval *), NULL);
+				zend_u_mangle_property_name(&priv_name, &priv_name_length, type, ce->name, ce->name_length, name, name_length, ce->type & ZEND_INTERNAL_CLASS);
+				zend_u_hash_update(target_symbol_table, type, priv_name, priv_name_length+1, &property, sizeof(zval *), NULL);
 				property_info.name = priv_name;
 				property_info.name_length = priv_name_length;
 			}
@@ -2157,8 +2599,8 @@ ZEND_API int zend_declare_property_ex(zend_class_entry *ce, char *name, int name
 				char *prot_name;
 				int prot_name_length;
 
-				zend_mangle_property_name(&prot_name, &prot_name_length, "*", 1, name, name_length, ce->type & ZEND_INTERNAL_CLASS);
-				zend_hash_update(target_symbol_table, prot_name, prot_name_length+1, &property, sizeof(zval *), NULL);
+				zend_u_mangle_property_name(&prot_name, &prot_name_length, type, "*", 1, name, name_length, ce->type & ZEND_INTERNAL_CLASS);
+				zend_u_hash_update(target_symbol_table, type, prot_name, prot_name_length+1, &property, sizeof(zval *), NULL);
 				property_info.name = prot_name;
 				property_info.name_length = prot_name_length;
 			}
@@ -2168,26 +2610,43 @@ ZEND_API int zend_declare_property_ex(zend_class_entry *ce, char *name, int name
 				char *prot_name;
 				int prot_name_length;
 
-				zend_mangle_property_name(&prot_name, &prot_name_length, "*", 1, name, name_length, ce->type & ZEND_INTERNAL_CLASS);
-				zend_hash_del(target_symbol_table, prot_name, prot_name_length+1);
+				zend_u_mangle_property_name(&prot_name, &prot_name_length, type, "*", 1, name, name_length, ce->type & ZEND_INTERNAL_CLASS);
+				zend_u_hash_del(target_symbol_table, type, prot_name, prot_name_length+1);
 				pefree(prot_name, ce->type & ZEND_INTERNAL_CLASS);
 			}
-			zend_hash_update(target_symbol_table, name, name_length+1, &property, sizeof(zval *), NULL);
-			property_info.name = ce->type & ZEND_INTERNAL_CLASS ? zend_strndup(name, name_length) : estrndup(name, name_length);
+			zend_u_hash_update(target_symbol_table, type, name, name_length+1, &property, sizeof(zval *), NULL);
+			property_info.name = ce->type & ZEND_INTERNAL_CLASS ? 
+				(type==IS_UNICODE?(char*)zend_ustrndup(name, name_length):zend_strndup(name, name_length)) : 
+				(type==IS_UNICODE?(char*)eustrndup(name, name_length):estrndup(name, name_length));
 			property_info.name_length = name_length;
 			break;
 	}
 	property_info.flags = access_type;
-	property_info.h = zend_get_hash_value(property_info.name, property_info.name_length+1);
+	property_info.h = zend_u_get_hash_value(type, property_info.name, property_info.name_length+1);
 
 	property_info.doc_comment = doc_comment;
 	property_info.doc_comment_len = doc_comment_len;
 	
-	zend_hash_update(&ce->properties_info, name, name_length + 1, &property_info, sizeof(zend_property_info), NULL);
+	zend_u_hash_update(&ce->properties_info, type, name, name_length + 1, &property_info, sizeof(zend_property_info), NULL);
 
 	return SUCCESS;
 }
 
+ZEND_API int zend_declare_property_ex(zend_class_entry *ce, char *name, int name_length, zval *property, int access_type, char *doc_comment, int doc_comment_len TSRMLS_DC)
+{
+	return zend_u_declare_property_ex(ce, IS_STRING, name, name_length, property, access_type, NULL, 0 TSRMLS_CC);
+}
+
+ZEND_API int zend_u_declare_property(zend_class_entry *ce, zend_uchar type, void *name, int name_length, zval *property, int access_type TSRMLS_DC)
+{
+	return zend_u_declare_property_ex(ce, type, name, name_length, property, access_type, NULL, 0 TSRMLS_CC);
+}
+
+ZEND_API int zend_declare_property(zend_class_entry *ce, char *name, int name_length, zval *property, int access_type TSRMLS_DC)
+{
+	return zend_u_declare_property_ex(ce, IS_STRING, name, name_length, property, access_type, NULL, 0 TSRMLS_CC);
+}
+
 ZEND_API int zend_declare_property_null(zend_class_entry *ce, char *name, int name_length, int access_type TSRMLS_DC)
 {
 	zval *property;
@@ -2287,7 +2746,7 @@ ZEND_API void zend_update_property(zend_class_entry *scope, zval *object, char *
 
 		zend_get_object_classname(object, &class_name, &class_name_len TSRMLS_CC);
 		
-		zend_error(E_CORE_ERROR, "Property %s of class %s cannot be updated", name, class_name);
+		zend_error(E_CORE_ERROR, "Property %s of class %v cannot be updated", name, class_name);
 	}
 	ZVAL_STRINGL(&property, name, name_length, 0);
 	Z_OBJ_HT_P(object)->write_property(object, &property, value TSRMLS_CC);
@@ -2373,7 +2832,7 @@ ZEND_API zval *zend_read_property(zend_class_entry *scope, zval *object, char *n
 		zend_uint class_name_len;
 
 		zend_get_object_classname(object, &class_name, &class_name_len TSRMLS_CC);
-		zend_error(E_CORE_ERROR, "Property %s of class %s cannot be read", name, class_name);
+		zend_error(E_CORE_ERROR, "Property %s of class %v cannot be read", name, class_name);
 	}
 	ZVAL_STRINGL(&property, name, name_length, 0);
 	value = Z_OBJ_HT_P(object)->read_property(object, &property, silent TSRMLS_CC);
@@ -2382,6 +2841,50 @@ ZEND_API zval *zend_read_property(zend_class_entry *scope, zval *object, char *n
 	return value;
 }
 
+ZEND_API zend_class_entry* zend_get_named_class_entry(char* name, int name_length TSRMLS_DC)
+{
+	zend_class_entry **scope;
+	char *lcname = do_alloca(name_length+1);
+
+	zend_str_tolower_copy(lcname, name, name_length);
+	if (zend_hash_find(CG(class_table), lcname, name_length+1, (void**)&scope) == FAILURE) {
+		free_alloca(lcname);
+		zend_error(E_ERROR, "Class '%s' is not defined", name);
+		return NULL;
+	}
+	free_alloca(lcname);
+	return *scope;
+}
+
+
+/*
+ * Return the most precise string type out of the list.
+ * If none of the types are string types, IS_STRING is returned.
+ * Binary > Unicode > string.
+ */
+ZEND_API zend_uchar zend_get_best_string_type(int num_args, ...)
+{
+	va_list ap;
+	int best_type = IS_STRING;
+	int type;
+
+	if (num_args <= 0) return -1;
+
+	va_start(ap, num_args);
+	while (num_args--) {
+		type = va_arg(ap, int);
+		if (type == IS_BINARY) {
+			best_type = IS_BINARY;
+			break;
+		} else if (type == IS_UNICODE && best_type == IS_STRING) {
+			best_type = IS_UNICODE;
+		}
+	}
+	va_end(ap);
+
+	return best_type;
+}
+
 /*
  * Local variables:
  * tab-width: 4