Update: use *_size_increase() functions, improve logic, and return F_string_too_large.

Use the *_size_increase() functions more.

Anything declared inside of a loop is destroyed at the end of the loop and created at the beginning.
This is an easily avoidable performance concern.

When the max size is reached but allocation is still possible (but at a smaller than requested length) return F_string_too_large without the error bit set.
This is useful for when only 1 unit is needed but the resize is say 4.
In the cases where the resize must exactly match the given length, then treat F_string_too_large without the error bit as if it does have an error bit.

diff --git a/level_1/fl_string/c/private-string.c b/level_1/fl_string/c/private-string.c
index 9779f3aaf388e65319143cf7abf27764873757b1..27a4b9ae37e9e385d1e84b4ca437db5c2013a57a 100644 (file)
--- a/level_1/fl_string/c/private-string.c
+++ b/level_1/fl_string/c/private-string.c
@@ -8,19 +8,15 @@ extern "C" {
 #if !defined(_di_fl_string_append_) || !defined(_di_fl_string_dynamic_append_) || !defined(_di_fl_string_append_mash_) || !defined(_di_fl_string_dynamic_mash_)
   f_return_status private_fl_string_append(const f_string_t source, const f_string_length_t length, f_string_dynamic_t *destination) {
 
-    if (destination->used + length > f_string_length_t_size) return F_status_set_error(F_string_too_large);
-
     f_status_t status = F_none;
 
-    const f_string_length_t total = destination->used + length;
-
-    if (total > destination->size) {
-      f_macro_string_dynamic_t_resize(status, (*destination), total);
+    if (destination->used + length > destination->size) {
+      status = private_fl_string_dynamic_size_increase(length, destination);
       if (F_status_is_error(status)) return status;
     }
 
     memcpy(destination->string + destination->used, source, length);
-    destination->used = total;
+    destination->used = destination->used + length;
 
     return F_none;
   }
@@ -34,23 +30,21 @@ extern "C" {
     f_status_t status = F_none;
 
     f_string_length_t first = 0;
+    f_string_length_t size = 0;
 
     for (f_string_length_t i = 0; i <= length; i++) {
+
       if (i == length) {
         if (i > first) {
-          f_string_length_t size = i - first;
+          size = i - first;
 
-          if (destination->used + size > f_string_length_t_size) return F_status_set_error(F_string_too_large);
-
-          f_string_length_t total = destination->used + size;
-
-          if (total > destination->size) {
-            f_macro_string_dynamic_t_resize(status, (*destination), total);
+          if (destination->used + size > destination->size) {
+            status = private_fl_string_dynamic_size_increase(size, destination);
             if (F_status_is_error(status)) return status;
           }
 
           memcpy(destination->string + destination->used, source + first, size);
-          destination->used = total;
+          destination->used = destination->used + size;
         }
 
         break;
@@ -59,19 +53,15 @@ extern "C" {
       if (source[i] == 0) {
         if (i > 0) {
           if (i > first) {
-            f_string_length_t size = i - first;
-
-            if (destination->used + size > f_string_length_t_size) return F_status_set_error(F_string_too_large);
+            size = i - first;
 
-            f_string_length_t total = destination->used + size;
-
-            if (total > destination->size) {
-              f_macro_string_dynamic_t_resize(status, (*destination), total);
+            if (destination->used + size > destination->size) {
+              status = private_fl_string_dynamic_size_increase(size, destination);
               if (F_status_is_error(status)) return status;
             }
 
             memcpy(destination->string + destination->used, source + first, size);
-            destination->used = total;
+            destination->used = destination->used + size;
           }
         }
 
@@ -135,6 +125,7 @@ extern "C" {
 
       width_max = (stop1 - i1) + 1;
       status = f_utf_is_whitespace(string1 + i1, width_max);
+
       if (F_status_is_error(status)) {
         if (F_status_set_fine(status) == F_maybe) return F_status_set_error(F_utf);
 
@@ -154,6 +145,7 @@ extern "C" {
 
       width_max = (stop2 - i2) + 1;
       status = f_utf_is_whitespace(string2 + i2, width_max);
+
       if (F_status_is_error(status)) {
         if (F_status_set_fine(status) == F_maybe) return F_status_set_error(F_utf);
 
@@ -203,6 +195,7 @@ extern "C" {
 
         width_max = (stop2 - j) + 1;
         status = f_utf_is_whitespace(string2 + j, width_max);
+
         if (F_status_is_error(status)) {
           if (F_status_set_fine(status) == F_maybe) return F_status_set_error(F_utf);
 
@@ -247,6 +240,24 @@ extern "C" {
   }
 #endif // !defined(_di_fl_string_compare_trim_) || !defined(_di_fl_string_dynamic_compare_trim_) || !defined(_di_fl_string_dynamic_partial_compare_trim_)
 
+#if !defined(_di_fl_string_dynamic_size_increase_) || !defined(_di_fl_string_append_) || !defined(_di_fl_string_dynamic_append_) || !defined(_di_fl_string_append_mash_) || !defined(_di_fl_string_dynamic_mash_) || !defined(_di_fl_string_append_nulless_) || !defined(_di_fl_string_dynamic_append_nulless_) || !defined(_di_fl_string_mash_nulless_) || !defined(_di_fl_string_dynamic_mash_nulless_) || !defined(_di_fl_string_prepend_) || !defined(_di_fl_string_dynamic_prepend_) || !defined(_di_fl_string_prepend_nulless_) || !defined(_di_fl_string_dynamic_prepend_nulless_)
+  f_return_status private_fl_string_dynamic_size_increase(const f_string_length_t length, f_string_dynamic_t *string) {
+    f_status_t status = F_none;
+
+    if (string->size + length > f_string_length_t_size) {
+      if (string->size == f_string_length_t_size) {
+        return F_status_set_error(F_string_too_large);
+      }
+
+      f_macro_string_dynamic_t_resize(status, (*string), f_string_length_t_size);
+      return F_string_too_large;
+    }
+
+    f_macro_string_dynamic_t_resize(status, (*string), string->size + length);
+    return status;
+  }
+#endif // !defined(_di_fl_string_dynamic_size_increase_) || !defined(_di_fl_string_append_) || !defined(_di_fl_string_dynamic_append_) || !defined(_di_fl_string_append_mash_) || !defined(_di_fl_string_dynamic_mash_) || !defined(_di_fl_string_append_nulless_) || !defined(_di_fl_string_dynamic_append_nulless_) || !defined(_di_fl_string_mash_nulless_) || !defined(_di_fl_string_dynamic_mash_nulless_) || !defined(_di_fl_string_prepend_) || !defined(_di_fl_string_dynamic_prepend_) || !defined(_di_fl_string_prepend_nulless_) || !defined(_di_fl_string_dynamic_prepend_nulless_)
+
 #if !defined(_di_fl_string_prepend_) || !defined(_di_fl_string_dynamic_prepend_) || !defined(_di_fl_string_append_mish_) || !defined(_di_fl_string_dynamic_mish_)
   f_return_status private_fl_string_prepend(const f_string_t source, const f_string_length_t length, f_string_dynamic_t *destination) {
 
@@ -256,14 +267,12 @@ extern "C" {
 
     f_status_t status = F_none;
 
-    const f_string_length_t total = destination->used + length;
-
-    if (total > destination->size) {
-      f_macro_string_dynamic_t_resize(status, (*destination), total);
+    if (destination->used + length > destination->size) {
+      status = private_fl_string_dynamic_size_increase(length, destination);
       if (F_status_is_error(status)) return status;
     }
 
-    if (destination->used > 0) {
+    if (destination->used) {
       memmove(destination->string + length, destination->string, destination->used);
       memcpy(destination->string, source, length);
     }
@@ -271,7 +280,7 @@ extern "C" {
       memcpy(destination->string, source, length);
     }
 
-    destination->used = total;
+    destination->used = destination->used + length;
     return F_none;
   }
 #endif // !defined(_di_fl_string_prepend_) || !defined(_di_fl_string_dynamic_prepend_)
@@ -288,26 +297,22 @@ extern "C" {
     f_string_length_t first = 0;
     f_string_length_t offset = 0;
 
+    f_string_length_t size = 0;
+
     for (f_string_length_t i = 0; i <= length; i++) {
       if (i == length) {
         if (i > first) {
-          const f_string_length_t size = i - first;
+          size = i - first;
 
-          if (destination->used + size > f_string_length_t_size) {
-            return F_status_set_error(F_string_too_large);
-          }
-
-          const f_string_length_t total = destination->used + size;
-
-          if (total > destination->size) {
-            f_macro_string_dynamic_t_resize(status, (*destination), total);
+          if (destination->used + size > destination->size) {
+            status = private_fl_string_dynamic_size_increase(size, destination);
             if (F_status_is_error(status)) return status;
           }
 
           memmove(destination->string + offset + size, destination->string + offset, destination->used - offset);
           memcpy(destination->string + offset, source + first, size);
 
-          destination->used = total;
+          destination->used = destination->used + size;
           offset += size;
         }
 
@@ -317,24 +322,17 @@ extern "C" {
       if (source[i] == 0) {
         if (i > 0) {
           if (i > first) {
-            const f_string_length_t size = i - first;
-
-            if (destination->used + size > f_string_length_t_size) {
-              return F_status_set_error(F_string_too_large);
-            }
-
-            const f_string_length_t total = destination->used + size;
-
-            if (total > destination->size) {
-              f_macro_string_dynamic_t_resize(status, (*destination), total);
+            size = i - first;
 
+            if (destination->used + size > destination->size) {
+              status = private_fl_string_dynamic_size_increase(size, destination);
               if (F_status_is_error(status)) return status;
             }
 
             memmove(destination->string + offset + size, destination->string + offset, destination->used - offset);
             memcpy(destination->string + offset, source + first, size);
 
-            destination->used = total;
+            destination->used = destination->used + size;
             offset += size;
           }
         }

diff --git a/level_1/fl_string/c/private-string.h b/level_1/fl_string/c/private-string.h
index 0739ac3a623de821d07c9323845bc1af501516dd..d7a90d1c40af099f201fbe449c807def8055cc63 100644 (file)
--- a/level_1/fl_string/c/private-string.h
+++ b/level_1/fl_string/c/private-string.h
@@ -138,6 +138,28 @@ extern "C" {
 #endif // !defined(_di_fl_string_compare_trim_) || !defined(_di_fl_string_dynamic_compare_trim_) || !defined(_di_fl_string_dynamic_partial_compare_trim_)
 
 /**
+ * Private implementation of fl_string_dynamic_size_increase().
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param length
+ *   A positive number greater than 0 representing how much to increase the size by.
+ * @param string
+ *   The string to resize.
+ *
+ * @return
+ *   F_none on success.
+ *   F_string_too_large on success, but requested size is too small (resize is smaller than requested length).
+ *   F_memory_allocation (with error bit) on memory allocation error.
+ *   F_memory_reallocation (with error bit) on memory reallocation error.
+ *   F_parameter (with error bit) if a parameter is invalid.
+ *   F_string_too_large (with error bit) if the combined string is too large.
+ */
+#if !defined(_di_fl_string_dynamic_size_increase_) || !defined(_di_fl_string_append_) || !defined(_di_fl_string_dynamic_append_) || !defined(_di_fl_string_append_mash_) || !defined(_di_fl_string_dynamic_mash_) || !defined(_di_fl_string_append_nulless_) || !defined(_di_fl_string_dynamic_append_nulless_) || !defined(_di_fl_string_mash_nulless_) || !defined(_di_fl_string_dynamic_mash_nulless_) || !defined(_di_fl_string_prepend_) || !defined(_di_fl_string_dynamic_prepend_) || !defined(_di_fl_string_prepend_nulless_) || !defined(_di_fl_string_dynamic_prepend_nulless_)
+  extern f_return_status private_fl_string_dynamic_size_increase(const f_string_length_t length, f_string_dynamic_t *string) f_gcc_attribute_visibility_internal;
+#endif // !defined(_di_fl_string_dynamic_size_increase_) || !defined(_di_fl_string_append_) || !defined(_di_fl_string_dynamic_append_) || !defined(_di_fl_string_append_mash_) || !defined(_di_fl_string_dynamic_mash_) || !defined(_di_fl_string_append_nulless_) || !defined(_di_fl_string_dynamic_append_nulless_) || !defined(_di_fl_string_mash_nulless_) || !defined(_di_fl_string_dynamic_mash_nulless_) || !defined(_di_fl_string_prepend_) || !defined(_di_fl_string_dynamic_prepend_) || !defined(_di_fl_string_prepend_nulless_) || !defined(_di_fl_string_dynamic_prepend_nulless_)
+
+/**
  * Private implementation of fl_string_prepend().
  *
  * Intended to be shared to each of the different implementation variations.

diff --git a/level_1/fl_string/c/string.c b/level_1/fl_string/c/string.c
index db525437693b545dd3192b7eec15c2bd65a5b484..8ebb363c79f8d38bd2386d235d35bfae21d12f11 100644 (file)
--- a/level_1/fl_string/c/string.c
+++ b/level_1/fl_string/c/string.c
@@ -773,10 +773,10 @@ extern "C" {
 
     f_status_t status = F_none;
 
-    if (string->used - length > 0) {
+    if (string->size - length > 0) {
       f_macro_string_dynamic_t_resize(status, (*string), string->size - length);
     }
-    else if (string->used - length <= 0) {
+    else if (string->size - length <= 0) {
       f_macro_string_dynamic_t_delete(status, (*string));
     }
 
@@ -791,23 +791,7 @@ extern "C" {
       if (string == 0) return F_status_set_error(F_parameter);
     #endif // _di_level_1_parameter_checking_
 
-    f_status_t status = F_none;
-
-    if (string->used + length > string->size) {
-      if (string->used + length > f_string_length_t_size) {
-        if (string->used == f_string_length_t_size) {
-          status = F_status_set_error(F_string_too_large);
-        }
-        else {
-          f_macro_string_dynamic_t_resize(status, (*string), f_string_length_t_size);
-        }
-      }
-      else {
-        f_macro_string_dynamic_t_resize(status, (*string), string->size + length);
-      }
-    }
-
-    return status;
+    return private_fl_string_dynamic_size_increase(length, string);
   }
 #endif // _di_fl_string_dynamic_size_increase_
 
@@ -820,10 +804,10 @@ extern "C" {
 
     f_status_t status = F_none;
 
-    if (strings->used - length > 0) {
+    if (strings->size - length > 0) {
       f_macro_string_dynamics_resize(status, (*strings), strings->size - length);
     }
-    else if (strings->used - length <= 0) {
+    else if (strings->size - length <= 0) {
       f_macro_string_dynamics_t_delete(status, (*strings));
     }
 
@@ -840,20 +824,16 @@ extern "C" {
 
     f_status_t status = F_none;
 
-    if (strings->used + length > strings->size) {
-      if (strings->used + length > f_array_length_t_size) {
-        if (strings->used == f_array_length_t_size) {
-          status = F_status_set_error(F_string_too_large);
-        }
-        else {
-          f_macro_string_dynamics_resize(status, (*strings), f_array_length_t_size);
-        }
-      }
-      else {
-        f_macro_string_dynamics_resize(status, (*strings), strings->size + length);
+    if (strings->size + length > f_array_length_t_size) {
+      if (strings->size == f_array_length_t_size) {
+        return F_status_set_error(F_string_too_large);
       }
+
+      f_macro_string_dynamics_resize(status, (*strings), f_array_length_t_size);
+      return F_string_too_large;
     }
 
+    f_macro_string_dynamics_resize(status, (*strings), strings->size + length);
     return status;
   }
 #endif // _di_fl_string_dynamics_size_increase_

diff --git a/level_1/fl_string/c/string.h b/level_1/fl_string/c/string.h
index f6bececc8ce88bafb26ddeab175f38aa349731f3..066574a86b291cd0b453011f0b6ff44dbadf1e3a 100644 (file)
--- a/level_1/fl_string/c/string.h
+++ b/level_1/fl_string/c/string.h
@@ -1093,6 +1093,7 @@ extern "C" {
  *
  * @return
  *   F_none on success.
+ *   F_string_too_large on success, but the requested length is too large for the buffer.
  *   F_memory_allocation (with error bit) on memory allocation error.
  *   F_memory_reallocation (with error bit) on memory reallocation error.
  *   F_parameter (with error bit) if a parameter is invalid.
@@ -1139,6 +1140,7 @@ extern "C" {
  *
  * @return
  *   F_none on success.
+ *   F_string_too_large on success, but the requested length is too large for the buffer.
  *   F_memory_allocation (with error bit) on memory allocation error.
  *   F_memory_reallocation (with error bit) on memory reallocation error.
  *   F_parameter (with error bit) if a parameter is invalid.

diff --git a/level_3/fake/c/private-make.c b/level_3/fake/c/private-make.c
index 3e6a9cd0f716bf324497cb57bca8fd18a9ff1310..f72eac64cfcb3533a626b35e174ce3b9b30f964f 100644 (file)
--- a/level_3/fake/c/private-make.c
+++ b/level_3/fake/c/private-make.c
@@ -1131,15 +1131,10 @@ extern "C" {
 
     // pre-allocate the known arguments size.
     if (arguments->used + content.used > arguments->size) {
-      if (arguments->used + content.used > F_buffer_too_large) {
-        *status = F_status_set_error(F_buffer_too_large);
-      }
-      else {
-        f_macro_string_dynamics_resize((*status), (*arguments), arguments->used + content.used);
-      }
+      *status = fl_string_dynamics_size_increase(content.used, arguments);
 
-      if (F_status_is_error(*status)) {
-        fake_print_message(data, F_status_set_fine(*status), "f_macro_string_dynamics_resize", F_true, data_make->print);
+      if (F_status_is_error(*status) || *status == F_string_too_large) {
+        fake_print_message(data, F_status_set_fine(*status), "fl_string_dynamics_size_increase", F_true, data_make->print);
         return;
       }
     }