Lay Pure out as a core with the parts selected around it

The app model, the tree store and the HTTP host lived in
prototypes/connections among the earlier document runtime, the store was
known only by its format's name, and Vega compiled six Pure sources by path.
Now, as the README's principle has it:

  core/   runtime, flow and the app model (module*.c), with what the core
          asks of storage (state.h, store.h)
  store/  the tree store (PURETRE3, PUREREC1)
  serve/  pure-serve: HTTP host, outbound delivery, JSON in place
  cli/    pure-run, pure-edit-module

A top-level make builds libpure.a (app model and store, for hosts to link)
and the hosts; make check runs the store's and the app model's tests. The
earlier runtime still builds from prototypes/connections against core/ and
store/ (check, check-tree and check-core pass). Design 009 records the rule:
parts by role behind libraries; git repositories split by coupling, so the
store stays here while its contract moves with the core, and Vega stays apart.

1 files changed, 189 insertions, 0 deletions

diff --git a/core/module-text.c b/core/module-text.c
new file mode 100644
index 0000000..68c03b0
--- /dev/null
+++ b/core/module-text.c
@@ -0,0 +1,189 @@
+#include "module-text.h"
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+enum { CHUNK = 4096 };
+
+/* state: pending continuation bytes (bits 0-1) and the allowed range of the
+ * next one (bits 2-4): 0 any, 1 A0-BF after E0, 2 80-9F after ED, 3 90-BF
+ * after F0, 4 80-8F after F4. */
+bool pure_utf8_step(unsigned *state, PureSpan span) {
+    unsigned remaining = *state & 3, range = *state >> 2;
+    for (size_t i = 0; i < span.size; ++i) {
+        /* Eight ASCII bytes at a time between characters. */
+        uint64_t word;
+        while (!remaining && span.size - i >= 8 && (memcpy(&word, span.data + i, 8), !(word & UINT64_C(0x8080808080808080))))
+            i += 8;
+        if (i == span.size) break;
+        unsigned char b = span.data[i];
+        if (remaining) {
+            unsigned low = range == 1 ? 0xA0 : range == 3 ? 0x90 : 0x80;
+            unsigned high = range == 2 ? 0x9F : range == 4 ? 0x8F : 0xBF;
+            if (b < low || b > high) return false;
+            --remaining;
+            range = 0;
+        } else if (b < 0x80) {
+            continue;
+        } else if (b >= 0xC2 && b <= 0xDF) {
+            remaining = 1;
+        } else if (b >= 0xE0 && b <= 0xEF) {
+            remaining = 2;
+            range = b == 0xE0 ? 1 : b == 0xED ? 2 : 0;
+        } else if (b >= 0xF0 && b <= 0xF4) {
+            remaining = 3;
+            range = b == 0xF0 ? 3 : b == 0xF4 ? 4 : 0;
+        } else return false;
+    }
+    *state = remaining | range << 2;
+    return true;
+}
+
+bool pure_utf8_complete(unsigned state) { return (state & 3) == 0; }
+
+bool pure_utf8_valid(PureSpan span) {
+    unsigned state = 0;
+    return pure_utf8_step(&state, span) && pure_utf8_complete(state);
+}
+
+size_t pure_utf8_scalars(PureSpan span) {
+    size_t count = 0;
+    for (size_t i = 0; i < span.size; ++i) count += (span.data[i] & 0xC0) != 0x80;
+    return count;
+}
+
+size_t pure_utf8_newlines(PureSpan span) {
+    size_t count = 0;
+    for (size_t i = 0; i < span.size; ++i) count += span.data[i] == '\n';
+    return count;
+}
+
+size_t pure_format_number(double value, char out[32]) {
+    if (value == 0) { memcpy(out, "0", 2); return 1; }
+    if (value == floor(value) && fabs(value) < 1e15) {
+        /* An integer's digits, without printf (the common case, many times cheaper). */
+        char digits[16];
+        uint64_t n = (uint64_t)fabs(value);
+        size_t count = 0, length = 0;
+        do { digits[count++] = (char)('0' + n % 10); n /= 10; } while (n);
+        if (value < 0) out[length++] = '-';
+        while (count) out[length++] = digits[--count];
+        out[length] = 0;
+        return length;
+    }
+    for (int precision = 1; precision <= 17; ++precision) {
+        snprintf(out, 32, "%.*g", precision, value);
+        if (strtod(out, NULL) == value) break;
+    }
+    char *exponent = strchr(out, 'e');
+    if (exponent) {
+        char *digits = exponent + 2; /* after the sign */
+        while (digits[0] == '0' && digits[1]) memmove(digits, digits + 1, strlen(digits));
+    }
+    return strlen(out);
+}
+
+typedef struct { unsigned char *out; } Copy;
+
+static bool copy(void *context, PureSpan span) {
+    Copy *c = context;
+    memcpy(c->out, span.data, span.size);
+    c->out += span.size;
+    return true;
+}
+
+static void read_bytes(const PureDraft *draft, PureVersion version, size_t offset, size_t length,
+                       unsigned char *out) {
+    Copy c = {out};
+    if (length) pure_draft_read_version(draft, version, offset, length, copy, &c);
+}
+
+static size_t forward(const PureDraft *draft, PureVersion version, size_t position) {
+    if (position >= version.bytes) return version.bytes;
+    unsigned char lead;
+    read_bytes(draft, version, position, 1, &lead);
+    size_t length = lead < 0x80 ? 1 : lead < 0xE0 ? 2 : lead < 0xF0 ? 3 : 4;
+    return position + length <= version.bytes ? position + length : version.bytes;
+}
+
+static size_t backward(const PureDraft *draft, PureVersion version, size_t position) {
+    if (!position) return 0;
+    size_t take = position < 4 ? position : 4;
+    unsigned char bytes[4];
+    read_bytes(draft, version, position - take, take, bytes);
+    size_t at = take - 1;
+    while (at && (bytes[at] & 0xC0) == 0x80) --at;
+    return position - take + at;
+}
+
+/* Saturating: stops at the start or end, so work is bounded by the text size. */
+size_t pure_text_step(const PureDraft *draft, PureVersion version, size_t position, double count) {
+    for (; count > 0 && position < version.bytes; --count) position = forward(draft, version, position);
+    for (; count < 0 && position > 0; ++count) position = backward(draft, version, position);
+    return position;
+}
+
+size_t pure_text_line_start(const PureDraft *draft, PureVersion version, size_t position) {
+    unsigned char chunk[CHUNK];
+    while (position) {
+        size_t take = position < CHUNK ? position : CHUNK;
+        read_bytes(draft, version, position - take, take, chunk);
+        for (size_t i = take; i-- > 0;)
+            if (chunk[i] == '\n') return position - take + i + 1;
+        position -= take;
+    }
+    return 0;
+}
+
+size_t pure_text_line_end(const PureDraft *draft, PureVersion version, size_t position) {
+    unsigned char chunk[CHUNK];
+    while (position < version.bytes) {
+        size_t take = version.bytes - position < CHUNK ? version.bytes - position : CHUNK;
+        read_bytes(draft, version, position, take, chunk);
+        for (size_t i = 0; i < take; ++i)
+            if (chunk[i] == '\n') return position + i;
+        position += take;
+    }
+    return version.bytes;
+}
+
+static size_t advance_within(const PureDraft *draft, PureVersion version, size_t position,
+                             size_t columns, size_t limit) {
+    for (; columns && position < limit; --columns) position = forward(draft, version, position);
+    return position < limit ? position : limit;
+}
+
+/* Moves keep the column; with no further line the cursor goes to the end or
+ * the start of the text. */
+size_t pure_text_line_step(const PureDraft *draft, PureVersion version, size_t position, double count) {
+    size_t start = pure_text_line_start(draft, version, position), column = 0;
+    for (size_t at = start; at < position; at = forward(draft, version, at)) ++column;
+    for (; count > 0; --count) {
+        size_t end = pure_text_line_end(draft, version, position);
+        if (end == version.bytes) return version.bytes;
+        size_t next = end + 1;
+        position = advance_within(draft, version, next, column, pure_text_line_end(draft, version, next));
+    }
+    for (; count < 0; ++count) {
+        size_t here = pure_text_line_start(draft, version, position);
+        if (!here) return 0;
+        size_t previous = pure_text_line_start(draft, version, here - 1);
+        position = advance_within(draft, version, previous, column, here - 1);
+    }
+    return position;
+}
+
+typedef struct { size_t count; unsigned unit; } Count;
+
+static bool count_span(void *context, PureSpan span) {
+    Count *c = context;
+    c->count += c->unit ? pure_utf8_newlines(span) : pure_utf8_scalars(span);
+    return true;
+}
+
+size_t pure_text_count(const PureDraft *draft, PureVersion version, size_t position, unsigned unit) {
+    Count c = {0, unit};
+    if (position) pure_draft_read_version(draft, version, 0, position, count_span, &c);
+    return c.count + (unit ? 1 : 0);
+}