Count with for i in a .. b, break, nest fors and let an event's own lists (Pure 018)

1 files changed, 244 insertions, 32 deletions

diff --git a/compiler/compile.c b/compiler/compile.c
index 2d66286..25a761b 100644
--- a/compiler/compile.c
+++ b/compiler/compile.c
@@ -20,13 +20,15 @@ enum { CONST, LOAD, DT, ADD, SUB, MUL, DIV, NEG, LT, LE, GT, GE, EQ, NE, AND, OR
        ITEM_GET, ITEM_SET, INDEX_LOAD, INDEX_STORE, INDEX_MOVE, INDEX_FIRST, INDEX_LAST, INDEX_NUM, ROW,
        PICK, SLIDE, FOLD, TEXT_COMPARE, LIST_FIND, LIST_HAS, NOW, FLOOR, MOD, SEND, OUTER_ROW, EACH,
        LOCAL_LOAD, LOCAL_STORE, I64_ADD, I64_SUB, I64_MUL, I64_DIV, I64_MOD, I64_NEG, I64_COMPARE, I64_MIN, I64_MAX,
-       I64_FROM, NUM_FROM };
+       I64_FROM, NUM_FROM, LOOP, BREAK };
 enum { LOCALS = 64 }; /* an event's locals (Pure's) */
+enum { NESTING = 8, LOOP_INTEGER = 256 }; /* loops (for) nest 8 deep; an i64's count (Pure 018) */
 enum { FOLD_COUNT, FOLD_SUM, FOLD_MAX, FOLD_MIN, FOLD_FIRST, FOLD_DISTINCT, FOLD_INTEGER = 0x40 };
 enum { KIND_KEY = 1, KIND_MESSAGE = 2, KIND_TEXT = 3, KIND_TIMER = 4, KIND_OUTPUT = 5, KIND_ARGUMENTS = 6,
        FIELD_U32 = 1, FIELD_BYTES = 2, FIELD_NUMBER = 3, FIELD_TEXT = 4,
        FIELD_ROWS = 5, FIELD_BOOL = 6, FIELD_I64 = 7 };
-/* A list of a message's rows: filled as the message arrives, emptied when its event ends (Pure's flag). */
+/* An event's list: a message's rows, filled as the message arrives, or a
+ * let's list; emptied when its event ends (Pure's flag). */
 enum { LIST_ROWS = 256 };
 enum { STATE_TRANSIENT = 256 };
 enum { STATE_NUM = 0, STATE_TEXT = 1, STATE_CURSOR = 2, STATE_LIST = 3, STATE_INDEX = 4, STATE_BOOL = 5, STATE_I64 = 6,
@@ -78,15 +80,19 @@ typedef struct Expr {
 } Expr;
 
 typedef enum { S_ASSIGN, S_IF, S_REPLACE, S_REPLY, S_REQUIRE, S_INSERT, S_REMOVE, S_APPEND, S_ADD, S_SET, S_SEND, S_FOR,
-               S_LET } StmtKind;
+               S_LET, S_COUNT, S_BREAK } StmtKind;
 typedef struct Stmt {
     StmtKind kind;
     int line, column;
     char name[NAME], member[NAME]; /* member: the item field an S_SET changes; S_FOR: name is the item, member the list */
     Expr *value;          /* assigned value, condition, reply, requirement or insertion */
     Expr *first, *last;   /* a range, the insertion cursor or index, or the item index; last may be NULL */
-    Expr *low, *high;     /* S_FOR: a slice of the list's keys, or NULL */
+    Expr *low, *high;     /* S_FOR: a slice of the list's keys, or NULL; S_COUNT: its range */
                           /* S_SET: name is the list, or empty when first is an index naming the item */
+    /* S_LET of a list (listed): member is its record (of library), key the field it is keyed by or empty. */
+    bool listed;
+    int library, key_line, key_column;
+    char key[NAME];
     struct Stmt *then, *otherwise, *next;
 } Stmt;
 
@@ -154,6 +160,7 @@ typedef struct {
     bool state_stays[STATES]; /* a mark: a cursor that stays before text inserted at it */
     bool state_transient[STATES]; /* held while the app runs, never stored (Pure 018) */
     int state_rows[STATES];   /* a list of a message's rows: its input + 1, or 0 */
+    bool state_event[STATES]; /* a let's list (let.NAME): its handlers' alone, found only by its let */
     int state_library[STATES]; /* a list's record's library (LIBRARY.NAME), or 0: the app's */
     /* A keyed list: the field named after by, and once resolved, that field + 1. */
     char state_key[STATES][NAME];
@@ -191,14 +198,15 @@ typedef struct {
     char fold_name[NAME];
     int fold_list;
     Scope *fold_scope;
-    /* A handler's locals in scope (let), innermost last, and the slots it used. */
-    struct { char name[NAME]; unsigned slot; Kind kind; } locals[LOCALS];
+    /* A handler's locals in scope (let), innermost last, and the slots it used. A let's list (list: its
+     * state) has no slot; a for's count (counter) is read, never assigned. */
+    struct { char name[NAME]; unsigned slot; Kind kind; int list; bool counter; } locals[LOCALS];
     unsigned local_count, local_slots;
-    /* The for whose block is being generated: its item's name and list. */
-    bool walking;
-    char walk_name[NAME];
-    int walk_list;
-    Scope *walk_scope;
+    /* The fors whose blocks are being generated, innermost last: the item's or count's name, the list a walk
+     * walks (-1: a count), and the index local an outer walk's item is kept in for the fors inside it (-1: none). */
+    struct { char name[NAME]; int list, item; Scope *scope; } loops[NESTING];
+    unsigned loop_count;
+    unsigned nested;      /* blocks within the handler's own (an if's, a for's) */
     /* Libraries: module 0 is the main source; each module lists the libraries it uses. */
     struct { char name[NAME], path[AUP_PATH]; bool uses[MODULES], parsing; } modules[MODULES];
     unsigned module_count;
@@ -224,7 +232,7 @@ static const char *const reserved[] = {"state", "input", "view", "on", "if", "el
                                        "dt", "min", "max", "clamp", "message", "by", "bytes", "u32",
                                        "reply", "require", "record", "each", "fn", "use", "now", "every",
                                        "floor", "output", "send", "for", "let", "true", "false",
-                                       "transient"};
+                                       "transient", "break"};
 
 /* An error in the module being parsed or inlined; inside a fn it names the call. */
 static _Noreturn void fail_at(Compiler *c, int line, int column, const char *format, ...) {
@@ -993,10 +1001,31 @@ static Stmt *statement(Compiler *c, unsigned depth) {
         memcpy(s->name, name.text, NAME);
         s->line = name.line;
         s->column = name.column;
+        if (is(c, ":")) { /* let name: list of R [by field]: the event's list, empty as it begins */
+            take(c);
+            Token type = expect_name(c, "list");
+            if (strcmp(type.text, "list"))
+                fail_at(c, type.line, type.column, "a let holds a list as let %s: list of a record; others take '='", s->name);
+            expect_word(c, "of");
+            held_record(c, s->member, &s->library);
+            if (word(c, "by")) {
+                take(c);
+                Token key = expect_name(c, "a field of the record");
+                memcpy(s->key, key.text, NAME);
+                s->key_line = key.line;
+                s->key_column = key.column;
+            }
+            s->listed = true;
+            return s;
+        }
         expect(c, "=", "'='");
         s->value = expression(c, 0, false);
         return s;
     }
+    if (!strcmp(token.text, "break")) { /* ends the innermost for */
+        s->kind = S_BREAK;
+        return s;
+    }
     if (!strcmp(token.text, "for")) {
         /* for item in list [where condition] { ... }: the block runs once for every item the list has */
         s->kind = S_FOR;
@@ -1007,6 +1036,29 @@ static Stmt *statement(Compiler *c, unsigned depth) {
         if (!word(c, "in")) fail_at(c, c->token.line, c->token.column, "expected 'in' and a list, as in for %s in tasks { }",
                                     item.text);
         take(c);
+        /* for i in low .. high counts; for x in list walks (a list's name, then '{', '[' or where: looked at, the
+         * scanner then put back when it counts) */
+        bool walks = false;
+        if (c->token.kind == T_NAME) {
+            size_t at = c->at;
+            int line = c->line, column = c->column;
+            Token token = c->token, ahead = c->ahead;
+            bool has_ahead = c->has_ahead;
+            char path[NAME];
+            list_path(c, path);
+            walks = is(c, "{") || is(c, "[") || word(c, "where");
+            c->at = at, c->line = line, c->column = column;
+            c->token = token, c->ahead = ahead, c->has_ahead = has_ahead;
+        }
+        if (!walks) {
+            s->kind = S_COUNT;
+            s->low = expression(c, 0, false);
+            if (!is(c, "..")) fail_at(c, c->token.line, c->token.column, "expected '..', as in for %s in 0 .. n { }", item.text);
+            take(c);
+            s->high = expression(c, 0, false);
+            s->then = block(c, depth + 1);
+            return s;
+        }
         s->first = node(c, E_NAME, c->token.line, c->token.column); /* where the list is named */
         list_path(c, s->member);
         if (is(c, "[")) slice(c, &s->low, &s->high);
@@ -1140,7 +1192,9 @@ static int input_index(const Compiler *c, const char *name) {
 }
 
 static int state_index(const Compiler *c, const char *name) {
-    for (unsigned i = 0; i < c->states; ++i) if (!strcmp(c->state_names[i], name)) return (int)i;
+    for (unsigned i = c->local_count; i-- > 0;) /* a let's list, by the let's name */
+        if (c->locals[i].list >= 0 && !strcmp(c->locals[i].name, name)) return c->locals[i].list;
+    for (unsigned i = 0; i < c->states; ++i) if (!c->state_event[i] && !strcmp(c->state_names[i], name)) return (int)i;
     return -1;
 }
 
@@ -2130,12 +2184,49 @@ static void app_name(Compiler *c, const Expr *e, const char *name) {
 }
 
 /* The local named name in scope, or -1. */
+/* A let of a value (or a for's count) in scope, by name, or -1; a let's list is a state (state_index). */
 static int local_named(const Compiler *c, const char *name) {
     for (unsigned i = c->local_count; i-- > 0;)
+        if (c->locals[i].list < 0 && !strcmp(c->locals[i].name, name)) return (int)i;
+    return -1;
+}
+
+/* Any let in scope by name (a value's or a list's), or -1. */
+static int let_named(const Compiler *c, const char *name) {
+    for (unsigned i = c->local_count; i-- > 0;)
         if (!strcmp(c->locals[i].name, name)) return (int)i;
     return -1;
 }
 
+/* The for (walk or count) in whose block a name is its item or count, innermost first, or -1. */
+static int loop_named(const Compiler *c, const char *name) {
+    for (unsigned i = c->loop_count; i-- > 0;)
+        if (!strcmp(c->loops[i].name, name)) return (int)i;
+    return -1;
+}
+
+/* The innermost walk among the fors around, or -1. */
+static int innermost_walk(const Compiler *c) {
+    for (unsigned i = c->loop_count; i-- > 0;)
+        if (c->loops[i].list >= 0) return (int)i;
+    return -1;
+}
+
+/* Whether a list is walked by a for around: the innermost walk's (1), an outer walk's (2), or none (0). */
+static int walked(const Compiler *c, int list) {
+    int inner = innermost_walk(c);
+    for (unsigned i = 0; inner >= 0 && i < c->loop_count; ++i)
+        if (c->loops[i].list == list) return (int)i == inner ? 1 : 2;
+    return 0;
+}
+
+/* Whether statements hold a walk (a for over a list), at any depth. */
+static bool holds_walk(const Stmt *s) {
+    for (; s; s = s->next)
+        if (s->kind == S_FOR || holds_walk(s->then) || holds_walk(s->otherwise)) return true;
+    return false;
+}
+
 static uint32_t local_arg(const Compiler *c, int local) {
     const Kind *kind = &c->locals[local].kind;
     return c->locals[local].slot | (kind->type == INDEX ? 1u << 8 | (uint32_t)kind->owner << 16 :
@@ -2177,10 +2268,14 @@ static Kind value(Compiler *c, const Expr *e, bool handler, int height) {
             emit(c, e->line, e->column, ROW, (uint32_t)c->fold_list, 0); /* the item a fold's block runs for */
             return (Kind){INDEX, c->fold_list};
         }
-        if (c->walking && c->scope == c->walk_scope && !strcmp(e->name, c->walk_name)) {
-            /* the item a for's block runs for; in a count, sum, max or min inside it, still there */
-            emit(c, e->line, e->column, c->folding ? OUTER_ROW : ROW, (uint32_t)c->walk_list, 0);
-            return (Kind){INDEX, c->walk_list};
+        int loop = loop_named(c, e->name);
+        if (loop >= 0 && c->loops[loop].list >= 0 && c->scope == c->loops[loop].scope) {
+            /* the item a for's block runs for; in a count, sum, max or min inside it, still there; an outer
+             * walk's, inside the walks within it, kept in a local */
+            int list = c->loops[loop].list;
+            if (loop == innermost_walk(c)) emit(c, e->line, e->column, c->folding ? OUTER_ROW : ROW, (uint32_t)list, 0);
+            else emit(c, e->line, e->column, LOCAL_LOAD, (uint32_t)c->loops[loop].item | 1u << 8 | (uint32_t)list << 16, 0);
+            return (Kind){INDEX, list};
         }
         int param = parameter(c, e->name);
         if (param >= 0 && c->folding && c->scope == c->fold_scope)
@@ -2580,7 +2675,8 @@ static Expr *spread_field(Compiler *c, const Expr *spread, const char *name) {
     }
     if (source->kind == E_NAME) {
         int local = local_named(c, source->name), state = state_index(c, source->name);
-        if (c->walking && !strcmp(source->name, c->walk_name)) list = c->walk_list;
+        int loop = loop_named(c, source->name);
+        if (loop >= 0 && c->loops[loop].list >= 0) list = c->loops[loop].list;
         else if (local >= 0 && c->locals[local].kind.type == INDEX) list = c->locals[local].kind.owner;
         else if (local < 0 && state >= 0 && c->state_types[state] == STATE_INDEX) list = cursor_owner(c, state);
     } else if (source->kind == E_ITEM && !source->member[0])
@@ -2683,11 +2779,26 @@ static void statements(Compiler *c, const Stmt *s) {
     for (; s; s = s->next) {
         switch (s->kind) {
         case S_LET: {
+            if (let_named(c, s->name) >= 0) fail_at(c, s->line, s->column, "'%s' is already a let here", s->name);
             const char *kind = declared_kind(c, s->name);
             if (kind) fail_at(c, s->line, s->column, "'%s' is already declared as %s", s->name, kind);
-            if (local_named(c, s->name) >= 0) fail_at(c, s->line, s->column, "'%s' is already a let here", s->name);
-            if (c->walking && !strcmp(s->name, c->walk_name))
-                fail_at(c, s->line, s->column, "'%s' is the item this for walks", s->name);
+            int loop = loop_named(c, s->name);
+            if (loop >= 0)
+                fail_at(c, s->line, s->column, c->loops[loop].list >= 0 ? "'%s' is the item this for walks" :
+                        "'%s' is what this for counts", s->name);
+            if (c->local_count == LOCALS) fail_at(c, s->line, s->column, "at most %d lets are allowed in a handler", LOCALS);
+            if (s->listed) { /* the event's list: its state let.NAME, made before the handlers (event_lists) */
+                if (c->nested) fail_at(c, s->line, s->column, "a let's list goes in the handler's own block, not in an if or a for");
+                char path[2 * NAME];
+                snprintf(path, sizeof(path), "let.%s", s->name);
+                int list = -1;
+                for (unsigned i = 0; i < c->states; ++i) if (c->state_event[i] && !strcmp(c->state_names[i], path)) list = (int)i;
+                unsigned local = c->local_count++;
+                memset(&c->locals[local], 0, sizeof(c->locals[local]));
+                memcpy(c->locals[local].name, s->name, NAME);
+                c->locals[local].list = list;
+                break;
+            }
             if (c->local_slots == LOCALS) fail_at(c, s->line, s->column, "at most %d lets are allowed in a handler", LOCALS);
             Kind held = value(c, s->value, true, 0);
             if (held.type != NUM && held.type != BOOL && held.type != I64 && held.type != INDEX)
@@ -2697,11 +2808,15 @@ static void statements(Compiler *c, const Stmt *s) {
             memcpy(c->locals[local].name, s->name, NAME);
             c->locals[local].slot = c->local_slots++;
             c->locals[local].kind = held;
+            c->locals[local].list = -1;
+            c->locals[local].counter = false;
             emit(c, s->line, s->column, LOCAL_STORE, local_arg(c, (int)local), 0);
             break;
         }
         case S_ASSIGN: {
             int local = local_named(c, s->name);
+            if (local >= 0 && c->locals[local].counter)
+                fail_at(c, s->line, s->column, "'%s' is what this for counts; it is not assigned", s->name);
             if (local >= 0) { /* a let takes a new value of its kind */
                 Kind kind = wanted(c, s->value, true, 0, c->locals[local].kind.type);
                 if (kind.type != c->locals[local].kind.type || (kind.type == INDEX && kind.owner != c->locals[local].kind.owner))
@@ -2741,8 +2856,10 @@ static void statements(Compiler *c, const Stmt *s) {
             int list = state_index(c, s->name);
             if (list >= 0 && c->state_types[list] == STATE_LIST) {
                 if (s->last) fail_at(c, s->last->line, s->last->column, "a list removes one item, as in %s.remove(index)", s->name);
-                if (s->kind == S_INSERT && c->walking && list == c->walk_list)
+                if (s->kind == S_INSERT && walked(c, list))
                     fail_at(c, s->line, s->column, "a for does not add to the list it walks; add to another list, or after the for");
+                if (s->kind == S_REMOVE && walked(c, list) == 2)
+                    fail_at(c, s->line, s->column, "a for removes from the list it walks, not from one an outer for walks");
                 if (s->kind == S_INSERT && keyed_by(c, list))
                     fail_at(c, s->line, s->column, "'%s' is keyed by %s: %s.add(%s { ... }) places an item by its key", s->name,
                             keyed_by(c, list), s->name, record_shown(c, c->module, record_of(c, list)));
@@ -2767,7 +2884,7 @@ static void statements(Compiler *c, const Stmt *s) {
         case S_APPEND: case S_ADD: {
             /* A keyed list places an added item by its key (it fails if the key is there); others append. */
             int list = list_state(c, s->name, s->line, s->column, NULL);
-            if (c->walking && list == c->walk_list)
+            if (walked(c, list))
                 fail_at(c, s->line, s->column, "a for does not add to the list it walks; add to another list, or after the for");
             const char *key = keyed_by(c, list), *record = record_shown(c, c->module, record_of(c, list));
             if (s->kind == S_APPEND && key)
@@ -2859,7 +2976,7 @@ static void statements(Compiler *c, const Stmt *s) {
         case S_REPLY:
             if (c->message < 0 || c->inputs[c->message].kind != KIND_MESSAGE)
                 fail_at(c, s->line, s->column, "reply is only available in a message handler");
-            if (c->walking) fail_at(c, s->line, s->column, "a message replies once: reply after the for");
+            if (c->loop_count) fail_at(c, s->line, s->column, "a message replies once: reply after the for");
             bytes_value(c, s->value, 0, "reply");
             emit(c, s->line, s->column, REPLY, 0, 0);
             break;
@@ -2869,10 +2986,12 @@ static void statements(Compiler *c, const Stmt *s) {
             break;
         case S_FOR: {
             /* EACH and the block after it, run once for every item the list has, with the item as ROW. */
-            if (c->walking) fail_at(c, s->line, s->column, "a for cannot hold another for");
+            if (c->loop_count == NESTING) fail_at(c, s->line, s->column, "fors nest at most %d deep", NESTING);
             int list = list_state(c, s->member, s->first->line, s->first->column, NULL);
             const char *kind = declared_kind(c, s->name);
             if (kind) fail_at(c, s->last->line, s->last->column, "'%s' is already declared as %s", s->name, kind);
+            if (let_named(c, s->name) >= 0 || loop_named(c, s->name) >= 0)
+                fail_at(c, s->last->line, s->last->column, "'%s' is already a let or a for's name here", s->name);
             if (s->low) { /* a slice: the keys from low up to before high */
                 Type key = keyed_by(c, list) ? field_kind(record_of(c, list), (unsigned)c->list_key[list] - 1) : TEXT;
                 if (key != NUM && key != I64)
@@ -2881,20 +3000,28 @@ static void statements(Compiler *c, const Stmt *s) {
                 expect_kind(c, s->low, wanted(c, s->low, true, 0, key), key);
                 expect_kind(c, s->high, wanted(c, s->high, true, 1, key), key);
             }
-            unsigned at = c->code_count, jump = 0;
+            unsigned at = c->code_count, jump = 0, loop = c->loop_count++;
             emit(c, s->line, s->column, EACH, 0, 0);
-            c->walking = true;
-            c->walk_list = list;
-            c->walk_scope = c->scope;
-            memcpy(c->walk_name, s->name, NAME);
+            memcpy(c->loops[loop].name, s->name, NAME);
+            c->loops[loop].list = list;
+            c->loops[loop].item = -1;
+            c->loops[loop].scope = c->scope;
             if (s->value) {
                 truth(c, s->value, true, 0, "where");
                 jump = c->code_count;
                 emit(c, s->line, s->column, JZ, 0, 0);
             }
+            if (holds_walk(s->then)) { /* the walks within read this item from a local */
+                if (c->local_slots == LOCALS) fail_at(c, s->line, s->column, "at most %d lets are allowed in a handler", LOCALS);
+                c->loops[loop].item = (int)c->local_slots++;
+                emit(c, s->line, s->column, ROW, (uint32_t)list, 0);
+                emit(c, s->line, s->column, LOCAL_STORE, (uint32_t)c->loops[loop].item | 1u << 8 | (uint32_t)list << 16, 0);
+            }
+            ++c->nested;
             statements(c, s->then);
+            --c->nested;
             if (s->value) c->code[jump].arg = c->code_count;
-            c->walking = false;
+            --c->loop_count;
             bool empty = c->code_count == at + 1;
             if (empty && !s->low) c->code_count = at; /* nothing to do for any item */
             else {
@@ -2910,6 +3037,7 @@ static void statements(Compiler *c, const Stmt *s) {
             truth(c, s->value, true, 0, "if");
             unsigned jump = c->code_count;
             emit(c, s->line, s->column, JZ, 0, 0);
+            ++c->nested;
             statements(c, s->then);
             if (s->otherwise) {
                 unsigned skip = c->code_count;
@@ -2918,8 +3046,46 @@ static void statements(Compiler *c, const Stmt *s) {
                 statements(c, s->otherwise);
                 c->code[skip].arg = c->code_count;
             } else c->code[jump].arg = c->code_count;
+            --c->nested;
+            break;
+        }
+        case S_COUNT: {
+            /* LOOP and the block after it, run once for each value from low up to before high, the value in a local:
+             * numbers (whole), or i64s when either is one. */
+            if (c->loop_count == NESTING) fail_at(c, s->line, s->column, "fors nest at most %d deep", NESTING);
+            const char *kind = declared_kind(c, s->name);
+            if (kind) fail_at(c, s->line, s->column, "'%s' is already declared as %s", s->name, kind);
+            if (let_named(c, s->name) >= 0 || loop_named(c, s->name) >= 0)
+                fail_at(c, s->line, s->column, "'%s' is already a let or a for's name here", s->name);
+            if (c->local_slots == LOCALS || c->local_count == LOCALS)
+                fail_at(c, s->line, s->column, "at most %d lets are allowed in a handler", LOCALS);
+            bool integer = probe(c, s->low, true, 0) == I64 || probe(c, s->high, true, 0) == I64;
+            Type type = integer ? I64 : NUM;
+            expect_kind(c, s->low, wanted(c, s->low, true, 0, type), type);
+            expect_kind(c, s->high, wanted(c, s->high, true, 1, type), type);
+            unsigned scope = c->local_count, local = c->local_count++, loop = c->loop_count++, at = c->code_count;
+            memcpy(c->locals[local].name, s->name, NAME);
+            c->locals[local].slot = c->local_slots++;
+            c->locals[local].kind = (Kind){type, -1};
+            c->locals[local].list = -1;
+            c->locals[local].counter = true;
+            memcpy(c->loops[loop].name, s->name, NAME);
+            c->loops[loop].list = -1;
+            c->loops[loop].item = -1;
+            c->loops[loop].scope = c->scope;
+            emit(c, s->line, s->column, LOOP, 0, 0);
+            ++c->nested;
+            statements(c, s->then);
+            --c->nested;
+            c->code[at].arg = c->locals[local].slot | (integer ? LOOP_INTEGER : 0) | (c->code_count - at - 1) << 16;
+            --c->loop_count;
+            c->local_count = scope;
             break;
         }
+        case S_BREAK:
+            if (!c->loop_count) fail_at(c, s->line, s->column, "break ends a for; this one is outside any");
+            emit(c, s->line, s->column, BREAK, 0, 0);
+            break;
         }
     }
     c->local_count = scope;
@@ -2962,6 +3128,50 @@ static uint32_t intern(unsigned char *strings, size_t *used, const char *text) {
 
 /* A message's rows field fills a list of its own, named by the input and the
  * field (order.lines): a state that holds rows only while its event runs. */
+/* A let's list (let x: list of R) is a state of its own, let.x: an event's
+ * list (Pure 018), one for the lets of that name in the handlers' own
+ * blocks, which hold one record keyed one way; no two handlers of one event
+ * have one, so each begins empty. */
+static void event_lists(Compiler *c) {
+    for (unsigned h = 0; h < c->handler_count; ++h)
+        for (const Stmt *s = c->handlers[h].body; s; s = s->next) {
+            if (s->kind != S_LET || !s->listed) continue;
+            char path[2 * NAME];
+            snprintf(path, sizeof(path), "let.%s", s->name);
+            if (strlen(path) >= NAME)
+                fail_at(c, s->line, s->column, "a let's list has a name of %d characters at most", NAME - 5);
+            int found = -1;
+            for (unsigned i = 0; i < c->states; ++i)
+                if (c->state_event[i] && !strcmp(c->state_names[i], path)) found = (int)i;
+            if (found >= 0) {
+                if (strcmp(c->state_target[found], s->member) || c->state_library[found] != s->library ||
+                    strcmp(c->state_key[found], s->key))
+                    fail_at(c, s->line, s->column, "'%s' is a let's list of another record or key in another handler; one name "
+                            "holds one kind of list", s->name);
+                for (unsigned k = 0; k < h; ++k) {
+                    if (strcmp(c->handlers[k].input, c->handlers[h].input) || c->handlers[k].edge != c->handlers[h].edge) continue;
+                    for (const Stmt *t = c->handlers[k].body; t; t = t->next)
+                        if (t->kind == S_LET && t->listed && !strcmp(t->name, s->name))
+                            fail_at(c, s->line, s->column, "another handler of this event has a list '%s'; name this one apart",
+                                    s->name);
+                }
+                continue;
+            }
+            if (c->states == STATES) fail_at(c, s->line, s->column, "at most 32 states are allowed, a let's list among them");
+            unsigned i = c->states++;
+            memcpy(c->state_names[i], path, strlen(path) + 1);
+            c->state_types[i] = STATE_LIST;
+            c->state_event[i] = true;
+            memcpy(c->state_target[i], s->member, NAME);
+            c->state_library[i] = s->library;
+            memcpy(c->state_key[i], s->key, NAME);
+            c->state_key_line[i] = s->key_line;
+            c->state_key_column[i] = s->key_column;
+            c->state_line[i] = s->line;
+            c->state_column[i] = s->column;
+        }
+}
+
 static void rows_lists(Compiler *c) {
     for (unsigned i = 0; i < c->input_count; ++i) {
         Input *in = &c->inputs[i];
@@ -3024,6 +3234,7 @@ static void generate(Compiler *c, unsigned char **module, size_t *size) {
     uint32_t events[HANDLERS], state_ref[STATES] = {0};
     int handler_input[HANDLERS];
     rows_lists(c);
+    event_lists(c);
     pull_records(c);
     for (unsigned i = 0; i < c->states; ++i) {
         if (c->state_types[i] == STATE_TEXT) {
@@ -3188,7 +3399,8 @@ static void generate(Compiler *c, unsigned char **module, size_t *size) {
         else if (c->state_types[i] == STATE_I64) p = put64(p, (uint64_t)c->state_integer[i]);
         else { /* flags: a mark (1: the cursor stays), or a keyed list's key field + 1 */
             p = put32(p, state_ref[i]);
-            p = put32(p, c->state_types[i] == STATE_LIST ? (c->state_rows[i] ? LIST_ROWS : (uint32_t)c->list_key[i]) :
+            p = put32(p, c->state_types[i] == STATE_LIST ? (c->state_rows[i] || c->state_event[i] ? LIST_ROWS : 0) |
+                                                           (uint32_t)c->list_key[i] :
                          c->state_stays[i] ? 1 : 0);
         }
     }