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
|
#ifndef LANG_H
#define LANG_H
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
/* Every file in langs/ must define both. Return a malloc'd string,
or NULL on failure. */
char *lang_encrypt(const char *input);
char *lang_decrypt(const char *input);
/* -------------------------------------------------- */
typedef struct StringBuffer {
char *data; /* always NUL-terminated once allocated */
size_t len;
size_t cap;
} SB;
/* A non-owning view into some other string. Not NUL-terminated. */
typedef struct Span {
const char *ptr;
size_t len;
} Span;
static void sb_init(SB *sb) {
sb->data = NULL;
sb->len = 0;
sb->cap = 0;
}
static void sb_free(SB *sb) {
free(sb->data);
sb_init(sb);
}
/* Ensure room for `extra` more bytes plus the NUL. 0 on success, -1 on failure. */
static int sb_reserve(SB *sb, size_t extra) {
if (extra >= SIZE_MAX - sb->len) return -1;
size_t need = sb->len + extra + 1;
if (need <= sb->cap) return 0;
size_t cap = sb->cap ? sb->cap : 16;
while (cap < need) {
if (cap > SIZE_MAX / 2) { cap = need; break; }
cap *= 2;
}
char *p = realloc(sb->data, cap);
if (!p) return -1;
sb->data = p;
sb->cap = cap;
return 0;
}
static int sb_append_n(SB *sb, const char *s, size_t n) {
if (sb_reserve(sb, n) != 0) return -1;
if (n) memcpy(sb->data + sb->len, s, n);
sb->len += n;
sb->data[sb->len] = '\0';
return 0;
}
static int sb_append(SB *sb, const char *s) {
return sb_append_n(sb, s, strlen(s));
}
static int sb_push(SB *sb, char c) {
return sb_append_n(sb, &c, 1);
}
/* Hand the contents to the caller (free() it) and reset the buffer.
Always returns a valid string ("" if nothing was appended), NULL only on OOM. */
static char *sb_take(SB *sb) {
if (sb_reserve(sb, 0) != 0) return NULL;
sb->data[sb->len] = '\0';
char *out = sb->data;
sb_init(sb);
return out;
}
/* Split on every `delim`. Empty fields are kept, so joining the spans
with the same delim gives back the original string exactly.
Returns the span count (always >= 1), or 0 on OOM. Caller frees *out. */
static size_t split_spans(const char *s, char delim, Span **out) {
size_t n = 1;
for (const char *p = s; *p; p++)
if (*p == delim) n++;
Span *spans = malloc(n * sizeof(Span));
if (!spans) return 0;
size_t i = 0;
const char *start = s;
for (const char *p = s; ; p++) {
if (*p == delim || *p == '\0') {
spans[i].ptr = start;
spans[i].len = (size_t)(p - start);
i++;
start = p + 1;
if (*p == '\0') break;
}
}
*out = spans;
return n;
}
/* Append spans[0..n) separated by `delim`. */
static int sb_join_spans(SB *sb, const Span *spans, size_t n, char delim) {
for (size_t i = 0; i < n; i++) {
if (i > 0 && sb_push(sb, delim) != 0) return -1;
if (sb_append_n(sb, spans[i].ptr, spans[i].len) != 0) return -1;
}
return 0;
}
#endif
|