#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