Make use optimized string lowering

diff --git a/Zend/zend_API.c b/Zend/zend_API.c
index 73313cdfed4edf42782d6fb1a1d1de1e89e6b293..034d6c9debdc9222156296e52fbfb067e21a4637 100644 (file)
--- a/Zend/zend_API.c
+++ b/Zend/zend_API.c
@@ -1182,8 +1182,7 @@ int zend_register_functions(zend_class_entry *scope, zend_function_entry *functi
                }
                fname_len = strlen(ptr->fname);
                lowercase_name = do_alloca(fname_len+1);
-               memcpy(lowercase_name, ptr->fname, fname_len+1);
-               zend_str_tolower(lowercase_name, fname_len);
+               zend_str_tolower_copy(lowercase_name, ptr->fname, fname_len);
                if (zend_hash_add(target_function_table, lowercase_name, fname_len+1, &function, sizeof(zend_function), (void**)&reg_function) == FAILURE) {
                        unload=1;
                        free_alloca(lowercase_name);
@@ -1377,7 +1376,7 @@ ZEND_API zend_class_entry *zend_register_internal_class_ex(zend_class_entry *cla
 ZEND_API zend_class_entry *zend_register_internal_class(zend_class_entry *orig_class_entry TSRMLS_DC)
 {
        zend_class_entry *class_entry = malloc(sizeof(zend_class_entry));
-       char *lowercase_name = zend_strndup(orig_class_entry->name, orig_class_entry->name_length);
+       char *lowercase_name = malloc(orig_class_entry->name_length + 1);
        *class_entry = *orig_class_entry;
 
        class_entry->type = ZEND_INTERNAL_CLASS;
@@ -1387,7 +1386,7 @@ ZEND_API zend_class_entry *zend_register_internal_class(zend_class_entry *orig_c
                zend_register_functions(class_entry, class_entry->builtin_functions, &class_entry->function_table, MODULE_PERSISTENT TSRMLS_CC);
        }
 
-       zend_str_tolower(lowercase_name, class_entry->name_length);
+       zend_str_tolower_copy(lowercase_name, orig_class_entry->name, class_entry->name_length);
        zend_hash_update(CG(class_table), lowercase_name, class_entry->name_length+1, &class_entry, sizeof(zend_class_entry *), NULL);
        free(lowercase_name);
        return class_entry;
@@ -1403,8 +1402,8 @@ ZEND_API zend_class_entry *zend_register_internal_ns_class(zend_class_entry *cla
        if (!ns && ns_name) {
                zend_namespace **pns;
                size_t ns_name_length = strlen(ns_name);
-               char *lowercase_name = zend_strndup(ns_name, ns_name_length);
-               zend_str_tolower(lowercase_name, ns_name_length);
+               char *lowercase_name = malloc(ns_name_length + 1);
+               zend_str_tolower_copy(lowercase_name, ns_name, ns_name_length);
                if (zend_hash_find(&CG(global_namespace).class_table, lowercase_name, ns_name_length+1, (void **)&pns) == FAILURE) {
                        free(lowercase_name);
                        return NULL;
@@ -1434,13 +1433,13 @@ ZEND_API zend_class_entry *zend_register_internal_ns_class(zend_class_entry *cla
 ZEND_API zend_namespace *zend_register_internal_namespace(zend_namespace *orig_ns TSRMLS_DC)
 {
        zend_namespace *ns = malloc(sizeof(zend_namespace));
-       char *lowercase_name = zend_strndup(orig_ns->name, orig_ns->name_length);
+       char *lowercase_name = malloc(orig_ns->name_length + 1);
        *ns = *orig_ns;
 
        ns->type = ZEND_INTERNAL_NAMESPACE;
        zend_init_namespace(ns TSRMLS_CC);
 
-       zend_str_tolower(lowercase_name, ns->name_length);
+       zend_str_tolower_copy(lowercase_name, orig_ns->name, orig_ns->name_length);
        zend_hash_update(&CG(global_namespace).class_table, lowercase_name, ns->name_length+1, &ns, sizeof(zend_namespace *), NULL);
        free(lowercase_name);
 

diff --git a/Zend/zend_builtin_functions.c b/Zend/zend_builtin_functions.c
index b458724815adc1e5e327fd8d02cefa2d925bf750..e8b29b0a88b238c3973f9486e7b3b6ba401361c6 100644 (file)
--- a/Zend/zend_builtin_functions.c
+++ b/Zend/zend_builtin_functions.c
@@ -615,8 +615,7 @@ static void is_a_impl(INTERNAL_FUNCTION_PARAMETERS, zend_bool only_subclass)
 
        convert_to_string_ex(class_name);
 
-       lcname = estrndup(Z_STRVAL_PP(class_name), Z_STRLEN_PP(class_name));
-       zend_str_tolower(lcname, Z_STRLEN_PP(class_name));
+       lcname = zend_str_tolower_dup(Z_STRVAL_PP(class_name), Z_STRLEN_PP(class_name));
 
        if (zend_lookup_ns_class(lcname, Z_STRLEN_PP(class_name), &ce TSRMLS_CC) == FAILURE) {
                efree(lcname);
@@ -673,8 +672,7 @@ ZEND_FUNCTION(get_class_vars)
        }
 
        convert_to_string_ex(class_name);
-       lcname = estrndup((*class_name)->value.str.val, (*class_name)->value.str.len);
-       zend_str_tolower(lcname, (*class_name)->value.str.len);
+       lcname = zend_str_tolower_dup((*class_name)->value.str.val, (*class_name)->value.str.len);
 
        if (zend_lookup_ns_class(lcname, Z_STRLEN_PP(class_name), &pce TSRMLS_CC) == FAILURE) {
                efree(lcname);
@@ -786,8 +784,7 @@ ZEND_FUNCTION(method_exists)
        }
 
        convert_to_string_ex(method_name);
-       lcname = estrndup((*method_name)->value.str.val, (*method_name)->value.str.len);
-       zend_str_tolower(lcname, (*method_name)->value.str.len);
+       lcname = zend_str_tolower_dup((*method_name)->value.str.val, (*method_name)->value.str.len);
        if (zend_hash_exists(&Z_OBJCE_PP(klass)->function_table, lcname, (*method_name)->value.str.len+1)) {
                efree(lcname);
                RETURN_TRUE;
@@ -808,8 +805,7 @@ static inline zend_namespace *get_namespace_from_zval(zval **namespace_name TSRM
                return EG(global_namespace_ptr);
        }
 
-       str_ns_name = estrndup(Z_STRVAL_PP(namespace_name), Z_STRLEN_PP(namespace_name));
-       zend_str_tolower(str_ns_name, Z_STRLEN_PP(namespace_name));
+       str_ns_name = zend_str_tolower_dup(Z_STRVAL_PP(namespace_name), Z_STRLEN_PP(namespace_name));
        if(zend_hash_find(&EG(global_namespace_ptr)->class_table, str_ns_name, Z_STRLEN_PP(namespace_name)+1, (void **)&pns) == FAILURE || !CLASS_IS_NAMESPACE((*pns))) {
                zend_error(E_WARNING, "Namespace '%s' is not defined!", Z_STRVAL_PP(namespace_name));
                efree(str_ns_name);
@@ -833,8 +829,7 @@ ZEND_FUNCTION(class_exists)
        }
 
        convert_to_string_ex(class_name);
-       lcname = estrndup((*class_name)->value.str.val, (*class_name)->value.str.len);
-       zend_str_tolower(lcname, (*class_name)->value.str.len);
+       lcname = zend_str_tolower_dup((*class_name)->value.str.val, (*class_name)->value.str.len);
        if (zend_lookup_ns_class(lcname, Z_STRLEN_PP(class_name), &ce TSRMLS_CC) == SUCCESS) {
                efree(lcname);
                RETURN_TRUE;
@@ -859,8 +854,7 @@ ZEND_FUNCTION(function_exists)
                ZEND_WRONG_PARAM_COUNT();
        }
        convert_to_string_ex(function_name);
-       lcname = estrndup((*function_name)->value.str.val, (*function_name)->value.str.len);
-       zend_str_tolower(lcname, (*function_name)->value.str.len);
+       lcname = zend_str_tolower_dup((*function_name)->value.str.val, (*function_name)->value.str.len);
 
        func_name_end = lcname + (*function_name)->value.str.len;
        if((func_name = zend_memnstr(lcname, "::", sizeof("::")-1, func_name_end)) == NULL) {

diff --git a/Zend/zend_constants.c b/Zend/zend_constants.c
index 826e6071faf34f8d7b23902ecb9012dab2aef7b5..f81eaceb68d01bfbce210f41e86c7a78249f3602 100644 (file)
--- a/Zend/zend_constants.c
+++ b/Zend/zend_constants.c
@@ -214,8 +214,7 @@ ZEND_API int zend_get_constant(char *name, uint name_len, zval *result TSRMLS_DC
 
        if (zend_hash_find(EG(zend_constants), name, name_len+1, (void **) &c) == FAILURE) {
                lookup_name = do_alloca(name_len+1);
-               memcpy(lookup_name, name, name_len+1);
-               zend_str_tolower(lookup_name, name_len);
+               zend_str_tolower_copy(lookup_name, name, name_len);
 
                if (zend_hash_find(EG(zend_constants), lookup_name, name_len+1, (void **) &c)==SUCCESS) {
                        if ((c->flags & CONST_CS) && memcmp(c->name, name, name_len)!=0) {
@@ -245,13 +244,14 @@ ZEND_API int zend_register_constant(zend_constant *c TSRMLS_DC)
        printf("Registering constant for module %d\n", c->module_number);
 #endif
 
-       lowercase_name = do_alloca(c->name_len);
-
-       memcpy(lowercase_name, c->name, c->name_len);
+       lowercase_name = do_alloca(c->name_len + 1);
 
        if (!(c->flags & CONST_CS)) {
-               zend_str_tolower(lowercase_name, c->name_len);
-       }       
+               zend_str_tolower_copy(lowercase_name, c->name, c->name_len);
+       } else {
+               memcpy(lowercase_name, c->name, c->name_len);
+               lowercase_name[c->name_len] = '\0';
+       }
 
        if (zend_hash_add(EG(zend_constants), lowercase_name, c->name_len, (void *) c, sizeof(zend_constant), NULL)==FAILURE) {
                free(c->name);

diff --git a/Zend/zend_object_handlers.c b/Zend/zend_object_handlers.c
index 759967bec551ad957925d9c3fd3d943699583573..1932d8c8d34a8cb9699e49888fcc79933d2b3d94 100644 (file)
--- a/Zend/zend_object_handlers.c
+++ b/Zend/zend_object_handlers.c
@@ -550,8 +550,7 @@ static union _zend_function *zend_std_get_method(zval *object, char *method_name
        
        lc_method_name = do_alloca(method_len+1);
        /* Create a zend_copy_str_tolower(dest, src, src_length); */
-       memcpy(lc_method_name, method_name, method_len+1);
-       zend_str_tolower(lc_method_name, method_len);
+       zend_str_tolower_copy(lc_method_name, method_name, method_len);
                
        zobj = Z_OBJ_P(object);
        if (zend_hash_find(&zobj->ce->function_table, lc_method_name, method_len+1, (void **)&fbc) == FAILURE) {