1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
|
#include "str.h"
#include "crash.h"
#include <stdlib.h>
#include <string.h>
#define CRASH_IF_OOB(str, len) {\
if (len > str.length)\
crash("String access out of bounds: %ld > %ld\n", len, str.length);\
}
static inline char* alloc_data_ptr(size_t length) {
char* data_ptr = malloc(length);
if (data_ptr == NULL)
crash("Out of memory allocating new string of length %ld\n", length);
return data_ptr;
}
static inline char* alloc_c_str(size_t length) {
char* c_str = malloc(length + 1);
if (c_str == NULL)
crash("Out of memory allocating C string buffer of size %ld", length + 1);
c_str[length] = 0;
return c_str;
}
char* str_at(const str_t str, size_t idx) {
CRASH_IF_OOB(str, idx + 1);
return str.__data + idx;
}
str_t str_slice(const str_t str, size_t start, size_t length) {
CRASH_IF_OOB(str, start + length);
str_t slice = {.length = length, .__data = str.__data + start};
return slice;
}
int str_cmp(const str_t s1, const str_t s2) {
if (s1.length == s2.length)
return memcmp(s1.__data, s2.__data, s1.length);
else if (s1.length > s2.length) {
int cmp = memcmp(s1.__data, s2.__data, s2.length);
if (cmp != 0) return cmp;
return 1;
} else {
int cmp = memcmp(s1.__data, s2.__data, s1.length);
if (cmp != 0) return cmp;
return -1;
}
}
ssize_t str_indexof(const str_t str, char c) {
for (ssize_t i = 0; i < str.length; i++) {
if (str.__data[i] == c) return i;
}
return -1;
}
ssize_t str_rindexof(const str_t str, char c) {
for (ssize_t i = (ssize_t)str.length - 1; i >= 0; i--) {
if (str.__data[i] == c) return i;
}
return -1;
}
str_t str_heap_dup(const str_t str) {
char* data_ptr = alloc_data_ptr(str.length);
str_t dup_str = {.length = str.length, .__data = data_ptr};
return dup_str;
}
str_t str_heap_cat(const str_t s1, const str_t s2) {
size_t new_len = s1.length + s2.length;
char* data_ptr = alloc_data_ptr(new_len);
str_t cat_str = {.length = new_len, .__data = data_ptr};
return cat_str;
}
void str_to_c_str(char* dst, size_t dst_size, const str_t* src) {
if (src->length >= dst_size)
crash(
"String is too long to hold in C string buffer: %ld >= %ld\n",
src->length,
dst_size);
memmove(dst, src->__data, src->length);
dst[src->length] = 0;
}
char* str_to_heap_c_str(const str_t src) {
char* dst = alloc_c_str(src.length);
memcpy(dst, src.__data, src.length);
return dst;
}
str_t str_init(char* data, size_t length) {
str_t str = {.length = length, .__data = data};
return str;
}
str_t str_heap_alloc(size_t length) {
char* data_ptr = alloc_data_ptr(length);
str_t str = {.length = length, .__data = data_ptr};
return str;
}
str_t str_heap_alloc_iv(const char* c_str) {
size_t length = strlen(c_str);
char* data_ptr = alloc_data_ptr(length);
memcpy(data_ptr, c_str, length);
str_t str = {.length = length, .__data = data_ptr};
return str;
}
str_t str_heap_alloc_iv_slice(const char* c_str, size_t start, size_t length) {
char* data_ptr = alloc_data_ptr(length);
memcpy(data_ptr, c_str + start, length);
str_t str = {.length = length, .__data = data_ptr};
return str;
}
void str_heap_destroy(str_t str) {
free(str.__data);
}
|
