workshopsoft/ludic
2
0
Fork 0
Code Issues Pull requests Projects Releases 26 Packages Wiki Activity Actions

Phase 6f: let = immutable, var = mutable (binding-only)

Browse source 
Bindings now signal mutability the way Rust/Swift do, instead of `let` meaning
"local" and `var` meaning "module-level":

  - `let x = e`  -> immutable binding; a later `x = …` is a compile error
    (`cannot assign to immutable 'x' … use var`).
  - `var x = e`  -> mutable binding, at local OR module scope (position decides
    scope; the keyword decides mutability).
  - `const`      -> unchanged (compile-time).

Immutability is of the *binding*, not the object: `let n = new Node; n.kind = 1`
is fine (mutation through the reference); only rebinding `n` is rejected. The
check lives in emit_assign — a direct `name =` whose target is a `let` local
(loc_mut == 0) errors; field/index targets and `var`/param/loop bindings are
unaffected.

Delivered as three reseeds so the self-hosting compiler never had to compile
source its own rules would reject:
  A) add `var` as a local statement + per-local mutability tracking (loc_mut),
     no enforcement;
  B) migrate every reassigned `let` -> `var` across the compiler, runtime and
     examples (337 declarations), driven by a per-function, string/comment-aware
     scan (binding targets only, never `x.f =` / `x[i] =`);
  C) turn on the check. bootstrap-cfree (compiler vs its own source) and every
     golden build (which splices the runtime) then proved zero reassigned `let`
     was missed anywhere.

Also folded in: removed leftover debug instrumentation in block() (a `cur=` /
print_int(777…) trace on the separator-error path) and fixed parse.ludic's stale
header comment (no more `struct`). Reseeded (21711 lines); C-free fixpoint holds;
goldens identical; 17/17; vocab + doc-fences clean.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
Orkun ÇAKILKAYA 2026-08-27 23:52:59 +03:00
parent 573813609c
commit e1d7797e29
38 changed files with 2909 additions and 2778 deletions
Download patch file Download diff file Expand all files Collapse all files

54
runtime/native/core.ludic
View file

@ -79,10 +79,10 @@ fn rt_fill_rect(x: int, y: int, w: int, h: int, c: int) -> void {
let y0 = max(0, y)
let x1 = min(rt_fbw, x + w)
let y1 = min(rt_fbh, y + h)
let j = y0
var j = y0
while j < y1 {
let row = j * rt_fbw
let i = x0
var i = x0
while i < x1 {
poke32(rt_fb, row + i, c)
i = i + 1
@ -108,7 +108,7 @@ fn rt_present() -> void {
# ---- text -----------------------------------------------------------------
fn rt_glyph(x: int, y: int, ch: int, colour: int, sc: int) -> void {
let c = ch
var c = ch
if c >= 97 {
if c <= 122 { c = c - 32 }
}
@ -118,7 +118,7 @@ fn rt_glyph(x: int, y: int, ch: int, colour: int, sc: int) -> void {
let font = rt_font()
for row in 0 .. 7 {
let bits = peek8(font, base + row) - 48
let b = bits
var b = bits
for cc in 0 .. 5 {
let on = b / 16
if on == 1 {
@ -130,9 +130,9 @@ fn rt_glyph(x: int, y: int, ch: int, colour: int, sc: int) -> void {
}
fn rt_text(x: int, y: int, s: str, colour: int, sc: int) -> void {
let i = 0
let cx = x
let ch = peek8(s, 0)
var i = 0
var cx = x
var ch = peek8(s, 0)
while ch != 0 {
rt_glyph(cx, y, ch, colour, sc)
cx = cx + 6 * sc
@ -146,22 +146,22 @@ fn rt_text_int(x: int, y: int, n: int, colour: int, sc: int) -> void {
rt_glyph(x, y, 48, colour, sc)
return
}
let v = n
let cx = x
var v = n
var cx = x
if v < 0 {
rt_glyph(cx, y, 45, colour, sc)
cx = cx + 6 * sc
v = 0 - v
}
let digits = 0
let t = v
var digits = 0
var t = v
while t > 0 {
digits = digits + 1
t = t / 10
}
let p = digits
var p = digits
while p > 0 {
let div = 1
var div = 1
for k in 1 .. p {
div = div * 10
}
@ -196,7 +196,7 @@ fn rt_seed(s: int) -> void {
# xorshift32 (Marsaglia). Runs on the raw 32-bit pattern, so the sign bit is
# masked off only when a caller asks for a number.
fn rt_next_rand() -> int {
let x = rt_rng
var x = rt_rng
x = bxor(x, shl(x, 13))
x = bxor(x, shr(x, 17))
x = bxor(x, shl(x, 5))
@ -238,9 +238,9 @@ fn rt_running() -> bool {
# ---- writing the frame out ------------------------------------------------
fn rt_put_str(buf: ptr, at: int, s: str) -> int {
let i = 0
let n = at
let ch = peek8(s, 0)
var i = 0
var n = at
var ch = peek8(s, 0)
while ch != 0 {
poke8(buf, n, ch)
n = n + 1
@ -255,16 +255,16 @@ fn rt_put_int(buf: ptr, at: int, v: int) -> int {
poke8(buf, at, 48)
return at + 1
}
let digits = 0
let t = v
var digits = 0
var t = v
while t > 0 {
digits = digits + 1
t = t / 10
}
let n = at
let p = digits
var n = at
var p = digits
while p > 0 {
let div = 1
var div = 1
for k in 1 .. p {
div = div * 10
}
@ -280,7 +280,7 @@ fn rt_dump_ppm(path: str) -> void {
if ptr_is_null(f) { return }
let hdr = mem_alloc(64)
let n = rt_put_str(hdr, 0, "P6\n")
var n = rt_put_str(hdr, 0, "P6\n")
n = rt_put_int(hdr, n, rt_fbw)
n = rt_put_str(hdr, n, " ")
n = rt_put_int(hdr, n, rt_fbh)
@ -323,8 +323,8 @@ fn rt_map_size(w: int, h: int) -> void {
fn rt_map_row(y: int, s: str) -> void {
if y < 0 { return }
if y >= 64 { return }
let x = 0
let ch = peek8(s, 0)
var x = 0
var ch = peek8(s, 0)
while ch != 0 {
if x >= 96 { return }
poke8(rt_map, y * 96 + x, ch)
@ -347,8 +347,8 @@ fn rt_tile(x: int, y: int) -> int {
var rt_statusbuf: ptr = ptr_null()
fn rt_status(s: str) -> void {
let i = 0
let ch = peek8(s, 0)
var i = 0
var ch = peek8(s, 0)
while ch != 0 {
if i >= 95 { ch = 0 }
if ch != 0 {

60
runtime/native/image.ludic
View file

@ -74,17 +74,17 @@ fn rt_decode_png(path: str) -> bool {
if peek8(d, 0) != 137 { mem_free(d); return false }
if peek8(d, 1) != 80 { mem_free(d); return false }
let w = 0
let h = 0
let bd = 0
let ct = 0
var w = 0
var h = 0
var bd = 0
var ct = 0
let plte = mem_alloc(768)
let trns = mem_alloc(256)
let ntrns = 0
var ntrns = 0
let idat = mem_alloc(size)
let idlen = 0
let i = 8
let done = 0
var idlen = 0
var i = 8
var done = 0
while done == 0 {
if i + 8 > size { done = 1 }
@ -122,12 +122,12 @@ fn rt_decode_png(path: str) -> bool {
if w <= 0 { mem_free(d); return false }
if h <= 0 { mem_free(d); return false }
let channels = 1
var channels = 1
if ct == 2 { channels = 3 }
if ct == 6 { channels = 4 }
if ct == 4 { channels = 2 }
let bppbits = bd * channels
let fbpp = (bppbits + 7) / 8
var fbpp = (bppbits + 7) / 8
if fbpp < 1 { fbpp = 1 }
let stride = (w * bppbits + 7) / 8
let rawlen = h * (stride + 1)
@ -144,13 +144,13 @@ fn rt_decode_png(path: str) -> bool {
let cur = line + 1
let prev = cur - (stride + 1)
for x in 0 .. stride {
let a = 0
let b = 0
let c = 0
var a = 0
var b = 0
var c = 0
if x >= fbpp { a = peek8(raw, cur + x - fbpp) }
if y > 0 { b = peek8(raw, prev + x) }
if x >= fbpp { if y > 0 { c = peek8(raw, prev + x - fbpp) } }
let v = peek8(raw, cur + x)
var v = peek8(raw, cur + x)
if ft == 1 { v = v + a }
if ft == 2 { v = v + b }
if ft == 3 { v = v + (a + b) / 2 }
@ -159,7 +159,7 @@ fn rt_decode_png(path: str) -> bool {
let pa = abs(p - a)
let pb = abs(p - b)
let pc = abs(p - c)
let pick = c
var pick = c
if pb <= pc { pick = b }
if pa <= pb { if pa <= pc { pick = a } }
v = v + pick
@ -174,10 +174,10 @@ fn rt_decode_png(path: str) -> bool {
for y in 0 .. h {
let row = y * (stride + 1) + 1
for x in 0 .. w {
let R = 0
let G = 0
let B = 0
let A = 255
var R = 0
var G = 0
var B = 0
var A = 255
if ct == 6 {
R = peek8(raw, row + x * 4)
G = peek8(raw, row + x * 4 + 1)
@ -206,7 +206,7 @@ fn rt_decode_png(path: str) -> bool {
if ct == 0 {
let bp = x * bd
let s = band(shr(peek8(raw, row + bp / 8), 8 - bd - bp % 8), maxv)
let g = s
var g = s
if bd != 8 { g = s * 255 / maxv }
R = g
G = g
@ -246,9 +246,9 @@ fn rt_blend_px(x: int, y: int, argb: int) -> void {
if y < 0 { return }
if x >= rt_fbw { return }
if y >= rt_fbh { return }
let r = band(shr(argb, 16), 255)
let g = band(shr(argb, 8), 255)
let b = band(argb, 255)
var r = band(shr(argb, 16), 255)
var g = band(shr(argb, 8), 255)
var b = band(argb, 255)
if a != 255 {
let dst = peek32(rt_fb, y * rt_fbw + x)
let dr = band(shr(dst, 16), 255)
@ -324,7 +324,7 @@ fn rt_png_load(path: str) -> int {
let base = id * SPR_SZ * SPR_SZ
for y in 0 .. SPR_SZ {
for x in 0 .. SPR_SZ {
let px = 0
var px = 0
if x < png_w {
if y < png_h {
let c = peek32(png_px, y * png_w + x)
@ -382,13 +382,13 @@ fn rt_sprites_load(path: str) -> void {
let size = rt_file_len
let pal = mem_alloc(128 * 4)
mem_set(pal, 0, 128 * 4)
let cur = 0 - 1
let row = 0
let i = 0
var cur = 0 - 1
var row = 0
var i = 0
while i < size {
let start = i
let len = 0
let j = start
var len = 0
var j = start
while j < size {
let ch = peek8(d, j)
if ch == 10 { j = size } else { len = len + 1; j = j + 1 }
@ -396,7 +396,7 @@ fn rt_sprites_load(path: str) -> void {
let c0 = peek8(d, start)
if c0 == 112 { # 'p' — "pal <char> <rrggbb>"
let ch = peek8(d, start + 4)
let v = 0
var v = 0
for k in 0 .. 6 {
let hv = rt_hexval(peek8(d, start + 6 + k))
if hv >= 0 { v = v * 16 + hv }

24
runtime/native/inflate.ludic
View file

@ -30,7 +30,7 @@ fn z_start(src: ptr, len: int) -> void {
}
fn z_bits(need: int) -> int {
let val = z_bitbuf
var val = z_bitbuf
while z_bitcnt < need {
if z_pos >= z_len {
z_err = 1
@ -79,9 +79,9 @@ fn z_table_build(table: ptr, lengths: ptr, n: int) -> void {
}
fn z_decode(table: ptr) -> int {
let code = 0
let first = 0
let index = 0
var code = 0
var first = 0
var index = 0
for len in 1 .. 16 {
code = bor(code, z_bits(1))
let count = peek32(table, len)
@ -131,7 +131,7 @@ fn z_stored(out: ptr, at: int, cap: int) -> int {
if z_pos + 4 > z_len { return -1 }
let n = peek8(z_src, z_pos) + shl(peek8(z_src, z_pos + 1), 8)
z_pos = z_pos + 4 # LEN then its one's complement
let w = at
var w = at
for i in 0 .. n {
if z_pos >= z_len { return -1 }
if w >= cap { return -1 }
@ -143,8 +143,8 @@ fn z_stored(out: ptr, at: int, cap: int) -> int {
}
fn z_codes(out: ptr, at: int, cap: int, lit: ptr, dist: ptr) -> int {
let w = at
let sym = z_decode(lit)
var w = at
var sym = z_decode(lit)
while sym != 256 {
if z_err != 0 { return -1 }
if sym < 0 { return -1 }
@ -202,7 +202,7 @@ fn z_dynamic_tables(lit: ptr, dist: ptr) -> int {
let clen = z_table_new(19)
z_table_build(clen, lengths, 19)
let n = 0
var n = 0
while n < nlen + ndist {
let sym = z_decode(clen)
if sym < 0 { return 0 }
@ -211,8 +211,8 @@ fn z_dynamic_tables(lit: ptr, dist: ptr) -> int {
n = n + 1
}
if sym >= 16 {
let prev = 0
let rep = 0
var prev = 0
var rep = 0
if sym == 16 {
if n == 0 { return 0 }
prev = peek32(lengths, n - 1)
@ -244,8 +244,8 @@ fn z_inflate(src: ptr, len: int, out: ptr, cap: int) -> int {
z_start(src, len)
let lit = z_table_new(288)
let dist = z_table_new(30)
let w = 0
let final = 0
var w = 0
var final = 0
while final == 0 {
final = z_bits(1)
let btype = z_bits(2)

44
runtime/native/truetype.ludic
View file

@ -144,14 +144,14 @@ fn tt_pick_cmap(id: int, d: ptr, co: int) -> void {
poke32(tt_cfmt, id, 0)
if co < 0 { return }
let n = tt_u16(d, co + 2)
let best = 0 - 1
let bestscore = 0 - 1
var best = 0 - 1
var bestscore = 0 - 1
for i in 0 .. n {
let rec = co + 4 + i * 8
let plat = tt_u16(d, rec)
let enc = tt_u16(d, rec + 2)
let off = tt_u32(d, rec + 4)
let score = 0 - 1
var score = 0 - 1
if plat == 0 { score = 2 }
if plat == 0 { if enc == 4 { score = 4 } }
if plat == 0 { if enc == 6 { score = 4 } }
@ -172,7 +172,7 @@ fn rt_font_load(path: str) -> int {
let d = rt_read_file(path)
if ptr_is_null(d) { return 0 - 1 }
let size = rt_file_len
let base = 0
var base = 0
# a .ttc collection points at its first font
if size >= 16 {
if peek8(d, 0) == 116 { if peek8(d, 1) == 116 { if peek8(d, 2) == 99 { if peek8(d, 3) == 102 {
@ -196,7 +196,7 @@ fn rt_font_load(path: str) -> int {
tt_n = tt_n + 1
pokep(tt_data, id, d)
poke32(tt_size, id, size)
let upem = tt_u16(d, head + 18)
var upem = tt_u16(d, head + 18)
if upem <= 0 { upem = 1000 }
poke32(tt_upem, id, upem)
poke32(tt_locfm, id, tt_i16(d, head + 50))
@ -306,20 +306,20 @@ fn tt_load_outline(id: int, gid: int, a: fixed, b: fixed, c: fixed, e: fixed, dx
if nc >= 0 {
let endpts = g + 10
let npts = 0
var npts = 0
if nc > 0 { npts = tt_u16(d, endpts + (nc - 1) * 2) + 1 }
let p = endpts + nc * 2
var p = endpts + nc * 2
p = p + 2 + tt_u16(d, p) # skip instructions
let flags = mem_alloc(npts + 8)
let i = 0
var i = 0
while i < npts {
let fl = peek8(d, p)
p = p + 1
poke8(flags, i, fl)
i = i + 1
if band(fl, 8) != 0 { # REPEAT
let r = peek8(d, p)
var r = peek8(d, p)
p = p + 1
while r > 0 {
if i < npts { poke8(flags, i, fl); i = i + 1 }
@ -330,7 +330,7 @@ fn tt_load_outline(id: int, gid: int, a: fixed, b: fixed, c: fixed, e: fixed, dx
let xs = mem_alloc((npts + 1) * 4)
let ys = mem_alloc((npts + 1) * 4)
let xv = 0
var xv = 0
for k in 0 .. npts {
let fl = peek8(flags, k)
if band(fl, 2) != 0 {
@ -342,7 +342,7 @@ fn tt_load_outline(id: int, gid: int, a: fixed, b: fixed, c: fixed, e: fixed, dx
}
poke32(xs, k, xv)
}
let yv = 0
var yv = 0
for k in 0 .. npts {
let fl = peek8(flags, k)
if band(fl, 4) != 0 {
@ -355,7 +355,7 @@ fn tt_load_outline(id: int, gid: int, a: fixed, b: fixed, c: fixed, e: fixed, dx
poke32(ys, k, yv)
}
let start = 0
var start = 0
for ci in 0 .. nc {
let last = tt_u16(d, endpts + ci * 2)
for k in start .. last + 1 {
@ -374,14 +374,14 @@ fn tt_load_outline(id: int, gid: int, a: fixed, b: fixed, c: fixed, e: fixed, dx
mem_free(ys)
} else {
# composite glyph: components, each with its own placement and transform
let p = g + 10
let more = 1
var p = g + 10
var more = 1
while more == 1 {
let flags = tt_u16(d, p)
let cgid = tt_u16(d, p + 2)
p = p + 4
let arg1 = 0
let arg2 = 0
var arg1 = 0
var arg2 = 0
if band(flags, 1) != 0 {
arg1 = tt_i16(d, p)
arg2 = tt_i16(d, p + 2)
@ -391,10 +391,10 @@ fn tt_load_outline(id: int, gid: int, a: fixed, b: fixed, c: fixed, e: fixed, dx
arg2 = tt_i8(d, p + 1)
p = p + 2
}
let ca = 1.0
let cb = 0.0
let cc = 0.0
let ce = 1.0
var ca = 1.0
var cb = 0.0
var cc = 0.0
var ce = 1.0
if band(flags, 8) != 0 {
ca = as_fixed(shl(tt_i16(d, p), 2)) # F2Dot14 -> Q16.16
ce = ca
@ -412,8 +412,8 @@ fn tt_load_outline(id: int, gid: int, a: fixed, b: fixed, c: fixed, e: fixed, dx
ce = as_fixed(shl(tt_i16(d, p + 6), 2))
p = p + 8
}
let odx = dx
let ody = dy
var odx = dx
var ody = dy
if band(flags, 2) != 0 {
odx = a * fx(arg1) + c * fx(arg2) + dx
ody = b * fx(arg1) + e * fx(arg2) + dy

78
runtime/native/truetype_raster.ludic
View file

@ -13,8 +13,8 @@ fn ed_add(x0: fixed, y0: fixed, x1: fixed, y1: fixed) -> void {
fn tt_isqrt(v: int) -> int {
if v <= 0 { return 0 }
let r = 0
let b = 32768
var r = 0
var b = 32768
while b > 0 {
let t = r + b
if t * t <= v { r = t }
@ -27,11 +27,11 @@ fn tt_isqrt(v: int) -> int {
fn ed_quad(x0: fixed, y0: fixed, cx: fixed, cy: fixed, x1: fixed, y1: fixed) -> void {
let dx = flr(x1) - flr(x0)
let dy = flr(y1) - flr(y0)
let n = tt_isqrt(dx * dx + dy * dy) / 3
var n = tt_isqrt(dx * dx + dy * dy) / 3
if n < 2 { n = 2 }
if n > 24 { n = 24 }
let px = x0
let py = y0
var px = x0
var py = y0
for i in 1 .. n + 1 {
let t = fx(i) / n
let u = 1.0 - t
@ -63,10 +63,10 @@ fn tt_raster(id: int, gid: int, px: int) -> ptr {
tt_load_outline(id, gid, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0)
if ol_n == 0 { return ptr_null() }
let minx = 999999.0
let miny = 999999.0
let maxx = 0.0 - 999999.0
let maxy = 0.0 - 999999.0
var minx = 999999.0
var miny = 999999.0
var maxx = 0.0 - 999999.0
var maxy = 0.0 - 999999.0
for i in 0 .. ol_n {
let X = peekf(ol_x, i) * scale
let Y = peekf(ol_y, i) * scale
@ -77,8 +77,8 @@ fn tt_raster(id: int, gid: int, px: int) -> ptr {
}
let x0 = flr(minx)
let y0 = flr(miny)
let x1 = flr(maxx) + 1
let y1 = flr(maxy) + 1
var x1 = flr(maxx) + 1
var y1 = flr(maxy) + 1
if maxx == fx(flr(maxx)) { x1 = flr(maxx) }
if maxy == fx(flr(maxy)) { y1 = flr(maxy) }
let W = x1 - x0
@ -93,17 +93,17 @@ fn tt_raster(id: int, gid: int, px: int) -> ptr {
gr_oy = y1
# build edges in supersample space (y grows downward)
let start = 0
var start = 0
for ci in 0 .. ol_ne {
let end = peek32(ol_ends, ci)
let cnt = end - start
if cnt >= 2 {
let first_on = 0 - 1
var first_on = 0 - 1
for i in 0 .. cnt {
if first_on < 0 { if peek32(ol_on, start + i) == 1 { first_on = i } }
}
let sx = 0.0
let sy = 0.0
var sx = 0.0
var sy = 0.0
if first_on < 0 {
# all off-curve: start at the midpoint of the first and last point
let mx = (peekf(ol_x, start) + peekf(ol_x, start + cnt - 1)) / 2
@ -115,9 +115,9 @@ fn tt_raster(id: int, gid: int, px: int) -> ptr {
sx = (peekf(ol_x, start + first_on) * scale - fx(x0)) * TT_SS
sy = (fx(y1) - peekf(ol_y, start + first_on) * scale) * TT_SS
}
let curx = sx
let cury = sy
let step = 0
var curx = sx
var cury = sy
var step = 0
while step < cnt {
let i = (first_on + 1 + step) % cnt
let ix = (peekf(ol_x, start + i) * scale - fx(x0)) * TT_SS
@ -127,11 +127,11 @@ fn tt_raster(id: int, gid: int, px: int) -> ptr {
curx = ix
cury = iy
} else {
let j = (i + 1) % cnt
var j = (i + 1) % cnt
let jx = (peekf(ol_x, start + j) * scale - fx(x0)) * TT_SS
let jy = (fx(y1) - peekf(ol_y, start + j) * scale) * TT_SS
let ex = jx
let ey = jy
var ex = jx
var ey = jy
if peek32(ol_on, start + j) == 1 {
step = step + 1
} else {
@ -157,11 +157,11 @@ fn tt_raster(id: int, gid: int, px: int) -> ptr {
for sy in 0 .. SH {
let yc = fx(sy) + 0.5
let m = 0
var m = 0
for i in 0 .. ed_n {
let ya = peekf(ed_y0, i)
let yb = peekf(ed_y1, i)
let hit = 0
var hit = 0
if ya <= yc { if yb > yc { hit = 1 } }
if yb <= yc { if ya > yc { hit = 1 } }
if hit == 1 {
@ -175,8 +175,8 @@ fn tt_raster(id: int, gid: int, px: int) -> ptr {
for i in 1 .. m {
let kx = peekf(sc_x, i)
let kd = peek32(sc_d, i)
let j = i - 1
let placed = 0
var j = i - 1
var placed = 0
while j >= 0 {
if peekf(sc_x, j) > kx {
pokef(sc_x, j + 1, peekf(sc_x, j))
@ -194,28 +194,28 @@ fn tt_raster(id: int, gid: int, px: int) -> ptr {
poke32(sc_d, 0, kd)
}
}
let wind = 0
var wind = 0
let oy = sy / TT_SS
for i in 0 .. m - 1 {
wind = wind + peek32(sc_d, i)
if wind != 0 {
let xa = peekf(sc_x, i)
let xb = peekf(sc_x, i + 1)
var xa = peekf(sc_x, i)
var xb = peekf(sc_x, i + 1)
if xa < 0.0 { xa = 0.0 }
if xb > fx(SW) { xb = fx(SW) }
if xb > xa {
let ixa = flr(xa)
let ixb = flr(xb) + 1
for sx in ixa .. ixb {
let cxl = xa
let cxr = xb
var cxl = xa
var cxr = xb
if fx(sx) > cxl { cxl = fx(sx) }
if fx(sx + 1) < cxr { cxr = fx(sx + 1) }
let cvr = cxr - cxl
if cvr > 0.0 {
let oxp = sx / TT_SS
if oxp >= 0 { if oxp < W { if oy >= 0 { if oy < H {
let v = peek8(cover, oy * W + oxp) + flr(cvr * unit)
var v = peek8(cover, oy * W + oxp) + flr(cvr * unit)
if v > 255 { v = 255 }
poke8(cover, oy * W + oxp, v)
} } } }
@ -271,7 +271,7 @@ var u8_next: int = 0 # byte index just past the codepoint last decoded
fn tt_utf8(s: str, at: int) -> int {
let c = peek8(s, at)
let extra = 0 - 1
var extra = 0 - 1
if c < 128 { extra = 0 }
if shr(c, 5) == 6 { extra = 1 }
if shr(c, 4) == 14 { extra = 2 }
@ -284,7 +284,7 @@ fn tt_utf8(s: str, at: int) -> int {
u8_next = at + 1
return c
}
let cp = band(c, shr(63, extra))
var cp = band(c, shr(63, extra))
for i in 0 .. extra {
let b = peek8(s, at + 1 + i)
if band(b, 192) != 128 {
@ -333,10 +333,10 @@ fn rt_text_ttf(font: int, x: int, y: int, s: str, colour: int, px: int) -> void
if px <= 0 { return }
let upem = peek32(tt_upem, font)
let scale = fx(px) / upem
let baseline = y + flr(fx(peek32(tt_asc, font)) * scale + 0.5)
var baseline = y + flr(fx(peek32(tt_asc, font)) * scale + 0.5)
let lineh = flr(fx(peek32(tt_asc, font) - peek32(tt_desc, font) + peek32(tt_gap, font)) * scale + 0.5)
let penx = x
let i = 0
var penx = x
var i = 0
while peek8(s, i) != 0 {
let cp = tt_utf8(s, i)
i = u8_next
@ -355,9 +355,9 @@ fn rt_text_w(font: int, s: str, px: int) -> int {
if font < 0 { return 0 }
if font >= tt_n { return 0 }
if px <= 0 { return 0 }
let w = 0
let best = 0
let i = 0
var w = 0
var best = 0
var i = 0
while peek8(s, i) != 0 {
let cp = tt_utf8(s, i)
i = u8_next

20
runtime/native/ui.ludic
View file

@ -196,7 +196,7 @@ fn ui_tw(font: int, s: ptr, size: int) -> int {
if font >= 0 {
if font < tt_n { return rt_text_w(font, s, size) }
}
let n = 0
var n = 0
while peek8(s, n) != 0 { n = n + 1 }
return n * 6 * max(size / 8, 1)
}
@ -219,7 +219,7 @@ fn ui_dir(t: int) -> int {
return 1
}
fn ui_under(i: int, root: int) -> bool {
let k = i
var k = i
while k >= 0 {
if k == root { return true }
k = peek32(ui_parent, k)
@ -229,7 +229,7 @@ fn ui_under(i: int, root: int) -> bool {
# ---- measure: content sizes, children before parents ----------------------
fn ui_measure() -> void {
let i = ui_n - 1
var i = ui_n - 1
while i >= 0 {
if peek32(ui_visible, i) == 0 {
poke32(ui_rw, i, 0)
@ -237,8 +237,8 @@ fn ui_measure() -> void {
} else {
let t = peek32(ui_type, i)
let pad = peek32(ui_pad, i)
let cw = 0
let ch = 0
var cw = 0
var ch = 0
if t == WT_LABEL { cw = 0 - 1 }
if t == WT_BUTTON { cw = 0 - 1 }
if cw == 0 - 1 {
@ -262,9 +262,9 @@ fn ui_measure() -> void {
ch = peek32(ui_h, i)
} else {
let dir = ui_dir(t)
let mainsz = 0
let cross = 0
let nc = 0
var mainsz = 0
var cross = 0
var nc = 0
for c in 0 .. ui_n {
if peek32(ui_parent, c) == i {
if peek32(ui_visible, c) == 1 {
@ -292,8 +292,8 @@ fn ui_measure() -> void {
}
}
}
let rw = peek32(ui_w, i)
let rh = peek32(ui_h, i)
var rw = peek32(ui_w, i)
var rh = peek32(ui_h, i)
if rw == 0 { rw = cw }
if rh == 0 { rh = ch }
poke32(ui_rw, i, rw)

62
runtime/native/ui_draw.ludic
View file

@ -12,9 +12,9 @@ fn ui_arrange(i: int, x: int, y: int) -> void {
let gap = peek32(ui_gap, i)
let innerw = peek32(ui_rw, i) - 2 * pad
let innerh = peek32(ui_rh, i) - 2 * pad
let total = 0
let ng = 0
let grows = 0
var total = 0
var ng = 0
var grows = 0
for c in 0 .. ui_n {
if peek32(ui_parent, c) == i {
if peek32(ui_visible, c) == 1 {
@ -25,16 +25,16 @@ fn ui_arrange(i: int, x: int, y: int) -> void {
}
}
if ng > 1 { total = total + gap * (ng - 1) }
let avail = innerw
var avail = innerw
if dir == 1 { avail = innerh }
let extra = max(avail - total, 0)
let cx = x + pad
let cy = y + pad
var cx = x + pad
var cy = y + pad
for c in 0 .. ui_n {
if peek32(ui_parent, c) == i {
if peek32(ui_visible, c) == 1 {
let kw = peek32(ui_rw, c)
let kh = peek32(ui_rh, c)
var kw = peek32(ui_rw, c)
var kh = peek32(ui_rh, c)
if peek32(ui_grow, c) != 0 {
if grows > 0 {
if dir == 1 { kh = kh + extra / grows } else { kw = kw + extra / grows }
@ -44,13 +44,13 @@ fn ui_arrange(i: int, x: int, y: int) -> void {
poke32(ui_rw, c, kw)
poke32(ui_rh, c, kh)
if dir == 1 {
let ax = x + pad
var ax = x + pad
if al == 1 { ax = x + pad + (innerw - kw) / 2 }
if al == 2 { ax = x + pad + (innerw - kw) }
ui_arrange(c, ax, cy)
cy = cy + kh + gap
} else {
let ay = y + pad
var ay = y + pad
if al == 1 { ay = y + pad + (innerh - kh) / 2 }
if al == 2 { ay = y + pad + (innerh - kh) }
ui_arrange(c, cx, ay)
@ -64,8 +64,8 @@ fn ui_arrange(i: int, x: int, y: int) -> void {
fn ui_layout() -> void {
if ui_active < 0 { return }
ui_measure()
let px = (rt_fbw - peek32(ui_rw, ui_active)) / 2
let py = (rt_fbh - peek32(ui_rh, ui_active)) / 2
var px = (rt_fbw - peek32(ui_rw, ui_active)) / 2
var py = (rt_fbh - peek32(ui_rh, ui_active)) / 2
if peek32(ui_haspos, ui_active) == 1 {
px = peek32(ui_x, ui_active)
py = peek32(ui_y, ui_active)
@ -75,9 +75,9 @@ fn ui_layout() -> void {
# ---- drawing --------------------------------------------------------------
fn ui_lighten(c: int) -> int {
let r = band(shr(c, 16), 255)
let g = band(shr(c, 8), 255)
let b = band(c, 255)
var r = band(shr(c, 16), 255)
var g = band(shr(c, 8), 255)
var b = band(c, 255)
r = r + (255 - r) * 4 / 10
g = g + (255 - g) * 4 / 10
b = b + (255 - b) * 4 / 10
@ -92,7 +92,7 @@ fn ui_draw_node(i: int) -> void {
let rw = peek32(ui_rw, i)
let rh = peek32(ui_rh, i)
let skin = peek32(ui_skin, i)
let focused = 0
var focused = 0
if i == ui_focus { focused = 1 }
if t == WT_PANEL {
@ -104,7 +104,7 @@ fn ui_draw_node(i: int) -> void {
}
}
if t == WT_BUTTON {
let bg = peek32(ui_bg, i)
var bg = peek32(ui_bg, i)
if bg < 0 { bg = 0x2a2a3a }
if focused == 1 { bg = ui_lighten(bg) }
if skin >= 0 {
@ -112,12 +112,12 @@ fn ui_draw_node(i: int) -> void {
} else {
rt_fill_rect(rx, ry, rw, rh, bg)
}
let bc = peek32(ui_border, i)
var bc = peek32(ui_border, i)
if bc < 0 { bc = 0x555577 }
if focused == 1 { bc = 0xffff00 }
rt_frame_rect(rx, ry, rw, rh, bc)
let s = ui_str(i)
let fg = peek32(ui_fg, i)
var fg = peek32(ui_fg, i)
if fg < 0 { fg = 0xffffff }
let font = peek32(ui_font, i)
let size = peek32(ui_size, i)
@ -125,13 +125,13 @@ fn ui_draw_node(i: int) -> void {
}
if t == WT_LABEL {
let s = ui_str(i)
let fg = peek32(ui_fg, i)
var fg = peek32(ui_fg, i)
if fg < 0 { fg = 0xffffff }
let font = peek32(ui_font, i)
let size = peek32(ui_size, i)
let pad = peek32(ui_pad, i)
let tw = ui_tw(font, s, size)
let tx = rx + pad
var tx = rx + pad
let al = peek32(ui_align, i)
if al == 1 { tx = rx + (rw - tw) / 2 }
if al == 2 { tx = rx + rw - pad - tw }
@ -150,7 +150,7 @@ var ui_fl: ptr = ptr_null()
fn ui_focusables() -> int {
if ptr_is_null(ui_fl) { ui_fl = mem_alloc(UI_MAX * 4) }
let n = 0
var n = 0
for i in 0 .. ui_n {
if peek32(ui_focusable, i) == 1 {
if peek32(ui_visible, i) == 1 {
@ -180,7 +180,7 @@ fn rt_ui_tick(k: int) -> void {
ui_focus = 0 - 1
return
}
let cur = 0 - 1
var cur = 0 - 1
for i in 0 .. n {
if peek32(ui_fl, i) == ui_focus { cur = i }
}
@ -218,8 +218,8 @@ fn rt_ui_set_text(id: int, s: str) -> void {
if id < 0 { return }
if id >= ui_n { return }
let base = id * 96
let i = 0
let ch = peek8(s, 0)
var i = 0
var ch = peek8(s, 0)
while ch != 0 {
if i >= 95 { ch = 0 }
if ch != 0 {
@ -236,8 +236,8 @@ fn rt_ui_set_int(id: int, n: int) -> void {
if id < 0 { return }
if id >= ui_n { return }
let base = id * 96
let at = 0
let v = n
var at = 0
var v = n
if v < 0 {
poke8(ui_dyn, base, 45)
at = 1
@ -247,15 +247,15 @@ fn rt_ui_set_int(id: int, n: int) -> void {
poke8(ui_dyn, base + at, 48)
at = at + 1
} else {
let digits = 0
let t = v
var digits = 0
var t = v
while t > 0 {
digits = digits + 1
t = t / 10
}
let p = digits
var p = digits
while p > 0 {
let div = 1
var div = 1
for k in 1 .. p { div = div * 10 }
poke8(ui_dyn, base + at, 48 + (v / div) % 10)
at = at + 1