aboutsummaryrefslogtreecommitdiff
path: root/src/lib/icon.zc
diff options
context:
space:
mode:
Diffstat (limited to 'src/lib/icon.zc')
-rw-r--r--src/lib/icon.zc623
1 files changed, 623 insertions, 0 deletions
diff --git a/src/lib/icon.zc b/src/lib/icon.zc
new file mode 100644
index 0000000..646a832
--- /dev/null
+++ b/src/lib/icon.zc
@@ -0,0 +1,623 @@
+namespace icon;
+include rt, run;
+
+// structured runtime transformations of compiler token lists.
+// token storage follows run.tokens: count, then kind, value and source line.
+// edits create independent lists; publication recompiles a function only after
+// delimiter validation. captures match complete balanced token ranges.
+
+int icon_error;
+
+int icon_eq(word* a, int ai, word* b, int bi, int n) {
+ int i = 0;
+ while (i < n) {
+ if (a[1 + (ai + i) * 3] != b[1 + (bi + i) * 3] || a[2 + (ai + i) * 3] != b[2 + (bi + i) * 3]) return 0;
+ i++;
+ }
+ return 1;
+}
+int icon_value(word* q, int i) { if (i < 0 || i >= q[0]) return 0; return q[2 + i * 3]; }
+int icon_kind(word* q, int i) { if (i < 0 || i >= q[0]) return 0; return q[1 + i * 3]; }
+int icon_is(word* q, int i, char* s) {
+ int kind = run.T_OP; if (s[0] >= 'a' && s[0] <= 'z') kind = run.T_ID;
+ return icon_kind(q, i) == kind && icon_value(q, i) == run.intern(s);
+}
+int icon_open(int v) { return v == run.intern("(") || v == run.intern("[") || v == run.intern("{"); }
+int icon_close(int v) { return v == run.intern(")") || v == run.intern("]") || v == run.intern("}"); }
+int icon_pair(int a, int b) {
+ return (a == run.intern("(") && b == run.intern(")")) || (a == run.intern("[") && b == run.intern("]")) || (a == run.intern("{") && b == run.intern("}"));
+}
+int icon_declaration(word* q, int start, int binding) {
+ int first = icon_value(q, start), i = start;
+ if (icon_kind(q, start) != run.T_ID || (first != run.intern("let") && first != run.intern("const") && !run.istypename(first))) return 0;
+ while (i < binding) { if (icon_is(q, i, "(") || icon_is(q, i, "=")) return 0; i++; }
+ return binding > start;
+}
+// locate a simple declaration at a statement boundary, including nested blocks.
+// result records [type start, binding position, semicolon, statement start].
+int icon_locate_declaration(word* q, int id, word* result) {
+ int start = 0, i, depth, v, binding, comma, type_start;
+ while (start < q[0]) {
+ if (start && !icon_is(q, start - 1, ";") && !icon_is(q, start - 1, "{") && !icon_is(q, start - 1, "}")) { start++; continue; }
+ type_start = start; if (icon_is(q, type_start, "const")) type_start++;
+ if (icon_kind(q, type_start) != run.T_ID || (!icon_is(q, type_start, "let") && !run.istypename(icon_value(q, type_start)))) { start++; continue; }
+ i = type_start; depth = 0; binding = -1; comma = 0;
+ while (i < q[0]) {
+ v = icon_value(q, i);
+ if (!depth && v == id && icon_kind(q, i) == run.T_ID && binding < 0 && icon_declaration(q, type_start, i) && (icon_is(q, i + 1, "=") || icon_is(q, i + 1, ";") || icon_is(q, i + 1, ",") || icon_is(q, i + 1, "("))) binding = i;
+ if (icon_kind(q, i) == run.T_OP) {
+ if (icon_open(v)) depth++;
+ else if (icon_close(v)) { if (!depth) break; depth--; }
+ if (!depth && v == run.intern(",")) comma = 1;
+ if (!depth && v == run.intern(";")) {
+ if (binding >= 0) {
+ if (comma || icon_is(q, binding + 1, "(")) return 0;
+ result[0] = type_start; result[1] = binding; result[2] = i; result[3] = start; return 1;
+ }
+ break;
+ }
+ }
+ i++;
+ }
+ start++;
+ }
+ return 0;
+}
+int icon_balanced(word* q, int a, int b) {
+ word* stack = rt.new(b - a + 1); int n = 0, i = a, v, valid = 1;
+ while (i < b) {
+ v = icon_value(q, i);
+ if (icon_kind(q, i) == run.T_OP) {
+ if (icon_open(v)) { stack[n] = v; n++; }
+ else if (icon_close(v)) { if (!n || !icon_pair(stack[n - 1], v)) { valid = 0; break; } n--; }
+ }
+ i++;
+ }
+ if (n) valid = 0;
+ rt.free(stack);
+ return valid;
+}
+word* .u icon_slice(word* q, int a, int b) {
+ word* r = rt.new(1 + (b - a) * 3); int i = 0; r[0] = b - a;
+ while (i < (b - a) * 3) { r[1 + i] = q[1 + a * 3 + i]; i++; }
+ return r;
+}
+word* .u icon_splice(word* q, int a, int b, word* insert) {
+ int n = q[0] - (b - a) + insert[0], i = 0, j = 0;
+ word* r = rt.new(1 + n * 3); r[0] = n;
+ while (i < a * 3) { r[1 + j] = q[1 + i]; i++; j++; }
+ i = 0; while (i < insert[0] * 3) { r[1 + j] = insert[1 + i]; i++; j++; }
+ i = b * 3; while (i < q[0] * 3) { r[1 + j] = q[1 + i]; i++; j++; }
+ return r;
+}
+// capture classes use integer literals, identifiers, expressions, statements
+// or blocks. a named capture records its exact token range for substitution.
+int icon_class(int name) {
+ if (name == run.intern("int")) return 1;
+ if (name == run.intern("name")) return 2;
+ if (name == run.intern("expr")) return 3;
+ if (name == run.intern("stmt")) return 4;
+ if (name == run.intern("block")) return 5;
+ return 0;
+}
+int icon_pattern(word* q) {
+ int i = 0;
+ if (!q || q[0] <= 0 || !icon_balanced(q, 0, q[0])) return 0;
+ while (i < q[0]) {
+ if (icon_is(q, i, "$")) {
+ if (icon_kind(q, i + 1) != run.T_ID || !icon_class(icon_value(q, i + 1))) return 0;
+ i += 2;
+ if (icon_is(q, i, ":")) { if (icon_kind(q, i + 1) != run.T_ID || icon_class(icon_value(q, i + 1))) return 0; i += 2; }
+ } else i++;
+ }
+ return 1;
+}
+int icon_precedence(int name) {
+ if (name == run.intern("||")) return 1;
+ if (name == run.intern("&&")) return 2;
+ if (name == run.intern("|")) return 3;
+ if (name == run.intern("^")) return 4;
+ if (name == run.intern("&")) return 5;
+ if (name == run.intern("==") || name == run.intern("!=")) return 6;
+ if (name == run.intern("<") || name == run.intern("<=") || name == run.intern(">") || name == run.intern(">=")) return 7;
+ if (name == run.intern("<<") || name == run.intern(">>")) return 8;
+ if (name == run.intern("+") || name == run.intern("-")) return 9;
+ if (name == run.intern("*") || name == run.intern("/") || name == run.intern("%")) return 10;
+ return 0;
+}
+// recognize expression structure before matching a variable-length capture.
+// this excludes statement keywords and incomplete operator sequences.
+int icon_expression(word* q, int start, int end, int minimum) {
+ int i = start, v, kind, priority, next;
+ if (i >= end) return -1;
+ v = icon_value(q, i); kind = icon_kind(q, i);
+ if (kind == run.T_OP && (v == run.intern("!") || v == run.intern("~") || v == run.intern("+") || v == run.intern("-") || v == run.intern("*") || v == run.intern("&"))) {
+ i = icon_expression(q, i + 1, end, 11); if (i < 0) return -1;
+ } else if (icon_is(q, i, "(")) {
+ i = icon_expression(q, i + 1, end, 1); if (i < 0 || !icon_is(q, i, ")")) return -1; i++;
+ } else if (kind == run.T_NUM || kind == run.T_FLT || kind == run.T_STR || kind == run.T_BSTR || kind == run.T_ID) {
+ if (kind == run.T_ID && (v == run.intern("return") || v == run.intern("let") || v == run.intern("if") || v == run.intern("while") || v == run.intern("for") || v == run.intern("else") || v == run.intern("break") || v == run.intern("continue") || v == run.intern("do") || v == run.intern("switch") || v == run.intern("const"))) return -1;
+ i++;
+ } else return -1;
+ while (i < end) {
+ if (icon_is(q, i, "(") || icon_is(q, i, "[")) {
+ v = icon_value(q, i); i++;
+ if (v != run.intern("(") || !icon_is(q, i, ")")) {
+ while (1) {
+ i = icon_expression(q, i, end, 1); if (i < 0) return -1;
+ if (v == run.intern("(") && icon_is(q, i, ",")) { i++; continue; } break;
+ }
+ }
+ if (i >= end || icon_kind(q, i) != run.T_OP || !icon_pair(v, icon_value(q, i))) return -1; i++; continue;
+ }
+ if (icon_is(q, i, ".")) { if (i + 1 >= end || icon_kind(q, i + 1) != run.T_ID) return -1; i += 2; continue; }
+ if (icon_is(q, i, "++") || icon_is(q, i, "--")) { i++; continue; }
+ if (minimum == 1 && icon_is(q, i, "?")) {
+ i = icon_expression(q, i + 1, end, 1); if (i < 0 || !icon_is(q, i, ":")) return -1;
+ i = icon_expression(q, i + 1, end, 1); if (i < 0) return -1; continue;
+ }
+ priority = 0; if (icon_kind(q, i) == run.T_OP) priority = icon_precedence(icon_value(q, i)); if (!priority || priority < minimum) break;
+ next = icon_expression(q, i + 1, end, priority + 1); if (next < 0) return -1; i = next;
+ }
+ return i;
+}
+int icon_range(word* q, int a, int b, int kind) {
+ if (a < 0 || a >= b || b > q[0]) return 0;
+ if (kind == 1) return b == a + 1 && icon_kind(q, a) == run.T_NUM;
+ if (kind == 2) return b == a + 1 && icon_kind(q, a) == run.T_ID;
+ if (kind == 3) return icon_expression(q, a, b, 1) == b;
+ if (kind == 5) return icon_is(q, a, "{") && icon_mate(q, a) == b - 1;
+ if (kind == 4) return icon_statement_end(q, a) == b;
+ return icon_expression(q, a, b, 1) == b;
+}
+// recursively match a pattern with backtracking at balanced capture boundaries.
+// captures contain count followed by [name, start, end, class] records.
+int icon_match(word* q, int at, word* p, int pi, word* caps) {
+ int kind, name, next, end, old, i;
+ if (pi == p[0]) return at + 1;
+ if (at >= q[0]) return 0;
+ if (!icon_is(p, pi, "$")) {
+ if (!icon_eq(q, at, p, pi, 1)) return 0;
+ return icon_match(q, at + 1, p, pi + 1, caps);
+ }
+ if (pi + 1 >= p[0]) return 0;
+ name = icon_value(p, pi + 1); kind = icon_class(name); next = pi + 2;
+ if (!kind) return 0;
+ if (icon_is(p, next, ":")) { name = icon_value(p, next + 1); next += 2; if (!name) return 0; }
+ else name = 0;
+ old = caps[0]; end = at + 1;
+ if (kind == 4) end = icon_statement_end(q, at);
+ if (kind == 5) { if (!icon_is(q, at, "{")) return 0; end = icon_mate(q, at) + 1; }
+ if (end <= at) return 0;
+ while (end <= q[0]) {
+ if (icon_range(q, at, end, kind)) {
+ i = 0;
+ while (i < old) {
+ if (name && caps[1 + i * 4] == name) {
+ if (end - at != caps[3 + i * 4] - caps[2 + i * 4] || !icon_eq(q, at, q, caps[2 + i * 4], end - at)) break;
+ }
+ i++;
+ }
+ if (i == old) {
+ caps[0] = old + 1; caps[1 + old * 4] = name; caps[2 + old * 4] = at; caps[3 + old * 4] = end; caps[4 + old * 4] = kind;
+ i = icon_match(q, end, p, next, caps);
+ if (i) return i;
+ caps[0] = old;
+ }
+ }
+ if (kind != 3) break;
+ end++;
+ }
+ return 0;
+}
+int icon_capture(word* caps, int name, int ordinal) {
+ int c = 0, kind = icon_class(name), k = 0;
+ while (c < caps[0]) {
+ if (!kind) { if (caps[1 + c * 4] == name) return c + 1; }
+ else if (caps[4 + c * 4] == kind) { if (k == ordinal) return c + 1; k++; }
+ c++;
+ }
+ return 0;
+}
+word* .u icon_expand(word* q, word* replacement, word* caps) {
+ int n = 0, i = 0, j = 0, c, name, kind, k, seen[6], a, b;
+ k = 0; while (k < 6) { seen[k] = 0; k++; }
+ while (i < replacement[0]) {
+ if (icon_is(replacement, i, "$")) {
+ if (icon_kind(replacement, i + 1) != run.T_ID) { icon_error = 3; return 0; }
+ name = icon_value(replacement, i + 1); kind = icon_class(name); c = icon_capture(caps, name, seen[kind]);
+ if (!c) { icon_error = 3; return 0; } c--;
+ n += caps[3 + c * 4] - caps[2 + c * 4]; if (kind) seen[kind]++; i += 2;
+ } else { n++; i++; }
+ }
+ word* r = rt.new(1 + n * 3); i = 0;
+ k = 0; while (k < 6) { seen[k] = 0; k++; }
+ while (i < replacement[0]) {
+ if (icon_is(replacement, i, "$")) {
+ name = icon_value(replacement, i + 1); kind = icon_class(name); c = icon_capture(caps, name, seen[kind]) - 1;
+ if (kind) seen[kind]++;
+ a = caps[2 + c * 4] * 3; b = caps[3 + c * 4] * 3;
+ while (a < b) { r[1 + j] = q[1 + a]; a++; j++; }
+ i += 2;
+ } else {
+ k = 0; while (k < 3) { r[1 + j] = replacement[1 + i * 3 + k]; j++; k++; } i++;
+ }
+ }
+ r[0] = j / 3;
+ if (!icon_balanced(r, 0, r[0])) { rt.free(r); icon_error = 1; return 0; }
+ return r;
+}
+
+// resumable frames retain their own token list and explicit binding maps.
+// [tokens, position, state, result, error, locals, globals, blocks, steps].
+
+// locate a binding in a frame map by its interned name.
+int icon_binding(word map, int name) {
+ while (map) { if (map[0] == name) return map; map = map[2]; }
+ return 0;
+}
+int icon_read(word binding) { if (binding[3]) return *binding[3]; return binding[1]; }
+int icon_store(word*.m frame, int column, int name, int value) {
+ word entry = icon_binding(frame[column], name);
+ if (!entry) {
+ word* node = rt.new(4); node[0] = name; node[1] = value; node[2] = frame[column]; node[3] = 0; frame[column] = node; return value;
+ }
+ entry[1] = value; if (entry[3]) *entry[3] = value; return value;
+}
+int icon_declare(word*.m frame, int name, int value) {
+ word* node = rt.new(4); node[0] = name; node[1] = value; node[2] = frame[5]; node[3] = 0; frame[5] = node; return value;
+}
+int icon_fail(word frame) { frame[2] = 2; frame[4] = 5; icon_error = 5; return 0; }
+int icon_end(word* q, int start) {
+ int depth = 0, i = start, v;
+ while (i < q[0]) {
+ v = icon_value(q, i);
+ if (icon_kind(q, i) == run.T_OP) {
+ if (icon_open(v)) depth++;
+ else if (icon_close(v)) { if (!depth) return i; depth--; }
+ if (!depth && v == run.intern(";")) return i;
+ }
+ i++;
+ }
+ return i;
+}
+int icon_mate(word* q, int start) {
+ int depth = 1, i = start + 1, v;
+ while (i < q[0]) {
+ v = icon_value(q, i);
+ if (icon_kind(q, i) == run.T_OP) {
+ if (icon_open(v)) depth++; else if (icon_close(v)) depth--;
+ if (!depth) return i;
+ }
+ i++;
+ }
+ return -1;
+}
+// find one statement boundary; control-flow captures require braced bodies.
+int icon_statement_end(word* q, int start) {
+ int close, end;
+ if (icon_is(q, start, "{")) { close = icon_mate(q, start); if (close < 0) return -1; return close + 1; }
+ if (icon_is(q, start, "if") || icon_is(q, start, "while")) {
+ if (!icon_is(q, start + 1, "(")) return -1;
+ close = icon_mate(q, start + 1);
+ if (close < 0 || !icon_is(q, close + 1, "{")) return -1;
+ end = icon_mate(q, close + 1); if (end < 0) return -1; end++;
+ if (icon_is(q, start, "if") && icon_is(q, end, "else")) {
+ if (!icon_is(q, end + 1, "{")) return -1;
+ close = icon_mate(q, end + 1); if (close < 0) return -1; return close + 1;
+ }
+ return end;
+ }
+ end = icon_end(q, start);
+ if (!icon_is(q, end, ";")) return -1;
+ return end + 1;
+}
+// construct a compiler return body in one allocation, retaining source lines.
+word* .u icon_eval_tokens(word* q, int start, int end) {
+ int count = end - start;
+ word* expr = rt.new(7 + count * 3); expr[0] = count + 2;
+ expr[1] = run.T_ID; expr[2] = run.intern("return"); expr[3] = 1;
+ if (count) rt.copy_w(expr + 4, q + 1 + start * 3, count * 3);
+ expr[4 + count * 3] = run.T_OP; expr[5 + count * 3] = run.intern(";"); expr[6 + count * 3] = 1;
+ return expr;
+}
+// scalar frame substitution cannot preserve lvalue operations or implicit
+// program-global reads. reject these before compiling or executing a range.
+int icon_frame_expression(word frame, int start, int end) {
+ word* q = frame[0]; int i = start, s; word binding;
+ if (!icon_range(q, start, end, 3)) return 0;
+ while (i < end) {
+ if (icon_is(q, i, "++") || icon_is(q, i, "--")) return 0;
+ if (icon_kind(q, i) == run.T_ID && !icon_is(q, i - 1, ".")) {
+ binding = icon_binding(frame[5], icon_value(q, i));
+ if (!binding) binding = icon_binding(frame[6], icon_value(q, i));
+ if (!binding) {
+ s = run.lookups(icon_value(q, i));
+ if (s < 0 || (run.skind[s] != run.K_FN && run.skind[s] != run.K_CONST)) return 0;
+ }
+ }
+ i++;
+ }
+ return 1;
+}
+int icon_frame_eval(word frame, int start, int end) {
+ word* expr = icon_eval_tokens(frame[0], start, end);
+ int i = 1; word binding;
+ while (i < expr[0] - 1) {
+ if (icon_kind(expr, i) == run.T_ID && !icon_is(expr, i - 1, ".")) {
+ binding = icon_binding(frame[5], icon_value(expr, i));
+ if (!binding) binding = icon_binding(frame[6], icon_value(expr, i));
+ if (binding) { expr[1 + i * 3] = run.T_NUM; expr[2 + i * 3] = icon_read(binding); }
+ }
+ i++;
+ }
+ int result = run.eval(expr); rt.free(expr); return result;
+}
+int icon_block(word*.m frame, int open, int resume) {
+ int close = icon_mate(frame[0], open);
+ if (close < 0) return icon_fail(frame);
+ word block = rt.new(4); block[0] = close; block[1] = resume; block[2] = frame[7]; block[3] = frame[5]; frame[7] = block; frame[1] = open + 1; return 1;
+}
+
+struct icon {
+ // the last transformation status: 0 success, 1 invalid delimiters,
+ // 2 invalid range or declaration, 3 unresolved replacement capture,
+ // 4 unavailable function metadata, 5 unsupported stepping syntax,
+ // 6 rejected function publication.
+ static int error() { return icon_error; }
+ // check token delimiters without compiling or executing the list.
+ static int validate(word* q) { icon_error = 0; if (!q || q[0] < 0 || !icon_balanced(q, 0, q[0])) { icon_error = 1; return 0; } return 1; }
+ // return an independent token list with [start, end) replaced by insert.
+ static word* .u splice(word* q, int start, int end, word* insert) {
+ icon_error = 0;
+ if (!q || !insert || q[0] < 0 || insert[0] < 0 || start < 0 || end < start || end > q[0]) { icon_error = 2; return 0; }
+ word* r = icon_splice(q, start, end, insert);
+ if (!icon_balanced(r, 0, r[0])) { rt.free(r); icon_error = 1; return 0; }
+ return r;
+ }
+ // replace each nonoverlapping pattern match. inserted tokens are not
+ // searched again. the input and templates remain unchanged.
+ static word* .u rewrite(word* q, word* pattern, word* replacement) {
+ icon_error = 0;
+ if (!q || q[0] < 0 || !replacement || replacement[0] < 0 || !icon_pattern(pattern) || !icon_balanced(q, 0, q[0])) { icon_error = 1; return 0; }
+ word* result = icon_slice(q, 0, q[0]); word* caps = rt.new(1 + pattern[0] * 4); word* insert, next;
+ int at = 0, end;
+ while (at < result[0]) {
+ caps[0] = 0; end = icon_match(result, at, pattern, 0, caps);
+ if (!end) { at++; continue; }
+ insert = icon_expand(result, replacement, caps);
+ if (!insert) { rt.free(result); rt.free(caps); return 0; }
+ next = icon_splice(result, at, end - 1, insert); at += insert[0];
+ rt.free(insert); rt.free(result); result = next;
+ }
+ rt.free(caps); return result;
+ }
+ // transform retained function tokens and publish the compiled replacement.
+ // references to the original entry continue to use the published version.
+ static int find_replace(word function, word* pattern, word* replacement) {
+ icon_error = 0;
+ if (!replacement || replacement[0] < 0 || !icon_pattern(pattern)) { icon_error = 1; return 0; }
+ word* q = run.function_tokens(function);
+ if (!q) { icon_error = 4; return 0; }
+ word* caps = rt.new(1 + pattern[0] * 4); int i = 0, end, count = 0;
+ while (i < q[0]) { caps[0] = 0; end = icon_match(q, i, pattern, 0, caps); if (end) { count++; i = end - 1; } else i++; }
+ rt.free(caps);
+ if (!count) { rt.free(q); return 0; }
+ word* changed = icon.rewrite(q, pattern, replacement); rt.free(q);
+ if (!changed) return 0;
+ int published = run.replace_function(function, changed); rt.free(changed);
+ if (!published) { icon_error = 6; return 0; }
+ return count;
+ }
+ // remove a complete declaration statement containing the requested name.
+ // declarations containing multiple bindings are rejected to preserve them.
+ static word* .u undeclare(word* q, char* name) {
+ icon_error = 0;
+ int declaration[4];
+ if (!q || q[0] < 0 || !name || !icon_locate_declaration(q, run.intern(name), declaration)) { icon_error = 2; return 0; }
+ word* empty = rt.new(1); empty[0] = 0;
+ word* result = icon.splice(q, declaration[3], declaration[2] + 1, empty); rt.free(empty); return result;
+ }
+ // change the type of the first simple declaration of name.
+ static word* .u change_type(word* q, char* name, word* type) {
+ icon_error = 0;
+ int declaration[4];
+ if (!q || q[0] < 0 || !name || !icon_locate_declaration(q, run.intern(name), declaration)) { icon_error = 2; return 0; }
+ return icon.splice(q, declaration[0], declaration[1], type);
+ }
+ // insert a scoped statement block at the given token boundary.
+ static word* .u insert_block(word* q, int at, word* body) {
+ icon_error = 0;
+ if (!q || !body || body[0] < 0 || at < 0 || at > q[0]) { icon_error = 2; return 0; }
+ word* block = rt.new(7 + body[0] * 3); int i = 0; block[0] = body[0] + 2;
+ block[1] = run.T_OP; block[2] = run.intern("{"); block[3] = 1;
+ while (i < body[0] * 3) { block[4 + i] = body[1 + i]; i++; }
+ block[4 + i] = run.T_OP; block[5 + i] = run.intern("}"); block[6 + i] = 1;
+ word* result = icon.splice(q, at, at, block); rt.free(block); return result;
+ }
+ // evaluate a selected expression using the compiler rather than a text
+ // evaluator. the range must contain one complete expression.
+ static int calculate(word* q, int start, int end) {
+ icon_error = 0;
+ if (!q || start < 0 || end > q[0] || !icon_range(q, start, end, 3)) { icon_error = 2; return 0; }
+ word* expr = icon_eval_tokens(q, start, end);
+ int value = run.eval(expr); rt.free(expr); return value;
+ }
+ // start a resumable evaluation with independent tokens and binding storage.
+ // stepping executes statements through the compiler; no native frame is
+ // suspended or inspected. scalar bindings are visible between statements.
+ static word* .u begin(word* q) {
+ if (!icon.validate(q)) { icon_error = 1; return 0; }
+ word* frame = rt.new(9); int i = 0; while (i < 9) { frame[i] = 0; i++; } frame[0] = icon_slice(q, 0, q[0]); return frame;
+ }
+ // create an explicit frame from a function's retained body. argument values
+ // are supplied through set_local before stepping starts.
+ static word* .u begin_function(int function) {
+ word* q = run.function_tokens(function);
+ if (!q) { icon_error = 4; return 0; }
+ word* frame = icon.begin(q); rt.free(q); return frame;
+ }
+ // set an isolated global binding, or update storage explicitly bound to it.
+ static int set_global(word frame, char* name, int value) { icon_error = 0; return icon_store(frame, 6, run.intern(name), value); }
+ // update the innermost local binding, creating a binding when absent.
+ static int set_local(word frame, char* name, int value) { icon_error = 0; return icon_store(frame, 5, run.intern(name), value); }
+ // bind one existing scalar global explicitly. reads observe its current
+ // value, and subsequent frame assignments update its program storage.
+ static int bind_global(word frame, char* name) {
+ int s = run.lookups(name); icon_error = 0;
+ if (s < 0 || run.skind[s] != run.K_GVAR) { icon_error = 2; return 0; }
+ word type = run.stype[s];
+ if (type && type != run.tint && type != run.tword) { icon_error = 2; return 0; }
+ icon_store(frame, 6, run.intern(name), *run.sval[s]);
+ word binding = icon_binding(frame[6], run.intern(name)); binding[3] = run.sval[s]; return 1;
+ }
+ // read the innermost local binding; a missing binding sets status 2.
+ static int local(word frame, char* name) { icon_error = 0; word b = icon_binding(frame[5], run.intern(name)); if (!b) { icon_error = 2; return 0; } return icon_read(b); }
+ // read an isolated or explicitly connected global binding.
+ static int global(word frame, char* name) { icon_error = 0; word b = icon_binding(frame[6], run.intern(name)); if (!b) { icon_error = 2; return 0; } return icon_read(b); }
+ // frame state: 0 resumable, 1 complete, 2 unsupported statement.
+ static int state(word frame) { return frame[2]; }
+ // the returned value after completion; zero before a return is executed.
+ static int result(word frame) { return frame[3]; }
+ // token index of the next statement or control-flow decision.
+ static int position(word frame) { return frame[1]; }
+ // number of executed statements and control-flow decisions.
+ static int steps(word frame) { return frame[8]; }
+ // number of retained local binding records, including active shadowed records.
+ static int local_count(word frame) { word b = frame[5]; int n = 0; while (b) { n++; b = b[2]; } return n; }
+ // interned name of a local record; zero when index is outside the map.
+ static char* local_name(word frame, int index) { word b = frame[5]; while (b && index > 0) { index--; b = b[2]; } if (!b || index < 0) return 0; return b[0]; }
+ // execute one statement or control-flow decision. returns 1 after progress,
+ // 0 after completion or an unsupported statement. blocks, if and while
+ // require braces; declarations contain one scalar binding.
+ static int step(word frame) {
+ if (!frame || frame[2]) return 0;
+ icon_error = 0;
+ word* q = frame[0]; int at = frame[1], end, name, value, column = 5, v, close, open, alternate;
+ word block, binding;
+ while (frame[7] && at == frame[7][0]) {
+ block = frame[7];
+ while (frame[5] != block[3]) { binding = frame[5]; frame[5] = binding[2]; rt.free(binding); }
+ at = block[1]; frame[7] = block[2]; rt.free(block); frame[1] = at;
+ }
+ if (at >= q[0]) { frame[2] = 1; return 0; }
+ frame[8]++;
+ if (icon_is(q, at, ";")) { frame[1] = at + 1; return 1; }
+ if (icon_is(q, at, "{")) { close = icon_mate(q, at); return icon_block(frame, at, close + 1); }
+ if (icon_is(q, at, "if") || icon_is(q, at, "while")) {
+ if (!icon_is(q, at + 1, "(")) return icon_fail(frame);
+ close = icon_mate(q, at + 1); open = close + 1;
+ if (close < 0 || !icon_is(q, open, "{")) return icon_fail(frame);
+ end = icon_mate(q, open); if (end < 0) return icon_fail(frame);
+ alternate = end + 1;
+ if (icon_is(q, at, "if") && icon_is(q, alternate, "else")) {
+ if (!icon_is(q, alternate + 1, "{")) return icon_fail(frame);
+ }
+ if (!icon_frame_expression(frame, at + 2, close)) return icon_fail(frame);
+ value = icon_frame_eval(frame, at + 2, close);
+ if (icon_is(q, at, "while")) { if (value) return icon_block(frame, open, at); frame[1] = end + 1; return 1; }
+ if (icon_is(q, alternate, "else")) {
+ close = icon_mate(q, alternate + 1);
+ if (value) return icon_block(frame, open, close + 1);
+ return icon_block(frame, alternate + 1, close + 1);
+ }
+ if (value) return icon_block(frame, open, end + 1);
+ frame[1] = end + 1; return 1;
+ }
+ end = icon_end(q, at);
+ if (end >= q[0] || !icon_is(q, end, ";")) return icon_fail(frame);
+ if (icon_is(q, at, "return")) {
+ frame[3] = 0;
+ if (end > at + 1) { if (!icon_frame_expression(frame, at + 1, end)) return icon_fail(frame); frame[3] = icon_frame_eval(frame, at + 1, end); }
+ frame[1] = end + 1; frame[2] = 1; return 1;
+ }
+ if (icon_is(q, at, "let") || icon_is(q, at, "int") || icon_is(q, at, "word")) {
+ if (icon_kind(q, at + 1) != run.T_ID) return icon_fail(frame);
+ name = icon_value(q, at + 1); value = 0;
+ if (end > at + 2) { if (!icon_is(q, at + 2, "=") || !icon_frame_expression(frame, at + 3, end)) return icon_fail(frame); value = icon_frame_eval(frame, at + 3, end); }
+ icon_declare(frame, name, value); frame[1] = end + 1; return 1;
+ }
+ name = icon_value(q, at); binding = icon_binding(frame[5], name);
+ if (!binding) { binding = icon_binding(frame[6], name); column = 6; }
+ if (binding && icon_kind(q, at) == run.T_ID) {
+ v = icon_value(q, at + 1);
+ if (end == at + 2 && (v == run.intern("++") || v == run.intern("--"))) {
+ value = icon_read(binding) + 1; if (v == run.intern("--")) value = icon_read(binding) - 1;
+ } else {
+ if (v != run.intern("=") && v != run.intern("+=") && v != run.intern("-=") && v != run.intern("*=") && v != run.intern("/=")) return icon_fail(frame);
+ if (!icon_frame_expression(frame, at + 2, end)) return icon_fail(frame);
+ value = icon_frame_eval(frame, at + 2, end);
+ if (v == run.intern("+=")) value = icon_read(binding) + value;
+ if (v == run.intern("-=")) value = icon_read(binding) - value;
+ if (v == run.intern("*=")) value = icon_read(binding) * value;
+ if (v == run.intern("/=")) value = icon_read(binding) / value;
+ }
+ icon_store(frame, column, name, value); frame[1] = end + 1; return 1;
+ }
+ return icon_fail(frame);
+ }
+ // execute at most budget statements. returning 0 leaves the frame resumable;
+ // callers can inspect bindings, edit them, then continue with another budget.
+ static int resume(word frame, int budget) { while (budget > 0 && !frame[2]) { icon.step(frame); budget--; } return frame[2]; }
+ // release a frame and all storage it owns.
+ static int close(.d frame) {
+ word b, next; int column = 5;
+ while (column <= 7) { b = frame[column]; while (b) { next = b[2]; rt.free(b); b = next; } column++; }
+ rt.free(frame[0]); rt.free(frame); return 0;
+ }
+}
+
+// public entry points for the icon namespace.
+
+// status of the most recent transformation or binding operation; see docs/ICON.md.
+int error() { return icon.icon.error(); }
+// check delimiter structure only; does not compile or execute tokens.
+int validate(word* q) { return icon.icon.validate(q); }
+// return a new token list with [start, end) replaced; caller owns the result.
+word* .u splice(word* q, int start, int end, word* insert) { return icon.icon.splice(q, start, end, insert); }
+// return a new list with nonoverlapping matches replaced; inputs remain unchanged.
+word* .u rewrite(word* q, word* pattern, word* replacement) { return icon.icon.rewrite(q, pattern, replacement); }
+// publish a transformed function body; returns matches, or 0 on no match or failure.
+int find_replace(word function, word* pattern, word* replacement) { return icon.icon.find_replace(function, pattern, replacement); }
+// remove the first complete single-binding declaration named name; caller owns the result.
+word* .u undeclare(word* q, char* name) { return icon.icon.undeclare(q, name); }
+// replace the type prefix of the first simple declaration named name; caller owns the result.
+word* .u change_type(word* q, char* name, word* type) { return icon.icon.change_type(q, name, type); }
+// insert a scoped block containing body at token boundary at; caller owns the result.
+word* .u insert_block(word* q, int at, word* body) { return icon.icon.insert_block(q, at, body); }
+// compile and evaluate the expression in [start, end); expression calls retain their effects.
+int calculate(word* q, int start, int end) { return icon.icon.calculate(q, start, end); }
+// create a frame with copied tokens and isolated bindings; caller closes the frame.
+word* .u begin(word* q) { return icon.icon.begin(q); }
+// create a frame from retained function tokens; set arguments as locals before stepping.
+word* .u begin_function(int function) { return icon.icon.begin_function(function); }
+// set an isolated global binding, creating it when absent; returns the stored value.
+int set_global(word frame, char* name, int value) { return icon.icon.set_global(frame, name, value); }
+// set the innermost local binding, creating it when absent; returns the stored value.
+int set_local(word frame, char* name, int value) { return icon.icon.set_local(frame, name, value); }
+// connect an int or word program global to the frame; later frame writes update it.
+int bind_global(word frame, char* name) { return icon.icon.bind_global(frame, name); }
+// read a local binding; missing names return 0 and set error status 2.
+int local(word frame, char* name) { return icon.icon.local(frame, name); }
+// read a frame global binding; missing names return 0 and set error status 2.
+int global(word frame, char* name) { return icon.icon.global(frame, name); }
+// return frame state: 0 resumable, 1 complete, or 2 unsupported statement.
+int state(word frame) { return icon.icon.state(frame); }
+// return the value produced by return, or 0 before a return is executed.
+int result(word frame) { return icon.icon.result(frame); }
+// return the token index of the next statement or control-flow decision.
+int position(word frame) { return icon.icon.position(frame); }
+// return the number of statements and control-flow decisions executed.
+int steps(word frame) { return icon.icon.steps(frame); }
+// count retained local records, including shadowed records in active blocks.
+int local_count(word frame) { return icon.icon.local_count(frame); }
+// return the zero-based local record name, or 0 when index is out of range.
+char* local_name(word frame, int index) { return icon.icon.local_name(frame, index); }
+// execute scalar declarations and assignments, standalone ++/--, return, blocks,
+// or braced if/else/while; direct program globals need bind_global first.
+// unsupported syntax sets error status 5.
+int step(word frame) { return icon.icon.step(frame); }
+// execute at most budget steps and return the frame state; frame bindings are scalar int/word values.
+int resume(word frame, int budget) { return icon.icon.resume(frame, budget); }
+// release the frame and owned storage; consumes frame and returns 0.
+int close(.d frame) { return icon.icon.close(d*frame); }
generated by cgit v1.2.3 (git 2.39.1) at 2026-10-27 18:32:03 +0000