fix(explode): allocate the needed size only 🐛

Author: 0xwal

src/explode.c

@@ -3,62 +3,61 @@
 //
 
 #include "include/explode.h"
+#include "common.h"
 #include <stdlib.h>
 
-
-void copy(char* dist, const char* source, size_t length) {
-    for (int i = 0; i < length; ++i)
-    {
-        dist[i] = source[i];
-    }
+void copy(char *dist, const char *source, size_t length) {
+  for (int i = 0; i < length; ++i) {
+    dist[i] = source[i];
+  }
 }
 
-explode_s explode_make(const char* text, char character)
-{
-    explode_s e;
-
-    e.count = 0;
-    //temp
-    e.values = malloc(sizeof(char*) * 50);
-
-    const char* textPointer = text;
-    const char* chunkStart = text;
-    size_t i = 0;
-
-    while (*textPointer != '\0')
-    {
-        if (*textPointer == character)
-        {
-            size_t chunkLength = textPointer - chunkStart;
-            e.values[i] = malloc(chunkLength + 1);
-            copy(e.values[i], chunkStart, chunkLength);
-            e.values[i][chunkLength] = 0;
-            chunkStart = textPointer + 1;
-            e.count++;
-            i++;
-        }
-        textPointer++;
-    }
+char **_extend_values(char **values_pointer, size_t size) {
+  // if (values_pointer == NULL) {
+  //   return malloc(values_pointer);
+  // }
+  return realloc(values_pointer, sizeof(char *) * size);
+}
 
-    if (i > 0) {
-        size_t chunkLength = textPointer - chunkStart;
-        e.values[i] = malloc(chunkLength + 1);
-        copy(e.values[i], chunkStart, chunkLength);
-        e.values[i][chunkLength] = 0;
-        e.count++;
+explode_s explode_make(const char *text, char character) {
+  explode_s e = {0};
+
+  e.count = 0;
+
+  const char *textPointer = text;
+  const char *chunkStart = text;
+  size_t i = 0;
+
+  while (*textPointer != '\0') {
+    if (*textPointer == character) {
+      size_t chunkLength = textPointer - chunkStart;
+      char *spaceForOccurance = malloc(NSIZE(chunkLength));
+      e.values = _extend_values(e.values, e.count + 1);
+      e.values[i] = spaceForOccurance;
+      copy(e.values[i], chunkStart, chunkLength);
+      e.values[i][chunkLength] = 0;
+      chunkStart = textPointer + 1;
+      e.count++;
+      i++;
     }
-
-
-
-    return e;
+    textPointer++;
+  }
+
+  if (i > 0) {
+    size_t chunkLength = textPointer - chunkStart;
+    e.values = _extend_values(e.values, e.count + 1);
+    e.values[i] = malloc(NSIZE(chunkLength));
+    copy(e.values[i], chunkStart, chunkLength);
+    e.values[i][chunkLength] = 0;
+    e.count++;
+  }
+
+  return e;
 }
 
-
-void explode_clean(explode_s* exp)
-{
-    for (int i = 0; i < exp->count; ++i)
-    {
-        free(exp->values[i]);
-    }
-    free(exp->values);
+void explode_clean(explode_s *exp) {
+  for (int i = 0; i < exp->count; ++i) {
+    free(exp->values[i]);
+  }
+  free(exp->values);
 }

src/include/common.h

@@ -1,15 +1,17 @@
 #ifndef COMMON_H
 #define COMMON_H
-#include <stddef.h>
 #include <stdbool.h>
+#include <stddef.h>
 #include <stdint.h>
 
+#define NSIZE(s) (s + 1)
+
 #if defined(__cplusplus)
-#define BEGIN_DECL   extern "C" {
-#define END_DECL     }
+#define BEGIN_DECL extern "C" {
+#define END_DECL }
 #else
 #define BEGIN_DECL
 #define END_DECL
 #endif
 
-#endif //COMMON_H
+#endif // COMMON_H

src/include/explode.h

@@ -7,18 +7,16 @@
 
 #include "common.h"
 
-typedef struct
-{
-    char** values;
-    size_t count;
+typedef struct {
+  char **values;
+  size_t count;
 } explode_s;
 
-
 BEGIN_DECL
 
-explode_s explode_make(const char* text, char character);
-void explode_clean(explode_s* exp);
+explode_s explode_make(const char *text, char character);
+void explode_clean(explode_s *exp);
 
 END_DECL
 
-#endif //EXPLODE_H
+#endif // EXPLODE_H

tests/explode.test.cpp

@@ -5,27 +5,40 @@
 #include <catch2/catch.hpp>
 #include <explode.h>
 
-TEST_CASE("explode")
-{
-    SECTION("should returns ->count of exploded elements")
-    {
-        auto r = explode_make("Hello-World", '-');
-        REQUIRE(r.count == 2);
-        explode_clean(&r);
-    }
+using Catch::Matchers::Equals;
 
-    SECTION("should returns ->count as 0 when character is not found")
-    {
-        auto r = explode_make("Hello-World", '*');
-        REQUIRE(r.count == 0);
-        explode_clean(&r);
-    }
+TEST_CASE("explode") {
+  SECTION("should returns ->count of exploded elements") {
+    auto r = explode_make("Hello-World", '-');
+    REQUIRE(r.count == 2);
+    explode_clean(&r);
+  }
 
-    SECTION("should returns ->values as char** for each value between the character")
-    {
-        auto r = explode_make("Hello-World", '-');
-        REQUIRE_THAT(r.values[0], Catch::Equals("Hello"));
-        REQUIRE_THAT(r.values[1], Catch::Equals("World"));
-        explode_clean(&r);
-    }
+  SECTION("should returns ->values with all content") {
+    auto r = explode_make("This is a text for a test", ' ');
+    REQUIRE(r.count == 7);
+    REQUIRE_THAT(r.values[0], Equals("This"));
+    REQUIRE_THAT(r.values[1], Equals("is"));
+    REQUIRE_THAT(r.values[2], Equals("a"));
+    REQUIRE_THAT(r.values[3], Equals("text"));
+    REQUIRE_THAT(r.values[4], Equals("for"));
+    REQUIRE_THAT(r.values[5], Equals("a"));
+    REQUIRE_THAT(r.values[6], Equals("test"));
+    REQUIRE(r.values[7] == NULL);
+    explode_clean(&r);
+  }
+
+  SECTION("should returns ->count as 0 when character is not found") {
+    auto r = explode_make("Hello-World", '*');
+    REQUIRE(r.count == 0);
+    explode_clean(&r);
+  }
+
+  SECTION("should returns ->values as char** for each value between the "
+          "character") {
+    auto r = explode_make("Hello-World", '-');
+    REQUIRE_THAT(r.values[0], Catch::Equals("Hello"));
+    REQUIRE_THAT(r.values[1], Catch::Equals("World"));
+    explode_clean(&r);
+  }
 }