mu/shell/data.limg

(
  (globals . (
    (hline1 . (fn () (screen y lo hi color)
                (while (< lo hi)
                  (pixel screen lo y color)
                  (set lo (+ lo 1)))))
    (vline1 . (fn () (screen x lo hi color)
                (while (< lo hi)
                  (pixel screen x lo color)
                  (set lo (+ lo 1)))))
    (hline . (fn () (screen y color)
               (hline1 screen y 0 (width screen) color)))
    (vline . (fn () (screen y color)
               (vline1 screen y 0 (height screen) color)))
    (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 xlast ylast dx dy sx sy err color)
                 (while (not (and (= x xlast) (= y ylast)))
                   (pixel screen x y color)
                   ((fn (e2)
                      (if (>= e2 dy)
                        (set x (+ x sx))
                        ())
                      (if (<= e2 dx)
                        (set y (+ y sy)))
                      (set err (+ err
                           (+
                             (if (>= e2 dy)
                               dy
                               0)
                             (if (<= e2 dx)
                               dx
                               0)))))
                    (* 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)
                   (while (< y1 y2)
                     (hline1 screen y1 x1 x2 fill_color)
                     (set y1 (+ y1 1)))))
    (chessboard . (fn () (screen px)
                    (chessboard1 screen px 0 15)))
    (chessboard1 . (fn () (screen px y color)
                     (clear screen)
                     (while (< y (height screen))
                       (chessboard2 screen px y 0 color)
                       (set y (+ y px))
                       (chessboard2 screen px y px color)
                       (set y (+ y px)))))
    (chessboard2 . (fn () (screen px y x color)
                     (while (< x (width screen))
                       (fill_rect screen x y (+ x px) (+ y px) color)
                       (set x (+ x px))
                       (set x (+ x px)))))
    (brcircle . (fn () (screen cx cy r color)
                  ((fn (x y err continue)
                     (while continue
                       (pixel screen (- cx x) (+ cy y) color)
                       (pixel screen (- cx y) (- cy x) color)
                       (pixel screen (+ cx x) (- cy y) color)
                       (pixel screen (+ cx y) (+ cy x) color)
                       (set r err)
                       (if (<= r y)
                         (set err (+ err (+ 1 (* 2 (set y (+ y 1))))))
                         ())
                       (if (or (> r x) (> err y))
                         (set err (+ err (+ 1 (* 2 (set x (+ x 1))))))
                         ())
                       (set continue (< x 0))
                       ))
                    (- 0 r)
                    0
                    (- 2 (* 2 r))
                    1
                   )))
    (main . (fn () (screen keyboard)
              (chessboard screen 16)))
  ))
  (sandbox . (brcircle screen 5 5 3 12))
)