From 74111495622a13104b4f6500f6dc8e9db6aec9bd Mon Sep 17 00:00:00 2001 From: David Moc Date: Thu, 19 Nov 2026 02:10:24 +0100 Subject: Hello World! --- lang.h | 119 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 119 insertions(+) create mode 100644 lang.h (limited to 'lang.h') diff --git a/lang.h b/lang.h new file mode 100644 index 0000000..64589db --- /dev/null +++ b/lang.h @@ -0,0 +1,119 @@ +#ifndef LANG_H +#define LANG_H + +#include +#include +#include + +/* 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 -- cgit v1.2.3