aboutsummaryrefslogtreecommitdiff
path: root/lang.h
diff options
context:
space:
mode:
authorDavid Moc <personal@cdatgoose.org>2026-11-19 02:10:24 +0100
committerDavid Moc <personal@cdatgoose.org>2026-11-19 02:10:24 +0100
commit74111495622a13104b4f6500f6dc8e9db6aec9bd (patch)
tree9695ff6f2abbb1d5f04bf9061d3ffafc248fb9f1 /lang.h
Hello World!
Diffstat (limited to 'lang.h')
-rw-r--r--lang.h119
1 files changed, 119 insertions, 0 deletions
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 <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