belatedly migrate stale example definitions

Also bare-bones syntax highlighting for .limg files. Doesn't work when
.limg file is first file opened with Vim.

4 files changed, 99 insertions, 93 deletions

diff --git a/shell/data.limg b/shell/data.limg
index 534ecd51..14eab44e 100644
--- a/shell/data.limg
+++ b/shell/data.limg
@@ -1,95 +1,95 @@
 (
   (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)))
+    (hline . [(def hline (fn (screen y color)
+  (hline1 screen y 0 (width screen) color)))])
+    (hline1 . [(def hline1 (fn (screen y lo hi color)
+  (while (< lo hi)
+    (pixel screen lo y color)
+    (set lo (+ lo 1)))))])
+    (vline . [(def vline (fn (screen x color)
+  (vline1 screen x 0 (height screen) color)))])
+    (vline1 . [(def vline1 (fn (screen x lo hi color)
+  (while (< lo hi)
+    (pixel screen x lo color)
+    (set lo (+ lo 1)))))])
+    (fill_rect . [(def fill_rect (fn (screen x1 y1 x2 y2 color)
+  (while (< y1 y2)
+    (hline1 screen y1 x1 x2 color)
+    (set y1 (+ y1 1)))))])
+  (brline . [(def 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 . [(def 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 . [(def 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 . [(def read_line (fn (keyboard)
+  (read_line_2 keyboard (stream))))])
+  (chessboard . [(def chessboard (fn (screen px)
+  (chessboard1 screen px 0 15)))])
+  (chessboard1 . [(def 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 . [(def 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 . [(def 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 . [(def main (fn (screen keyboard)
+  (chessboard screen 16)))])
   ))
-  (sandbox . (brcircle screen 5 5 3 12))
+  (sandbox . (fill_rect screen 0 0 8 8 2))
 )
diff --git a/shell/print.mu b/shell/print.mu
index fce0490a..542c59a4 100644
--- a/shell/print.mu
+++ b/shell/print.mu
@@ -83,7 +83,7 @@ fn print-cell _in: (addr handle cell), out: (addr stream byte), trace: (addr tra
 
 # debug helper
 fn dump-cell-at-top-right in-ah: (addr handle cell) {
-  var stream-storage: (stream byte 0x200)
+  var stream-storage: (stream byte 0x1000)
   var stream/edx: (addr stream byte) <- address stream-storage
   print-cell in-ah, stream, 0/no-trace
   var d1/eax: int <- copy 0
diff --git a/shell/tokenize.mu b/shell/tokenize.mu
index 0d6fdd6e..7572ffba 100644
--- a/shell/tokenize.mu
+++ b/shell/tokenize.mu
@@ -9,13 +9,15 @@ fn tokenize in: (addr gap-buffer), out: (addr stream cell), trace: (addr trace)
   var token-storage: cell
   var token/edx: (addr cell) <- address token-storage
   {
+#?     draw-text-wrapping-right-then-down-from-cursor-over-full-screen 0/screen "a", 7/fg 0/bg
     skip-whitespace-from-gap-buffer in
     var done?/eax: boolean <- gap-buffer-scan-done? in
     compare done?, 0/false
     break-if-!=
+#?     draw-text-wrapping-right-then-down-from-cursor-over-full-screen 0/screen "b", 7/fg 0/bg
     # initialize token data each iteration to avoid aliasing
     var dest-ah/eax: (addr handle stream byte) <- get token, text-data
-    populate-stream dest-ah, 0x100/max-definition-size
+    populate-stream dest-ah, 0x400/max-definition-size
     #
     next-token in, token, trace
     var skip?/eax: boolean <- comment-token? token
@@ -27,7 +29,9 @@ fn tokenize in: (addr gap-buffer), out: (addr stream cell), trace: (addr trace)
       break-if-=
       return
     }
+#?     draw-text-wrapping-right-then-down-from-cursor-over-full-screen 0/screen "y", 7/fg 0/bg
     write-to-stream out, token  # shallow-copy text-data
+#?     draw-text-wrapping-right-then-down-from-cursor-over-full-screen 0/screen "z", 7/fg 0/bg
     loop
   }
   trace-higher trace
diff --git a/vimrc.vim b/vimrc.vim
index 8f902777..b8b17a8c 100644
--- a/vimrc.vim
+++ b/vimrc.vim
@@ -96,3 +96,5 @@ inoremap <Leader>ahs <Esc>F<Space>a(addr handle stream <Esc>A)
 inoremap <Leader>o <Esc>F<Space>a(offset <Esc>A)
 inoremap ,- <-
 inoremap -. ->
+
+autocmd BufReadPost,BufNewFile *.limg call matchadd('String', '\[\([^\]]*\_$\_s\)*[^\]]*\]')