cstring.h

#if !defined(CSTRING_H)
#define CSTRING_H

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <stdarg.h>

    struct string_t {

        char*                   data;
        size_t                  length;
        size_t                  capacity;

    };

    #define                     empty_string                (struct string_t){NULL,0,0}
    
    void                        string_drop                 (struct string_t* ptr);
    int                         string_resize               (struct string_t* ptr, size_t size);
    struct string_t             string_from_until           (char* src, size_t index); 
    struct string_t             string_from                 (char* src);
    struct string_t             string_from_section         (char* src, size_t start, size_t size); 
    struct string_t             string_from_format          (const char* fmt, ...);
    struct string_t             string_from_size            (size_t size);
    int                         string_append_n             (struct string_t* ptr, char* src, size_t size);
    int                         string_append               (struct string_t* ptr, char* src);
    int                         string_append_destroy       (struct string_t* ptr, struct string_t src);

    #define                     string_append_format(ptr, fmt, ...) \
        string_append_destroy(ptr, string_from_format(fmt, __VA_ARGS__))

#if defined(CSTRING_IMPLEMENTATION)

    void string_drop(struct string_t* ptr) {

        if (ptr != NULL) {
            free(ptr->data);
            *ptr = empty_string;
        }

    }

    int string_resize(struct string_t* ptr, size_t size) {

        if (size < 0) {
            printf("warning: please provide a valid size.\n");
            return -1;
        }

        char* temp = (char*)realloc(ptr->data, size);
        if (temp == NULL) {
            perror("malloc");
            return -1;
        }

        ptr->data = temp;
        ptr->capacity = size;

        return 0;

    }

    /* UNSAFE */ 
    struct string_t string_from_until(char* src, size_t index) {

        if (index < 0) {
            printf("warning: please provide a valid index.\n");
            return empty_string;
        }

        struct string_t result = empty_string;

        char* temp = (char*)malloc(index + 1);
        if (temp == NULL) {
            perror("malloc");
            return empty_string;
        }

        result.data = temp;
        memcpy(result.data, src, index);
        result.data[index] = '\0';
        
        result.length = index;
        result.capacity = index + 1;

        return result;

    }

    struct string_t string_from(char* src) {

        if (src == NULL) 
            return empty_string;

        size_t src_length = strlen(src);
        return string_from_until(src, src_length);

    }

    /* UNSAFE */ 
    struct string_t string_from_section(char* src, size_t start, size_t size) {

        if (src == NULL) 
            return empty_string;

        return string_from_until(src + start, size);
    
    }

    struct string_t string_from_format(const char* fmt, ...) {

        if (fmt == NULL)
            return empty_string;

        va_list args;
        struct string_t result = empty_string;

        va_start(args, fmt);
        int size = vsnprintf(result.data, result.length, fmt, args);
        va_end(args);

        if (size < 0) {
            perror("vsnprintf");
            return empty_string;
        }

        result.length = (size_t)size;
        result.capacity = result.length + 1;

        result.data = (char*)malloc(result.capacity);
        if (result.data == NULL) {
            perror("malloc");
            return empty_string;
        }

        va_start(args, fmt);
        size = vsnprintf(result.data, (result.length + 1), fmt, args);
        va_end(args);

        if (size < 0) {
            perror("vsnprintf");
            return empty_string;
        }

        return result;

    }

    struct string_t string_from_size(size_t size) {

        if (size < 0) {
            printf("warning: please provide a valid size.\n");
            return empty_string;
        }

        struct string_t result = empty_string;
        if (string_resize(&result, size) < 0)
            return empty_string;
        return result;

    }

    /* UNSAFE */ 
    int string_append_n(struct string_t* ptr, char* src, size_t size) {

        if (size < 0) {
            printf("warning: please provide a valid size.\n");
            return -1;
        }

        if ((ptr->length + size + 1) > ptr->capacity)
            string_resize(ptr, ptr->length + size + 1);

        char* buffer = (char*)malloc(ptr->length + 1);
        if (buffer == NULL) {
            perror("malloc");
            return -1;
        }
        memcpy(buffer, ptr->data, ptr->length + 1);

        int amnt = snprintf(ptr->data, ptr->length + size + 1, "%s%s", buffer, src);
        ptr->length = (ptr->length + size);

        return (amnt < 0) ? -1 : 0;

    } 

    int string_append(struct string_t* ptr, char* src) {

        return string_append_n(ptr, src, strlen(src));

    } 

    int string_append_destroy(struct string_t* ptr, struct string_t src) {

        if (string_append(ptr, src.data) < 0) {
            string_drop(&src);
            return -1;
        }
        
        string_drop(&src);
        return 0;

    }

#endif // CSTRING_IMPLEMENTATION
#endif // CSTRING_H