Avoid DST struct Table

3 files changed, 63 insertions, 65 deletions

diff --git a/bin/edi/edi.h b/bin/edi/edi.h
index 77c9d734..9b300739 100644
--- a/bin/edi/edi.h
+++ b/bin/edi/edi.h
@@ -48,18 +48,19 @@ wchar_t *bufferDest(struct Buffer *buf, size_t len);
 
 struct Table {
 	size_t len;
-	struct Slice slices[];
+	struct Slice *slices;
 };
+static const struct Table TableEmpty = { 0, NULL };
 
-struct Table *tableInsert(const struct Table *prev, size_t at, struct Slice slice);
-struct Table *tableDelete(const struct Table *prev, struct Span del);
+struct Table tableInsert(struct Table prev, size_t at, struct Slice ins);
+struct Table tableDelete(struct Table prev, struct Span del);
 
 struct Log {
 	size_t cap;
 	size_t len;
-	size_t index;
+	size_t idx;
 	struct State {
-		struct Table *table;
+		struct Table table;
 		size_t prev;
 		size_t next;
 	} *states;
@@ -67,20 +68,20 @@ struct Log {
 
 struct Log logAlloc(size_t cap);
 void logFree(struct Log *log);
-void logPush(struct Log *log, struct Table *table);
+void logPush(struct Log *log, struct Table table);
 
-static inline struct Table *logTable(struct Log *log) {
-	return log->states[log->index].table;
+static inline struct Table logTable(struct Log log) {
+	return log.states[log.idx].table;
 }
 static inline void logPrev(struct Log *log) {
-	log->index = log->states[log->index].prev;
+	log->idx = log->states[log->idx].prev;
 }
 static inline void logNext(struct Log *log) {
-	log->index = log->states[log->index].next;
+	log->idx = log->states[log->idx].next;
 }
 static inline void logBack(struct Log *log) {
-	if (log->index) log->index--;
+	if (log->idx) log->idx--;
 }
 static inline void logFore(struct Log *log) {
-	if (log->index + 1 < log->len) log->index++;
+	if (log->idx + 1 < log->len) log->idx++;
 }
diff --git a/bin/edi/log.c b/bin/edi/log.c
index 2c146aaf..f31f075f 100644
--- a/bin/edi/log.c
+++ b/bin/edi/log.c
@@ -27,26 +27,26 @@ struct Log logAlloc(size_t cap) {
 	struct State *states = malloc(sizeof(*states) * cap);
 	if (!states) err(EX_OSERR, "malloc");
 	states[0] = (struct State) {
-		.table = NULL,
+		.table = TableEmpty,
 		.prev = 0,
 		.next = 0,
 	};
 	return (struct Log) {
 		.cap = cap,
 		.len = 1,
-		.index = 0,
+		.idx = 0,
 		.states = states,
 	};
 }
 
 void logFree(struct Log *log) {
 	for (size_t i = 0; i < log->len; ++i) {
-		free(log->states[i].table);
+		free(log->states[i].table.slices);
 	}
 	free(log->states);
 }
 
-void logPush(struct Log *log, struct Table *table) {
+void logPush(struct Log *log, struct Table table) {
 	if (log->len == log->cap) {
 		log->cap *= 2;
 		log->states = realloc(log->states, sizeof(*log->states) * log->cap);
@@ -55,9 +55,9 @@ void logPush(struct Log *log, struct Table *table) {
 	size_t next = log->len++;
 	log->states[next] = (struct State) {
 		.table = table,
-		.prev = log->index,
+		.prev = log->idx,
 		.next = next,
 	};
-	log->states[log->index].next = next;
-	log->index = next;
+	log->states[log->idx].next = next;
+	log->idx = next;
 }
diff --git a/bin/edi/table.c b/bin/edi/table.c
index 318f1ac2..bb84c38e 100644
--- a/bin/edi/table.c
+++ b/bin/edi/table.c
@@ -21,78 +21,75 @@
 
 #include "edi.h"
 
-static struct Table *alloc(size_t cap) {
-	size_t size = sizeof(struct Table) + sizeof(struct Slice) * cap;
-	struct Table *table = malloc(size);
-	if (!table) err(EX_OSERR, "malloc");
-	table->len = 0;
-	return table;
+static struct Table alloc(size_t cap) {
+	struct Slice *slices = malloc(sizeof(*slices) * cap);
+	if (!slices) err(EX_OSERR, "malloc");
+	return (struct Table) { 0, slices };
 }
 
-struct Table *tableInsert(const struct Table *prev, size_t at, struct Slice slice) {
-	if (!prev || !prev->len) {
-		struct Table *next = alloc(1);
-		next->slices[next->len++] = slice;
+struct Table tableInsert(struct Table prev, size_t at, struct Slice ins) {
+	if (!prev.len) {
+		struct Table next = alloc(1);
+		next.slices[next.len++] = ins;
 		return next;
 	}
 
-	struct Table *next = alloc(prev->len + 2);
+	struct Table next = alloc(prev.len + 2);
 	struct Span span = { 0, 0 };
-	for (size_t i = 0; i < prev->len; ++i) {
-		span = spanNext(span, prev->slices[i].len);
+	for (size_t i = 0; i < prev.len; ++i) {
+		span = spanNext(span, prev.slices[i].len);
 		if (span.at == at) {
-			next->slices[next->len++] = slice;
-			next->slices[next->len++] = prev->slices[i];
+			next.slices[next.len++] = ins;
+			next.slices[next.len++] = prev.slices[i];
 		} else if (span.at < at && span.to > at) {
-			next->slices[next->len++] = (struct Slice) {
-				prev->slices[i].ptr,
+			next.slices[next.len++] = (struct Slice) {
+				prev.slices[i].ptr,
 				at - span.at,
 			};
-			next->slices[next->len++] = slice;
-			next->slices[next->len++] = (struct Slice) {
-				&prev->slices[i].ptr[at - span.at],
-				prev->slices[i].len - (at - span.at),
+			next.slices[next.len++] = ins;
+			next.slices[next.len++] = (struct Slice) {
+				&prev.slices[i].ptr[at - span.at],
+				prev.slices[i].len - (at - span.at),
 			};
 		} else {
-			next->slices[next->len++] = prev->slices[i];
+			next.slices[next.len++] = prev.slices[i];
 		}
 	}
 	if (span.to == at) {
-		next->slices[next->len++] = slice;
+		next.slices[next.len++] = ins;
 	}
 	return next;
 }
 
-struct Table *tableDelete(const struct Table *prev, struct Span del) {
-	if (!prev || !prev->len) return alloc(0);
-
-	struct Table *next = alloc(prev->len + 1);
+struct Table tableDelete(struct Table prev, struct Span del) {
+	if (!prev.len) return TableEmpty;
+	struct Table next = alloc(prev.len + 1);
 	struct Span span = { 0, 0 };
-	for (size_t i = 0; i < prev->len; ++i) {
-		span = spanNext(span, prev->slices[i].len);
+	for (size_t i = 0; i < prev.len; ++i) {
+		span = spanNext(span, prev.slices[i].len);
 		if (span.at >= del.at && span.to <= del.to) {
-			(void)prev->slices[i];
+			(void)prev.slices[i];
 		} else if (span.at < del.at && span.to > del.to) {
-			next->slices[next->len++] = (struct Slice) {
-				prev->slices[i].ptr,
+			next.slices[next.len++] = (struct Slice) {
+				prev.slices[i].ptr,
 				del.at - span.at,
 			};
-			next->slices[next->len++] = (struct Slice) {
-				&prev->slices[i].ptr[del.to - span.at],
-				prev->slices[i].len - (del.to - span.at),
+			next.slices[next.len++] = (struct Slice) {
+				&prev.slices[i].ptr[del.to - span.at],
+				prev.slices[i].len - (del.to - span.at),
 			};
 		} else if (span.at < del.at && span.to > del.at) {
-			next->slices[next->len++] = (struct Slice) {
-				prev->slices[i].ptr,
+			next.slices[next.len++] = (struct Slice) {
+				prev.slices[i].ptr,
 				del.at - span.at,
 			};
 		} else if (span.at < del.to && span.to > del.to) {
-			next->slices[next->len++] = (struct Slice) {
-				&prev->slices[i].ptr[del.to - span.at],
-				prev->slices[i].len - (del.to - span.at),
+			next.slices[next.len++] = (struct Slice) {
+				&prev.slices[i].ptr[del.to - span.at],
+				prev.slices[i].len - (del.to - span.at),
 			};
 		} else {
-			next->slices[next->len++] = prev->slices[i];
+			next.slices[next.len++] = prev.slices[i];
 		}
 	}
 	return next;
@@ -109,18 +106,18 @@ static struct Slice slice(const wchar_t *str) {
 	return (struct Slice) { str, wcslen(str) };
 }
 
-static int eq(const struct Table *table, const wchar_t *str) {
-	for (size_t i = 0; i < table->len; ++i) {
-		if (wcsncmp(str, table->slices[i].ptr, table->slices[i].len)) {
+static int eq(struct Table table, const wchar_t *str) {
+	for (size_t i = 0; i < table.len; ++i) {
+		if (wcsncmp(str, table.slices[i].ptr, table.slices[i].len)) {
 			return 0;
 		}
-		str = &str[table->slices[i].len];
+		str = &str[table.slices[i].len];
 	}
 	return 1;
 }
 
 int main() {
-	struct Table *abc = tableInsert(NULL, 0, slice(L"ABC"));
+	struct Table abc = tableInsert(TableEmpty, 0, slice(L"ABC"));
 	assert(eq(abc, L"ABC"));
 
 	assert(eq(tableInsert(abc, 0, slice(L"D")), L"DABC"));