base_strings.h

Go to the documentation of this file.

 
#ifndef BASE_STRINGS_H
#define BASE_STRINGS_H
 
#include "base_macros.h"
#include "base_types.h"
#include <ctype.h>
#include <string.h>
 
C_LINKAGE_BEGIN


typedef struct String8 {
    u8   *str;  
    usize size; 
} String8;

typedef struct String8Node {
    struct String8Node *next;   
    String8         string; 
} String8Node;

typedef struct String8List {
    String8Node *first;  
    String8Node *last;   
    usize        node_count; 
    usize        total_size; 
} String8List;



#if defined(COMPILER_CLANG) || defined(COMPILER_GCC)
// #    define STR8(s)                                                                            \
//      (_Static_assert(__builtin_constant_p(s), "STR8: pass a string literal only"),      \
//       (String8){.str = (u8 *)(s), .size = sizeof(s) - 1})
#   define STR8(s) ((String8){.str = (u8 *)(s), .size = sizeof(s) - 1})
#else
#   define STR8(s) ((String8){.str = (u8 *)(s), .size = sizeof(s) - 1})
#endif

#define STR8_FMT(s) (int)(s).size, (char *)(s).str



function inline String8
str8(u8 *str, usize size)
{
    String8 result = {str, size};
    return result;
}

function inline String8
str8_range(u8 *first, u8 *one_past_last)
{
    String8 result = {first, (usize)(one_past_last - first)};
    return result;
}

function inline String8
str8_cstr(const char *cstr)
{
    if (cstr == NULL) return (String8){0};
    return str8((u8 *)cstr, strlen(cstr));
}

function inline String8
str8_prefix(String8 str, usize size)
{
    usize clamped_size = MIN(size, str.size);
    return str8(str.str, clamped_size);
}

function inline String8
str8_suffix(String8 str, usize size)
{
    usize clamped_size = MIN(size, str.size);
    return str8(str.str + (str.size - clamped_size), clamped_size);
}

function inline String8
str8_skip(String8 str, usize amt)
{
    usize clamped_amt = MIN(amt, str.size);
    return str8(str.str + clamped_amt, str.size - clamped_amt);
}

function inline String8
str8_chop(String8 str, usize amt)
{
    usize clamped_amt = MIN(amt, str.size);
    return str8(str.str, str.size - clamped_amt);
}

function inline String8
str8_substr(String8 str, usize first, usize one_past_last)
{
    usize clamped_first = MIN(first, str.size);
    usize clamped_opl   = MIN(one_past_last, str.size);
    if (clamped_opl < clamped_first) clamped_opl = clamped_first;
    return str8(str.str + clamped_first, clamped_opl - clamped_first);
}

function inline b32
str8_match(String8 a, String8 b)
{
    if (a.size != b.size) {
        return 0;
    }
    return (a.size == 0) || (memcmp(a.str, b.str, a.size) == 0);
}

function inline b32
str8_match_nocase(String8 a, String8 b)
{
    if (a.size != b.size) {
        return 0;
    }
    for (usize i = 0; i < a.size; i += 1) {
        if (tolower(a.str[i]) != tolower(b.str[i])) {
            return 0;
        }
    }
    return 1;
}

function inline b32
str8_starts_with(String8 str, String8 prefix)
{
    if (prefix.size > str.size) {
        return 0;
    }
    return str8_match(str8_prefix(str, prefix.size), prefix);
}

function inline b32
str8_ends_with(String8 str, String8 suffix)
{
    if (suffix.size > str.size) {
        return 0;
    }
    return str8_match(str8_suffix(str, suffix.size), suffix);
}

function inline usize
str8_find_first(String8 str, u8 byte)
{
    for (usize i = 0; i < str.size; i += 1) {
        if (str.str[i] == byte) {
            return i;
        }
    }
    return str.size;
}

function inline void
str8_list_push(String8List *list, String8Node *node, String8 str)
{
    node->string = str;
    node->next   = NULL;
    if (list->last != NULL) {
        list->last->next = node;
    } else {
        list->first = node;
    }
    list->last = node;
    list->node_count += 1;
    list->total_size += str.size;
}

 
C_LINKAGE_END
 
#endif // BASE_STRINGS_H