about summary refs log tree commit diff stats
Commit message (Collapse)AuthorAgeFilesLines
* clear old output when new run is in progressKartik K. Agaram2021-04-212-69/+94
| | | | I'm currently doing this extremely naively/slowly/uglily. Not a bottleneck.
* .Kartik K. Agaram2021-04-212-14/+14
|
* .Kartik K. Agaram2021-04-211-1/+1
|
* .Kartik K. Agaram2021-04-212-67/+67
|
* opt: don't clear streams of bytes on the stackKartik K. Agaram2021-04-212-3/+152
| | | | | | | | | | | | All over the Mu code I reflexively initialize all variables just to keep unsafe SubX easy to debug. However I don't really need to do this for safe Mu code, since the type- and memory-safety already ensures we can't read from streams beyond what we've written to them. For now I'll continue mostly with the same approach, but with one exception for streams of bytes. Mu programs often emit traces, and in doing so they often use temporary streams of bytes that can get quite long. I'm hoping avoiding initializing KBs of data all over the place will measurably speed up the Mu shell.
* .Kartik Agaram2021-04-21243-45738/+47168
|
* shell: show screen state during evaluationKartik K. Agaram2021-04-213-17/+41
| | | | | | | | | | | | | | All highly experimental. Current constraints: * No tail recursion elimination * No heap reuse * Keep implementation simple So it's slow, and I don't want to complicate it to speed it up. So I'm investing in affordances to help deal with the slowness. However, in the process I've taken the clean abstraction of a trace ("all you need to do is add to the trace") and bolted on call counts and debug-prints as independent mechanisms.
* .Kartik K. Agaram2021-04-211-0/+11
|
* an interface approximating stack tracesKartik K. Agaram2021-04-206-27/+51
|
* get bresenham line drawing working with a traceKartik K. Agaram2021-04-202-11/+27
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | (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))))) sandbox: (brline screen 1 1 5 5 12) There are two ideas stemming from this commit: - I need an extremely compact on-screen trace to underlie the trace UX - perhaps we should start truncating trace lines
* deemphasize fn arg evaluation slightlyKartik K. Agaram2021-04-191-0/+2
|
* reimplement pixel graphicsKartik K. Agaram2021-04-192-74/+147
| | | | | | | | | | | Before: we always drew pixels atop characters, and we only drew pixels that were explicitly requested. After: we always draw pixels atop characters, and we only draw pixels that don't have color 0. Both semantics should be identical as long as pixels are never drawn atop characters.
* .Kartik K. Agaram2021-04-191-33/+33
|
* .Kartik K. Agaram2021-04-191-1/+2
|
* add some checksKartik K. Agaram2021-04-191-2/+18
| | | | | | | Even if they duplicate lower-level ones, we have an opportunity for better error messages. Any time I see a hard-to-debug error message, I should be asking myself, "what higher-level primitive should catch and improve this error?"
* start cleaning up pixel graphicsKartik K. Agaram2021-04-197-54/+54
| | | | | | Filling pixels isn't a rare corner case. I'm going to switch to a dense rather than sparse representation for pixels, but callers will have to explicitly request the additional memory.
* re-enable testsKartik K. Agaram2021-04-181-13/+13
| | | | Disabled in commit 1354161a3, and then I forgot about them for a while.
* Revert "allow drawing all pixels"Kartik K. Agaram2021-04-181-2/+3
| | | | It causes us to run out of memory during tests.
* .Kartik K. Agaram2021-04-181-0/+7
|
* fix a bug in loading code diskKartik K. Agaram2021-04-181-1/+1
|
* revert experiment: expand heapKartik K. Agaram2021-04-182-4/+3
| | | | | There are several things in the codebase right now that don't seem sustainable. I need to take them out and bring them back in more gradually.
* experiment: expand heapKartik K. Agaram2021-04-182-3/+4
|
* some primitives for monitoring code integrityKartik K. Agaram2021-04-183-0/+58
|
* update the memory mapKartik K. Agaram2021-04-181-1/+1
|
* .Kartik K. Agaram2021-04-172-0/+258
|
* shell: ctrl-r runs on real screen without a traceKartik K. Agaram2021-04-179-26/+106
| | | | | We run out of memory fairly early in the course of drawing a chessboard on the whole screen.
* .Kartik K. Agaram2021-04-172-6/+6
|
* allow drawing all pixelsKartik K. Agaram2021-04-171-3/+2
| | | | So far we aren't running out of memory. Might as well loosen our belts.
* bump up the token limit againKartik K. Agaram2021-04-171-1/+1
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 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)) )
* shell: reenable the traceKartik K. Agaram2021-04-173-1/+22
| | | | | | | | | | | | | | We now have a couple of protections: - if we get close to running out of space in the trace we drop in an error - if we run out of space in the trace we stop trying to append - if there are errors we cancel future evaluations This is already much nicer. You can't do much on the Mu computer, but at least it gracefully gives up and shows its limitations. On my computer the Mu shell tries to run computations for about 20s before giving up. That seems at the outer limit of what interactivity supports. If things take too long, test smaller chunks.
* evaluating fns is too similar to its inputKartik K. Agaram2021-04-171-1/+1
| | | | | When I edit disk images directly, it's easy to forget a pair of parens. Then the first expression of the body never executes.
* write-multiple supportKartik K. Agaram2021-04-171-3/+24
| | | | | | | Is flush-ata-cache even needed? Reading the ATA 5 spec more closely, it looks like it's only required by ATAPI devices! (Packet Interface is what the 'PI' stands for!) And it's unclear if my driver actually supports ATAPI at the moment.
* start flushing the ATA disk cacheKartik K. Agaram2021-04-171-0/+18
| | | | | | "Make sure to do a Cache Flush (ATA command 0xE7) after each write command completes." https://wiki.osdev.org/index.php?title=ATA_PIO_Mode&oldid=25664#Writing_28_bit_LBA
* starting write-multiple supportKartik K. Agaram2021-04-171-52/+55
|
* load sandbox even if there are no globalsKartik K. Agaram2021-04-171-11/+9
|
* heh, the current state actually overflows 2KBKartik K. Agaram2021-04-171-4/+4
| | | | | | It only works because the part that's truncated is cleanly the sandbox. I need better error-checking in `read`.
* Bresenham line-drawing now workingKartik K. Agaram2021-04-171-0/+16
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | I can't run tests right now, and the trace is disabled. Still, progress. https://merveilles.town/@akkartik/106081486035689980 Current state of the disk image: ( (globals . ( (hline1 . (fn () (screen y lo hi) (if (>= lo hi) () ((fn () (pixel screen lo y 12) (hline1 screen y (+ lo 1) hi)))))) (vline1 . (fn () (screen x lo hi) (if (>= lo hi) () ((fn () (pixel screen x lo 12) (vline1 screen x (+ lo 1) hi)))))) (hline . (fn () (screen y) (hline1 screen y 0 (width screen)))) (vline . (fn () (screen y) (vline1 screen y 0 (height screen)))) (andf . (fn () (a b) (if a (if b 1 ()) ()))) (brline . (fn () (screen x0 y0 x1 y1) ((fn (dx dy sx sy) ((fn (err) (brline1 screen x0 y0 x1 y1 dx dy sx sy err)) (+ 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) (pixel screen x y 12) (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))))) (* err 2))))) )) (sandbox . (brline screen 1 1 5 5)) )
* tmp: debugging why brline prints no pixelsKartik K. Agaram2021-04-172-14/+14
| | | | | | | | | | | | | | | | | Among other things, we turned off the trace to significantly speed up the debug cycle. State as of https://merveilles.town/@akkartik/106079258606146213 Ohhh, as I save the commit I notice a big problem: I've been editing the disk image directly because writes to the Mu disk lose indentation. But I've been forgetting that the state in the Mu disk needs to be pre-evaluated. So function bindings need extra parens for the environment. The `pixel` calls in the previous commit message are the first statement in the body, and they aren't actually considered part of the body right now. No wonder they don't run. There are lots of other problems, but this will clarify a lot.
* loosening a few more buffersKartik K. Agaram2021-04-174-9/+21
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | Mu computer now has more code in it: ( (globals . ( (hline1 . (fn () (screen y lo hi) (if (>= lo hi) () ((fn () (pixel screen lo y 12) (hline1 screen y (+ lo 1) hi)))))) (vline1 . (fn () (screen x lo hi) (if (>= lo hi) () ((fn () (pixel screen x lo 12) (vline1 screen x (+ lo 1) hi)))))) (hline . (fn () (screen y) (hline1 screen y 0 (width screen)))) (vline . (fn () (screen y) (vline1 screen y 0 (height screen)))) (andf . (fn (a b) (if a (if b 1 ()) ()))) (brline . (fn (screen x0 y0 x1 y1) ((fn (dx dy sx sy) ((fn (err) (brline1 screen x0 y0 x1 y1 dx dy sx sy err)) (+ 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) (pixel screen x y 12) (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))))) (* err 2))))) )) (sandbox . (brline screen 1 1 5 5)) )
* .Kartik K. Agaram2021-04-171-1/+1
|
* new primitives: abs, sgnKartik K. Agaram2021-04-161-1/+100
|
* .Kartik K. Agaram2021-04-1618-45/+45
|
* handle drawing 16*4 = 64 pixelsKartik K. Agaram2021-04-161-1/+1
| | | | | | | | | | | | | | | Previously we'd only drawn 8*5 = 40 pixels. Current contents of data.img: ( (globals . ( (hline . (fn () (screen y) (hline1 screen y 0 (width screen)))) (hline1 . (fn () (screen y lo hi) (if (>= lo hi) () ((fn () (pixel screen lo y 12) (hline1 screen y (+ lo 1) hi)))))) (vline1 . (fn () (screen x lo hi) (if (>= lo hi) () ((fn () (pixel screen x lo 12) (vline1 screen x (+ lo 1) hi)))))) )) (sandbox . (vline1 screen 5 0 (height screen))) )
* data.img now has more than one sector of dataKartik K. Agaram2021-04-165-42/+88
|
* open question: animations in the fake screenKartik K. Agaram2021-04-151-0/+38
| | | | Right now we just render the state of the screen at the end of an evaluation.
* .Kartik K. Agaram2021-04-151-17/+17
|
* .Kartik K. Agaram2021-04-151-2/+6
|
* .Kartik K. Agaram2021-04-151-1/+2
|
* shell: horline working nowKartik K. Agaram2021-04-151-1/+9
| | | | And we give a high-level error when the pixel buffer fills up.
* first session programming _within_ the Mu computerKartik K. Agaram2021-04-152-8/+16
| | | | | | | | | | | | | | | | | | | | | | | | | | | | I tried building a function to draw a horizontal line across the screen. Here's what I have in data.txt: ( (globals . ( (horline . (fn () (screen y) (horline_1 screen y 0 (width screen)))) (horline_1 . (fn () (screen y lo hi) (if (>= lo hi) () ((fn () (pixel screen lo y 12) (horline_1 screen y (+ lo 1) hi)))))) )) (sandbox . (horline_1 screen 0 0 20)) ) $ dd if=/dev/zero of=data.img count=20160 $ cat data.txt |dd of=data.img conv=notrunc $ ./translate shell/*.mu && qemu-system-i386 -hda disk.img -hdb data.img Result: I can't call (horline screen 0) over a fake screen of width 40. Some stream overflows somewhere after all the tweaks to various fixed-size buffers scattered throughout the app. Calling horline_1 gets to a 'hi' column of 20, but not to 30.
generated by cgit-pink 1.4.1-2-gfad0 (git 2.36.2.497.gbbea4dcf42) at 2024-11-07 13:31:33 +0000