Switch (un)mangle property name to size_t and zend_string

Also use the _ex variants where possible.

diff --git a/Zend/zend.c b/Zend/zend.c
index eee2739dd29772dcfb0e01dbcb805d3be3c7757c..46719b4ac18e67e6fbf594b4b8c2e86b20b57cd5 100644 (file)
--- a/Zend/zend.c
+++ b/Zend/zend.c
@@ -156,8 +156,8 @@ static void print_hash(zend_write_func_t write_func, HashTable *ht, int indent,
                if (string_key) {
                        if (is_object) {
                                const char *prop_name, *class_name;
-                               int prop_len;
-                               int mangled = zend_unmangle_property_name_ex(string_key->val, string_key->len, &class_name, &prop_name, &prop_len);
+                               size_t prop_len;
+                               int mangled = zend_unmangle_property_name_ex(string_key, &class_name, &prop_name, &prop_len);
 
                                ZEND_WRITE_EX(prop_name, prop_len);
                                if (class_name && mangled == SUCCESS) {

diff --git a/Zend/zend_builtin_functions.c b/Zend/zend_builtin_functions.c
index 0977b648d7890dac5ae723f95d95d8bb10610e6c..1bb02ef2eb1963fdd1ea6e1f9b42436b2f4b658b 100644 (file)
--- a/Zend/zend_builtin_functions.c
+++ b/Zend/zend_builtin_functions.c
@@ -1036,8 +1036,6 @@ ZEND_FUNCTION(get_object_vars)
        zval *value;
        HashTable *properties;
        zend_string *key;
-       const char *prop_name, *class_name;
-       uint prop_len;
        zend_object *zobj;
 
 #ifndef FAST_ZPP
@@ -1070,7 +1068,9 @@ ZEND_FUNCTION(get_object_vars)
                                /* Not separating references */
                                if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
                                if (key->val[0] == 0) {
-                                       zend_unmangle_property_name_ex(key->val, key->len, &class_name, &prop_name, (int*) &prop_len);
+                                       const char *prop_name, *class_name;
+                                       size_t prop_len;
+                                       zend_unmangle_property_name_ex(key, &class_name, &prop_name, &prop_len);
                                        zend_hash_str_add_new(Z_ARRVAL_P(return_value), prop_name, prop_len, value);
                                } else {
                                        zend_hash_add_new(Z_ARRVAL_P(return_value), key, value);

diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
index 7a1822c1f68a829a9ec40722da136c8c13d7739d..5beacab0b611152ba9cfa14133dc797bdd7a8f7a 100644 (file)
--- a/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@ -2300,10 +2300,10 @@ static void zend_do_traits_property_binding(zend_class_entry *ce TSRMLS_DC) /* {
                                prop_name = zend_string_copy(property_info->name);
                        } else {
                                const char *pname;
-                               int pname_len;
+                               size_t pname_len;
 
                                /* for private and protected we need to unmangle the names */
-                               zend_unmangle_property_name_ex(property_info->name->val, property_info->name->len,
+                               zend_unmangle_property_name_ex(property_info->name,
                                                                                        &class_name_unused, &pname, &pname_len);
                                prop_name = zend_string_init(pname, pname_len, 0);
                        }
@@ -2668,13 +2668,11 @@ ZEND_API void zend_do_delayed_early_binding(const zend_op_array *op_array TSRMLS
 }
 /* }}} */
 
-ZEND_API zend_string *zend_mangle_property_name(const char *src1, int src1_length, const char *src2, int src2_length, int internal) /* {{{ */
+ZEND_API zend_string *zend_mangle_property_name(const char *src1, size_t src1_length, const char *src2, size_t src2_length, int internal) /* {{{ */
 {
-       zend_string *prop_name;
-       int prop_name_length;
+       size_t prop_name_length = 1 + src1_length + 1 + src2_length;
+       zend_string *prop_name = zend_string_alloc(prop_name_length, internal);
 
-       prop_name_length = 1 + src1_length + 1 + src2_length;
-       prop_name = zend_string_alloc(prop_name_length, internal);
        prop_name->val[0] = '\0';
        memcpy(prop_name->val + 1, src1, src1_length+1);
        memcpy(prop_name->val + 1 + src1_length + 1, src2, src2_length+1);
@@ -2682,49 +2680,50 @@ ZEND_API zend_string *zend_mangle_property_name(const char *src1, int src1_lengt
 }
 /* }}} */
 
-static int zend_strnlen(const char* s, int maxlen) /* {{{ */
+static int zend_strnlen(const char* s, size_t maxlen) /* {{{ */
 {
-       int len = 0;
+       size_t len = 0;
        while (*s++ && maxlen--) len++;
        return len;
 }
 /* }}} */
 
-ZEND_API int zend_unmangle_property_name_ex(const char *mangled_property, int len, const char **class_name, const char **prop_name, int *prop_len) /* {{{ */
+ZEND_API int zend_unmangle_property_name_ex(const zend_string *name, const char **class_name, const char **prop_name, size_t *prop_len) /* {{{ */
 {
-       int class_name_len;
+       size_t class_name_len;
 
        *class_name = NULL;
 
-       if (mangled_property[0]!=0) {
-               *prop_name = mangled_property;
+       if (name->val[0] != '\0') {
+               *prop_name = name->val;
                if (prop_len) {
-                       *prop_len = len;
+                       *prop_len = name->len;
                }
                return SUCCESS;
        }
-       if (len < 3 || mangled_property[1]==0) {
+       if (name->len < 3 || name->val[1] == '\0') {
                zend_error(E_NOTICE, "Illegal member variable name");
-               *prop_name = mangled_property;
+               *prop_name = name->val;
                if (prop_len) {
-                       *prop_len = len;
+                       *prop_len = name->len;
                }
                return FAILURE;
        }
 
-       class_name_len = zend_strnlen(mangled_property + 1, --len - 1) + 1;
-       if (class_name_len >= len || mangled_property[class_name_len]!=0) {
+       class_name_len = zend_strnlen(name->val + 1, name->len - 2);
+       if (class_name_len >= name->len - 2 || name->val[class_name_len + 1] != '\0') {
                zend_error(E_NOTICE, "Corrupt member variable name");
-               *prop_name = mangled_property;
+               *prop_name = name->val;
                if (prop_len) {
-                       *prop_len = len + 1;
+                       *prop_len = name->len;
                }
                return FAILURE;
        }
-       *class_name = mangled_property + 1;
-       *prop_name = (*class_name) + class_name_len;
+
+       *class_name = name->val + 1;
+       *prop_name = name->val + class_name_len + 2;
        if (prop_len) {
-               *prop_len = len - class_name_len;
+               *prop_len = name->len - class_name_len - 2;
        }
        return SUCCESS;
 }

diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h
index 4b20b54bbaadbe4417647999ac22955faa355058..8cbe465c1473a42eabaa339b56a744e4661f9468 100644 (file)
--- a/Zend/zend_compile.h
+++ b/Zend/zend_compile.h
@@ -499,10 +499,10 @@ ZEND_API void zend_function_dtor(zval *zv);
 ZEND_API void destroy_zend_class(zval *zv);
 void zend_class_add_ref(zval *zv);
 
-ZEND_API zend_string *zend_mangle_property_name(const char *src1, int src1_length, const char *src2, int src2_length, int internal);
-#define zend_unmangle_property_name(mangled_property, mangled_property_len, class_name, prop_name) \
-        zend_unmangle_property_name_ex(mangled_property, mangled_property_len, class_name, prop_name, NULL)
-ZEND_API int zend_unmangle_property_name_ex(const char *mangled_property, int mangled_property_len, const char **class_name, const char **prop_name, int *prop_len);
+ZEND_API zend_string *zend_mangle_property_name(const char *src1, size_t src1_length, const char *src2, size_t src2_length, int internal);
+#define zend_unmangle_property_name(mangled_property, class_name, prop_name) \
+        zend_unmangle_property_name_ex(mangled_property, class_name, prop_name, NULL)
+ZEND_API int zend_unmangle_property_name_ex(const zend_string *name, const char **class_name, const char **prop_name, size_t *prop_len);
 
 #define ZEND_FUNCTION_DTOR zend_function_dtor
 #define ZEND_CLASS_DTOR destroy_zend_class

diff --git a/Zend/zend_object_handlers.c b/Zend/zend_object_handlers.c
index 36c4efd8822de698750037a3cc60d815763e3002..f831d2fadd623bb345d48f210fad98e532d8ea11 100644 (file)
--- a/Zend/zend_object_handlers.c
+++ b/Zend/zend_object_handlers.c
@@ -397,10 +397,10 @@ ZEND_API int zend_check_property_access(zend_object *zobj, zend_string *prop_inf
        const char *class_name = NULL;
        const char *prop_name;
        zend_string *member;
-       int prop_name_len;
+       size_t prop_name_len;
 
        if (prop_info_name->val[0] == 0) {
-               zend_unmangle_property_name_ex(prop_info_name->val, prop_info_name->len, &class_name, &prop_name, &prop_name_len);
+               zend_unmangle_property_name_ex(prop_info_name, &class_name, &prop_name, &prop_name_len);
                member = zend_string_init(prop_name, prop_name_len, 0);
        } else {
                member = zend_string_copy(prop_info_name);
@@ -434,10 +434,12 @@ static zend_long *zend_get_property_guard(zend_object *zobj, zend_property_info
                info.name = Z_STR_P(member);
        } else if(property_info->name->val[0] == '\0'){
                const char *class_name = NULL, *prop_name = NULL;
-               zend_unmangle_property_name(property_info->name->val, property_info->name->len, &class_name, &prop_name);
+               size_t prop_name_len;
+               zend_unmangle_property_name_ex(property_info->name, &class_name,
+                       &prop_name, &prop_name_len);
                if (class_name) {
                        /* use unmangled name for protected properties */
-                       str = info.name = zend_string_init(prop_name, strlen(prop_name), 0);
+                       str = info.name = zend_string_init(prop_name, prop_name_len, 0);
                        property_info = &info;
                }
        }

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index 97351ce5d9b9f0340a75325597fa527d813b780f..d2171579667700beb06de4e084ff3b9bf7564f6f 100644 (file)
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -4811,9 +4811,9 @@ ZEND_VM_HANDLER(78, ZEND_FE_FETCH, VAR, ANY)
                                                        }
                                                } else {
                                                        const char *class_name, *prop_name;
-                                                       int prop_name_len;
+                                                       size_t prop_name_len;
                                                        zend_unmangle_property_name_ex(
-                                                               p->key->val, p->key->len, &class_name, &prop_name, &prop_name_len);
+                                                               p->key, &class_name, &prop_name, &prop_name_len);
                                                        ZVAL_STRINGL(EX_VAR((opline+1)->result.var), prop_name, prop_name_len);
                                                }
                                        }

diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index 646a4987601ec56dccdc30fee8c6b23a8023b9c3..53a36958eb038b7f5c821bdd48d134918cb4e3a0 100644 (file)
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -16791,9 +16791,9 @@ static int ZEND_FASTCALL  ZEND_FE_FETCH_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
                                                        }
                                                } else {
                                                        const char *class_name, *prop_name;
-                                                       int prop_name_len;
+                                                       size_t prop_name_len;
                                                        zend_unmangle_property_name_ex(
-                                                               p->key->val, p->key->len, &class_name, &prop_name, &prop_name_len);
+                                                               p->key, &class_name, &prop_name, &prop_name_len);
                                                        ZVAL_STRINGL(EX_VAR((opline+1)->result.var), prop_name, prop_name_len);
                                                }
                                        }

diff --git a/ext/reflection/php_reflection.c b/ext/reflection/php_reflection.c
index c52f8d155c8e4feb6f8f906e032b113965e81945..c2e26103085d54e4df99a1e28a91507a4c906495 100644 (file)
--- a/ext/reflection/php_reflection.c
+++ b/ext/reflection/php_reflection.c
@@ -941,7 +941,7 @@ static void _property_string(string *str, zend_property_info *prop, char *prop_n
                        string_printf(str, "static ");
                }
 
-               zend_unmangle_property_name(prop->name->val, prop->name->len, &class_name, (const char**)&prop_name);
+               zend_unmangle_property_name(prop->name, &class_name, (const char**)&prop_name);
                string_printf(str, "$%s", prop_name);
        }
 
@@ -1298,9 +1298,9 @@ static void reflection_property_factory(zend_class_entry *ce, zend_property_info
        zval classname;
        property_reference *reference;
        const char *class_name, *prop_name;
-       int prop_name_len;
+       size_t prop_name_len;
 
-       zend_unmangle_property_name_ex(prop->name->val, prop->name->len, &class_name, &prop_name, &prop_name_len);
+       zend_unmangle_property_name_ex(prop->name, &class_name, &prop_name, &prop_name_len);
 
        if (!(prop->flags & ZEND_ACC_PRIVATE)) {
                /* we have to search the class hierarchy for this (implicit) public or protected property */
@@ -4733,7 +4733,6 @@ ZEND_METHOD(reflection_property, __construct)
 {
        zval propname, cname, *classname;
        char *name_str;
-       const char *class_name, *prop_name;
        size_t name_len;
        int dynam_prop = 0;
        zval *object;
@@ -4797,9 +4796,11 @@ ZEND_METHOD(reflection_property, __construct)
        }
 
        if (dynam_prop == 0) {
-               zend_unmangle_property_name(property_info->name->val, property_info->name->len, &class_name, &prop_name);
+               const char *class_name, *prop_name;
+               size_t prop_name_len;
+               zend_unmangle_property_name_ex(property_info->name, &class_name, &prop_name, &prop_name_len);
                ZVAL_STR(&cname, zend_string_copy(property_info->ce->name));
-               ZVAL_STRING(&propname, prop_name);
+               ZVAL_STRINGL(&propname, prop_name, prop_name_len);
        } else {
                ZVAL_STR(&cname, zend_string_copy(ce->name));
                ZVAL_STRINGL(&propname, name_str, name_len);
@@ -4950,12 +4951,14 @@ ZEND_METHOD(reflection_property, getValue)
                ZVAL_DUP(return_value, &CE_STATIC_MEMBERS(intern->ce)[ref->prop.offset]);
        } else {
                const char *class_name, *prop_name;
+               size_t prop_name_len;
 
                if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o", &object) == FAILURE) {
                        return;
                }
-               zend_unmangle_property_name(ref->prop.name->val, ref->prop.name->len, &class_name, &prop_name);
-               member_p = zend_read_property(ref->ce, object, prop_name, strlen(prop_name), 1 TSRMLS_CC);
+
+               zend_unmangle_property_name_ex(ref->prop.name, &class_name, &prop_name, &prop_name_len);
+               member_p = zend_read_property(ref->ce, object, prop_name, prop_name_len, 1 TSRMLS_CC);
                ZVAL_DUP(return_value, member_p);
        }
 }
@@ -5024,12 +5027,14 @@ ZEND_METHOD(reflection_property, setValue)
                }
        } else {
                const char *class_name, *prop_name;
+               size_t prop_name_len;
 
                if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "oz", &object, &value) == FAILURE) {
                        return;
                }
-               zend_unmangle_property_name(ref->prop.name->val, ref->prop.name->len, &class_name, &prop_name);
-               zend_update_property(ref->ce, object, prop_name, strlen(prop_name), value TSRMLS_CC);
+
+               zend_unmangle_property_name_ex(ref->prop.name, &class_name, &prop_name, &prop_name_len);
+               zend_update_property(ref->ce, object, prop_name, prop_name_len, value TSRMLS_CC);
        }
 }
 /* }}} */
@@ -5043,18 +5048,17 @@ ZEND_METHOD(reflection_property, getDeclaringClass)
        zend_class_entry *tmp_ce, *ce;
        zend_property_info *tmp_info;
        const char *prop_name, *class_name;
-       int prop_name_len;
+       size_t prop_name_len;
 
        if (zend_parse_parameters_none() == FAILURE) {
                return;
        }
        GET_REFLECTION_OBJECT_PTR(ref);
 
-       if (zend_unmangle_property_name(ref->prop.name->val, ref->prop.name->len, &class_name, &prop_name) != SUCCESS) {
+       if (zend_unmangle_property_name_ex(ref->prop.name, &class_name, &prop_name, &prop_name_len) != SUCCESS) {
                RETURN_FALSE;
        }
 
-       prop_name_len = strlen(prop_name);
        ce = tmp_ce = ref->ce;
        while (tmp_ce && (tmp_info = zend_hash_str_find_ptr(&tmp_ce->properties_info, prop_name, prop_name_len)) != NULL) {
                if (tmp_info->flags & ZEND_ACC_PRIVATE || tmp_info->flags & ZEND_ACC_SHADOW) {

diff --git a/ext/soap/php_encoding.c b/ext/soap/php_encoding.c
index 6189f172a6728aba359882ba1434eefa9ba53bfa..8de045ae800655020ad3f1db4443e3e68461e008 100644 (file)
--- a/ext/soap/php_encoding.c
+++ b/ext/soap/php_encoding.c
@@ -1984,7 +1984,7 @@ static xmlNodePtr to_xml_object(encodeTypePtr type, zval *data, int style, xmlNo
                                        if (Z_TYPE_P(data) == IS_OBJECT) {
                                                const char *class_name;
 
-                                               zend_unmangle_property_name(str_key->val, str_key->len, &class_name, &prop_name);
+                                               zend_unmangle_property_name(str_key, &class_name, &prop_name);
                                        } else {
                                                prop_name = str_key->val;
                                        }

diff --git a/ext/standard/http.c b/ext/standard/http.c
index 62b05ed7b536f4d419179f0ef9e196ac9bda7d9e..cf44a87c648ead6687f9fdde0e125a86008bbb15 100644 (file)
--- a/ext/standard/http.c
+++ b/ext/standard/http.c
@@ -66,7 +66,7 @@ PHPAPI int php_url_encode_hash_ex(HashTable *ht, smart_str *formstr,
                                        /* private or protected property access outside of the class */
                                        continue;
                                }
-                               zend_unmangle_property_name_ex(key->val, key->len, &tmp, &prop_name, (int *)&prop_len);
+                               zend_unmangle_property_name_ex(key, &tmp, &prop_name, &prop_len);
                        } else {
                                prop_name = key->val;
                                prop_len = key->len;

diff --git a/ext/standard/var.c b/ext/standard/var.c
index 829e8053abe5b9ea5705776c18058131ca2ed8d4..664198ad97572143ac0bd53c24cb8867486fd0d7 100644 (file)
--- a/ext/standard/var.c
+++ b/ext/standard/var.c
@@ -74,7 +74,7 @@ static void php_object_property_dump(zval *zv, zend_ulong index, zend_string *ke
        if (key == NULL) { /* numeric key */
                php_printf("%*c[" ZEND_LONG_FMT "]=>\n", level + 1, ' ', index);
        } else { /* string key */
-               int unmangle = zend_unmangle_property_name(key->val, key->len, &class_name, &prop_name);
+               int unmangle = zend_unmangle_property_name(key, &class_name, &prop_name);
                php_printf("%*c[", level + 1, ' ');
 
                if (class_name && unmangle == SUCCESS) {
@@ -247,7 +247,7 @@ static void zval_object_property_dump(zval *zv, zend_ulong index, zend_string *k
        if (key == NULL) { /* numeric key */
                php_printf("%*c[" ZEND_LONG_FMT "]=>\n", level + 1, ' ', index);
        } else { /* string key */
-               zend_unmangle_property_name(key->val, key->len, &class_name, &prop_name);
+               zend_unmangle_property_name(key, &class_name, &prop_name);
                php_printf("%*c[", level + 1, ' ');
 
                if (class_name) {
@@ -430,13 +430,12 @@ static void php_object_element_export(zval *zv, zend_ulong index, zend_string *k
 {
        buffer_append_spaces(buf, level + 2);
        if (key != NULL) {
-               const char *class_name; /* ignored, but must be passed to unmangle */
-               const char *pname;
+               const char *class_name, *prop_name;
+               size_t prop_name_len;
                zend_string *pname_esc;
                
-               zend_unmangle_property_name(key->val, key->len,
-                               &class_name, &pname);
-               pname_esc = php_addcslashes(pname, strlen(pname), 0, "'\\", 2 TSRMLS_CC);
+               zend_unmangle_property_name_ex(key, &class_name, &prop_name, &prop_name_len);
+               pname_esc = php_addcslashes(prop_name, prop_name_len, 0, "'\\", 2 TSRMLS_CC);
 
                smart_str_appendc(buf, '\'');
                smart_str_appendl(buf, pname_esc->val, pname_esc->len);

diff --git a/ext/wddx/wddx.c b/ext/wddx/wddx.c
index b799fa261dda03f387d97ccab0adb9503e624cc8..bbd9bf35f823525215af47b2dcae173dad47144a 100644 (file)
--- a/ext/wddx/wddx.c
+++ b/ext/wddx/wddx.c
@@ -505,10 +505,11 @@ static void php_wddx_serialize_object(wddx_packet *packet, zval *obj)
                        }
                        if (key) {
                                const char *class_name, *prop_name;
+                               size_t prop_name_len;
                                zend_string *tmp;
                                
-                               zend_unmangle_property_name(key->val, key->len, &class_name, &prop_name);
-                               tmp = zend_string_init(prop_name, strlen(prop_name), 0);
+                               zend_unmangle_property_name_ex(key, &class_name, &prop_name, &prop_name_len);
+                               tmp = zend_string_init(prop_name, prop_name_len, 0);
                                php_wddx_serialize_var(packet, ent, tmp TSRMLS_CC);
                                zend_string_release(tmp);
                        } else {