8be6fe2485
Current state of code in the Mu computer:
(
(globals . (
(hline1 . (fn () (screen y lo hi color)
(if (>= lo hi)
()
((fn ()
(pixel screen lo y color)
(hline1 screen y (+ lo 1) hi color))))))
(vline1 . (fn () (screen x lo hi color)
(if (>= lo hi)
()
((fn ()
(pixel screen x lo color)
(vline1 screen x (+ lo 1) hi color))))))
(hline . (fn () (screen y color)
(hline1 screen y 0 (width screen) color)))
(vline . (fn () (screen y color)
(vline1 screen y 0 (height screen) color)))
(andf . (fn () (a b)
(if a
(if b
1
())
())))
(brline . (fn () (screen x0 y0 x1 y1 color)
((fn (dx dy sx sy)
((fn (err)
(brline1 screen x0 y0 x1 y1 dx dy sx sy err color))
(+ dx dy)))
(abs (- x1 x0))
(- 0 (abs (- y1 y0)))
(sgn (- x1 x0))
(sgn (- y1 y0)))))
(brline1 . (fn () (screen x y xmax ymax dx dy sx sy err color)
(pixel screen x y color)
(if (andf (= x xmax) (= y ymax))
()
((fn (e2)
(brline1 screen
(if (>= e2 dy)
(+ x sx)
x)
(if (<= e2 dx)
(+ y sy)
y)
xmax
ymax
dx
dy
sx
sy
(+ err
(+
(if (>= e2 dy)
dy
0)
(if (<= e2 dx)
dx
0)))
color))
(* err 2)))))
(read_line_2 . (fn () (keyboard stream)
((fn (c)
(if (= c 10)
stream
(if (= c 0)
stream
(read_line_2 keyboard (write stream c)))))
(key keyboard))))
(read_line . (fn () (keyboard)
(read_line_2 keyboard (stream))))
(fill_rect . (fn () (screen x1 y1 x2 y2 fill_color)
(if (>= y1 y2)
()
((fn ()
(hline1 screen y1 x1 x2 fill_color)
(fill_rect screen x1 (+ y1 1) x2 y2 fill_color))))))
(chessboard . (fn () (screen px)
(chessboard1 screen px 0 15)))
(chessboard1 . (fn () (screen px y color)
(if (>= y (height screen))
()
((fn ()
(chessboard2 screen px y 0 color)
(chessboard1 screen px (+ y px) (- 15 color)))))))
(chessboard2 . (fn () (screen px y x color)
(if (>= x (width screen))
()
((fn ()
(fill_rect screen x y (+ x px) (+ y px) color)
(chessboard2 screen px y (+ x px) (- 15 color)))))))
))
(sandbox . (chessboard screen 8))
)
|
||
|---|---|---|
| .. | ||
| cell.mu | ||
| evaluate.mu | ||
| gap-buffer.mu | ||
| global.mu | ||
| grapheme-stack.mu | ||
| main.mu | ||
| parse.mu | ||
| print.mu | ||
| read.mu | ||
| README.md | ||
| sandbox.mu | ||
| tokenize.mu | ||
| trace.mu | ||
| vimrc.vim | ||
A prototype shell for the Mu computer
Currently runs a tiny subset of Lisp. Steps to run it from the top-level:
- Build it:
$ ./translate shell/*.mu # generates code.img
- Run it:
$ qemu-system-i386 code.img
or:
$ bochs -f bochsrc
To save typing in a large s-expression, create a secondary disk for data:
$ dd if=/dev/zero of=data.img count=20160
Load an s-expression into it:
$ echo '(+ 1 1)' |dd of=data.img conv=notrunc
Now run with both code and data disks:
$ qemu-system-i386 -hda code.img -hdb data.img
or:
$ bochs -f bochsrc.2disks
You can type in expressions, hit ctrl-s to see their results, and hit Tab
to focus on the ... below and browse how the results were computed. Here's
a demo. The bottom of
the screen shows context-dependent keyboard shortcuts (there's no mouse in the
Mu computer at the moment).
Known issues
-
There's no way to save to disk.
-
Don't press keys too quickly (such as by holding down a key). The Mu computer will crash (and often Qemu will segfault).