Give i64 its own type in modules, lists, stores and the host (016 stage 2)

An i64 is an int64_t in a value's 8 bytes, its own stack type: CONST and
NUM_TEXT take argument 2 for one, eleven opcodes are appended (ADD, SUB
and MUL fail as overflow past its range, DIV and MOD floor and fail as
divide by zero, NEG, COMPARE with a relation, MIN, MAX, and I64_FROM and
NUM_FROM, which convert only where the value fits and else fail as
limit), and moves (LOAD, STORE, locals, items, FIELD, SEND) copy it as
they copy a number. Type codes: state 6, record field 3, message field 7
(8 bytes), view 4, local 3. v6 stays: all of it is added.

- Folds with PURE_FOLD_INTEGER sum (overflow fails), keep the most or
  least of, or count the different i64s; distinct's set keeps an i64's
  -1 apart from its free mark. Blocks with an i64 run item by item.
- A list's kinds are its stored header's (number, text, bytes, bool,
  integer): integer columns are int64_t, ordered as integers as keys
  (found without guide keys for now), stored in 8 bytes and logged as
  zigzag varints of any size. Records name their fields' type in one
  array (record_field_type) in place of text and bool flags.
- A number, a bool and an i64 carry over each other by one rule,
  pure_cell_as, wherever one becomes another: a module replaced, a stored
  value or item read by another module, a waiting send recast. A u32
  field delivers to an i64 one.
- The host reads i64 fields from JSON, rows and queries as integer digits
  in range and nothing else, and shows every digit in views, tables,
  deliveries and pure-run. Faults are named by one function,
  pure_fault_name, in place of three tables; overflow is new.

test-module: 28 arithmetic cases at the range's ends, relations,
conversions both ways, 14 refusals, a keyed i64 list app (order, a sum
that overflows, a failed add undone, messages and sends of 8 bytes, every
digit as text), recasts, replacement between numbers, bools and i64s, and
three stored runs against memory with restarts (46 images written).

1 files changed, 20 insertions, 1 deletions

diff --git a/serve/test-message-json.c b/serve/test-message-json.c
index b2bad37..eb98f47 100644
--- a/serve/test-message-json.c
+++ b/serve/test-message-json.c
@@ -1,7 +1,8 @@
 /* JSON numbers are read as strtod reads them, bit for bit: in the forms a
  * client writes (a program's shortest digits, fixed decimals, exponents), at
  * the edges of the exact path (2^53, 10^22) and past them, and refused when
- * not finite or not JSON. A bool is true or false, nothing else. */
+ * not finite or not JSON. A bool is true or false, nothing else; an i64 an
+ * integer's digits, exact in its range. */
 #include "message-json.h"
 #include <math.h>
 #include <stdint.h>
@@ -52,6 +53,24 @@ int main(void) {
         CHECK(!pure_json_fixed(&truth, (const unsigned char *)not_bools[i], strlen(not_bools[i]), prefix) && prefix[1] == 0);
     double number;
     CHECK(!read_number("true", &number) && !read_number("false", &number));
+    /* An i64 is an integer's digits, exactly, in its range. */
+    static const PureField whole = {.type = PURE_FIELD_I64, .offset = 0};
+    static const struct { const char *text; int64_t value; } integers[] = {
+        {"0", 0}, {"-0", 0}, {"9007199254740993", INT64_C(9007199254740993)}, {"9223372036854775807", INT64_MAX},
+        {"-9223372036854775808", INT64_MIN}, {"-1", -1}};
+    for (size_t i = 0; i < sizeof(integers) / sizeof(*integers); ++i) {
+        unsigned char bytes[8];
+        int64_t value;
+        CHECK(pure_json_fixed(&whole, (const unsigned char *)integers[i].text, strlen(integers[i].text), bytes));
+        memcpy(&value, bytes, 8);
+        CHECK(value == integers[i].value);
+    }
+    static const char *const not_integers[] = {"9223372036854775808", "-9223372036854775809", "1.0", "1e3", "+1", "01", "\"1\"",
+                                               "", "-", "1.5", "true", "99999999999999999999"};
+    for (size_t i = 0; i < sizeof(not_integers) / sizeof(*not_integers); ++i) {
+        unsigned char bytes[8];
+        CHECK(!pure_json_fixed(&whole, (const unsigned char *)not_integers[i], strlen(not_integers[i]), bytes));
+    }
     uint64_t seed = 0x6a736f6eu;
     size_t read = 0;
     for (unsigned i = 0; i < 400000; ++i) {