r/string.c at dc150f2ea2e73552203963d9f0decebeea42abdd

 // retoor <retoor@molodetz.nl>
 #include "string.h"
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 struct string_t {
     char *data;
     size_t length;
     size_t capacity;
 };
 static const size_t DEFAULT_CAPACITY = 32;
 string_handle string_create(const char *str) {
     if (!str) return string_create_empty();
     return string_create_n(str, strlen(str));
 }
 string_handle string_create_empty(void) {
     struct string_t *s = calloc(1, sizeof(struct string_t));
     if (!s) return NULL;
     s->data = malloc(DEFAULT_CAPACITY);
     if (!s->data) {
         free(s);
         return NULL;
     }
     s->data[0] = '\0';
     s->length = 0;
     s->capacity = DEFAULT_CAPACITY;
     return s;
 }
 string_handle string_create_n(const char *str, size_t len) {
     if (!str) return string_create_empty();
     if (len == 0) return string_create_empty();
     struct string_t *s = malloc(sizeof(struct string_t));
     if (!s) return NULL;
     s->capacity = len + 1;
     if (s->capacity < DEFAULT_CAPACITY) s->capacity = DEFAULT_CAPACITY;
     s->data = malloc(s->capacity);
     if (!s->data) {
         free(s);
         return NULL;
     }
     memcpy(s->data, str, len);
     s->data[len] = '\0';
     s->length = len;
     return s;
 }
 string_handle string_format(const char *fmt, ...) {
     if (!fmt) return string_create_empty();
     va_list args, args_copy;
     va_start(args, fmt);
     va_copy(args_copy, args);
     int len = vsnprintf(NULL, 0, fmt, args_copy);
     va_end(args_copy);
     if (len < 0) {
         va_end(args);
         return string_create_empty();
     }
     struct string_t *s = malloc(sizeof(struct string_t));
     if (!s) {
         va_end(args);
         return NULL;
     }
     s->capacity = (size_t)len + 1;
     s->data = malloc(s->capacity);
     if (!s->data) {
         free(s);
         va_end(args);
         return NULL;
     }
     vsnprintf(s->data, s->capacity, fmt, args);
     s->length = (size_t)len;
     va_end(args);
     return s;
 }
 string_handle string_clone(const char *str) {
     return string_create(str);
 }
 string_handle string_clone_handle(string_handle s) {
     if (!s) return NULL;
     return string_create_n(s->data, s->length);
 }
 string_handle string_concat(const char *a, const char *b) {
     if (!a) return string_create(b);
     if (!b) return string_create(a);
     size_t len_a = strlen(a);
     size_t len_b = strlen(b);
     struct string_t *s = malloc(sizeof(struct string_t));
     if (!s) return NULL;
     s->length = len_a + len_b;
     s->capacity = s->length + 1;
     s->data = malloc(s->capacity);
     if (!s->data) {
         free(s);
         return NULL;
     }
     memcpy(s->data, a, len_a);
     memcpy(s->data + len_a, b, len_b);
     s->data[s->length] = '\0';
     return s;
 }
 string_handle string_concat_handle(string_handle a, const char *b) {
     if (!a) return string_create(b);
     if (!b) return string_clone_handle(a);
     size_t len_b = strlen(b);
     size_t new_len = a->length + len_b;
     if (new_len + 1 > a->capacity) {
         size_t new_capacity = a->capacity * 2;
         while (new_capacity < new_len + 1) new_capacity *= 2;
         char *new_data = realloc(a->data, new_capacity);
         if (!new_data) return NULL;
         a->data = new_data;
         a->capacity = new_capacity;
     }
     memcpy(a->data + a->length, b, len_b);
     a->length = new_len;
     a->data[a->length] = '\0';
     return a;
 }
 void string_append(string_handle s, const char *str) {
     if (!s || !str) return;
     string_append_n(s, str, strlen(str));
 }
 void string_append_n(string_handle s, const char *str, size_t len) {
     if (!s || !str || len == 0) return;
     if (s->length + len + 1 > s->capacity) {
         size_t new_capacity = s->capacity;
         while (new_capacity < s->length + len + 1) new_capacity *= 2;
         char *new_data = realloc(s->data, new_capacity);
         if (!new_data) return;
         s->data = new_data;
         s->capacity = new_capacity;
     }
     memcpy(s->data + s->length, str, len);
     s->length += len;
     s->data[s->length] = '\0';
 }
 void string_appendf(string_handle s, const char *fmt, ...) {
     if (!s || !fmt) return;
     va_list args;
     va_start(args, fmt);
     int len = vsnprintf(NULL, 0, fmt, args);
     va_end(args);
     if (len < 0) return;
     if (s->length + (size_t)len + 1 > s->capacity) {
         size_t new_capacity = s->capacity;
         while (new_capacity < s->length + (size_t)len + 1) new_capacity *= 2;
         char *new_data = realloc(s->data, new_capacity);
         if (!new_data) return;
         s->data = new_data;
         s->capacity = new_capacity;
     }
     va_start(args, fmt);
     vsnprintf(s->data + s->length, s->capacity - s->length, fmt, args);
     s->length += (size_t)len;
     va_end(args);
 }
 void string_append_handle(string_handle dest, string_handle src) {
     if (!dest || !src) return;
     string_append_n(dest, src->data, src->length);
 }
 size_t string_length(string_handle s) {
     return s ? s->length : 0;
 }
 size_t string_capacity(string_handle s) {
     return s ? s->capacity : 0;
 }
 const char *string_c_str(string_handle s) {
     return s ? s->data : "";
 }
 char *string_release(string_handle s) {
     if (!s) return NULL;
     char *data = s->data;
     free(s);
     return data;
 }
 bool string_equals(string_handle a, string_handle b) {
     if (!a && !b) return true;
     if (!a || !b) return false;
     if (a->length != b->length) return false;
     return memcmp(a->data, b->data, a->length) == 0;
 }
 bool string_equals_c_str(string_handle s, const char *str) {
     if (!s && !str) return true;
     if (!s || !str) return false;
     return strcmp(s->data, str) == 0;
 }
 bool string_is_empty(string_handle s) {
     return !s || s->length == 0;
 }
 void string_clear(string_handle s) {
     if (!s) return;
     s->length = 0;
     if (s->data) s->data[0] = '\0';
 }
 void string_destroy(string_handle s) {
     if (!s) return;
     if (s->data) free(s->data);
     free(s);
 }