aboutsummaryrefslogtreecommitdiff
path: root/lang.h
blob: 64589db28774558098973a3c7c5730022fa79525 (plain)
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