571 - screen primitives take an explicit terminal

This will let me swap in a fake in tests.

Still hacky, though. I'm sure I'm not managing the parameter right in
the chessboard app.

And then there's the question of whether it should also appear as an
output operand.

But it's a start. And using nil to mean 'real' is a reasonable
convention.

If I ever need to handle multiple screens perhaps we'll have to switch
to 1:literal/terminal and 2:literal/terminal, etc. But those are equally
easy to guard on.

11 files changed, 125 insertions, 101 deletions

diff --git a/channel.mu b/channel.mu
index 92746a62..ea6c89a8 100644
--- a/channel.mu
+++ b/channel.mu
@@ -8,9 +8,9 @@
     (done?:boolean <- less-than n:integer 5:literal)
     (break-unless done?:boolean)
     ; other threads might get between these prints
-    (print-primitive (("produce: " literal)))
-    (print-primitive n:integer)
-    (print-primitive (("\n" literal)))
+    (print-primitive nil:literal/terminal (("produce: " literal)))
+    (print-primitive nil:literal/terminal n:integer)
+    (print-primitive nil:literal/terminal (("\n" literal)))
     ; 'box' n into a dynamically typed 'tagged value' because that's what
     ; channels take
     (n2:integer <- copy n:integer)
@@ -31,9 +31,9 @@
     ; unbox the tagged value into an integer
     (n2:integer <- maybe-coerce x:tagged-value integer:literal)
     ; other threads might get between these prints
-    (print-primitive (("consume: " literal)))
-    (print-primitive n2:integer)
-    (print-primitive (("\n" literal)))
+    (print-primitive nil:literal/terminal (("consume: " literal)))
+    (print-primitive nil:literal/terminal n2:integer)
+    (print-primitive nil:literal/terminal (("\n" literal)))
     (loop)
   }
 ])
diff --git a/chessboard-cursor.mu b/chessboard-cursor.mu
index af520121..4c025cff 100644
--- a/chessboard-cursor.mu
+++ b/chessboard-cursor.mu
@@ -63,8 +63,8 @@
     (break-if done?:boolean)
     ; print rank number as a legend
     (rank:integer <- add row:integer 1:literal)
-    (print-primitive rank:integer)
-    (print-primitive ((" | " literal)))
+    (print-primitive nil:literal/terminal rank:integer)
+    (print-primitive nil:literal/terminal ((" | " literal)))
     ; print each square in the row
     (col:integer <- copy 0:literal)
     { begin
@@ -72,20 +72,20 @@
       (break-if done?:boolean)
       (f:file-address <- index b:board-address/deref col:integer)
       (s:square <- index f:file-address/deref row:integer)
-      (print-primitive s:square)
-      (print-primitive ((" " literal)))
+      (print-primitive nil:literal/terminal s:square)
+      (print-primitive nil:literal/terminal ((" " literal)))
       (col:integer <- add col:integer 1:literal)
       (loop)
     }
     (row:integer <- subtract row:integer 1:literal)
-    (cursor-to-next-line)
+    (cursor-to-next-line nil:literal/terminal)
     (loop)
   }
   ; print file letters as legend
-  (print-primitive (("  +----------------" literal)))
-  (cursor-to-next-line)
-  (print-primitive (("    a b c d e f g h" literal)))
-  (cursor-to-next-line)
+  (print-primitive nil:literal/terminal (("  +----------------" literal)))
+  (cursor-to-next-line nil:literal/terminal)
+  (print-primitive nil:literal/terminal (("    a b c d e f g h" literal)))
+  (cursor-to-next-line nil:literal/terminal)
 ])
 
 ;; data structure: move
@@ -224,17 +224,17 @@
   { begin
     ; print any stray characters from keyboard *before* clearing screen
     (flush-stdout)
-    (clear-screen)
-    (print-primitive (("Stupid text-mode chessboard. White pieces in uppercase; black pieces in lowercase. No checking for legal moves." literal)))
-    (cursor-to-next-line)
-    (cursor-to-next-line)
+    (clear-screen nil:literal/terminal)
+    (print-primitive nil:literal/terminal (("Stupid text-mode chessboard. White pieces in uppercase; black pieces in lowercase. No checking for legal moves." literal)))
+    (cursor-to-next-line nil:literal/terminal)
+    (cursor-to-next-line nil:literal/terminal)
     (print-board b:board-address)
-    (cursor-to-next-line)
-    (print-primitive (("Type in your move as <from square>-<to square>. For example: 'a2-a4'. Currently very unforgiving of typos; exactly five letters, no <Enter>, no uppercase." literal)))
-    (cursor-to-next-line)
-    (print-primitive (("Hit 'q' to exit." literal)))
-    (cursor-to-next-line)
-    (print-primitive (("move: " literal)))
+    (cursor-to-next-line nil:literal/terminal)
+    (print-primitive nil:literal/terminal (("Type in your move as <from square>-<to square>. For example: 'a2-a4'. Currently very unforgiving of typos; exactly five letters, no <Enter>, no uppercase." literal)))
+    (cursor-to-next-line nil:literal/terminal)
+    (print-primitive nil:literal/terminal (("Hit 'q' to exit." literal)))
+    (cursor-to-next-line nil:literal/terminal)
+    (print-primitive nil:literal/terminal (("move: " literal)))
     (m:move-address <- read-move)
     (break-unless m:move-address)
     (b:board-address <- make-move b:board-address m:move-address)
diff --git a/chessboard-retro.mu b/chessboard-retro.mu
index e9fbd101..9a04c1b8 100644
--- a/chessboard-retro.mu
+++ b/chessboard-retro.mu
@@ -18,7 +18,7 @@
                                               N:literal P:literal _:literal _:literal _:literal _:literal p:literal n:literal
                                               R:literal P:literal _:literal _:literal _:literal _:literal p:literal r:literal)
   ; assert(length(initial-position) == 64)
-;?   (print-primitive (("list-length\n" literal)))
+;?   (print-primitive nil:literal/terminal (("list-length\n" literal)))
   (len:integer <- list-length initial-position:list-address)
   (correct-length?:boolean <- equal len:integer 64:literal)
   (assert correct-length?:boolean "chessboard had incorrect size")
@@ -28,8 +28,8 @@
   { begin
     (done?:boolean <- equal col:integer 8:literal)
     (break-if done?:boolean)
-;?     (print-primitive col:integer)
-;?     (print-primitive (("\n" literal)))
+;?     (print-primitive nil:literal/terminal col:integer)
+;?     (print-primitive nil:literal/terminal (("\n" literal)))
     (file:file-address-address <- index-address b:board-address/deref col:integer)
     (file:file-address-address/deref curr:list-address <- read-file curr:list-address)
     (col:integer <- add col:integer 1:literal)
@@ -74,12 +74,12 @@
       (break-if done?:boolean)
       (f:file-address <- index b:board-address/deref col:integer)
       (s:square <- index f:file-address/deref row:integer)
-      (print-primitive s:square)
-      (print-primitive ((" " literal)))
+      (print-primitive nil:literal/terminal s:square)
+      (print-primitive nil:literal/terminal ((" " literal)))
       (col:integer <- add col:integer 1:literal)
       (loop)
     }
-    (print-primitive (("\n" literal)))
+    (print-primitive nil:literal/terminal (("\n" literal)))
     (row:integer <- subtract row:integer 1:literal)
     (loop)
   }
diff --git a/counters.mu b/counters.mu
index 6f26abae..90805639 100644
--- a/counters.mu
+++ b/counters.mu
@@ -23,11 +23,11 @@
   (bres:integer <- increment-counter b:space-address 2:literal)
   (ares:integer <- increment-counter a:space-address 1:literal)
   ; check results
-  (print-primitive (("Contents of counters a: " literal)))
-  (print-primitive ares:integer)
-  (print-primitive ((" b: " literal)))
-  (print-primitive bres:integer)
-  (print-primitive (("\n" literal)))
+  (print-primitive nil:literal/terminal (("Contents of counters a: " literal)))
+  (print-primitive nil:literal/terminal ares:integer)
+  (print-primitive nil:literal/terminal ((" b: " literal)))
+  (print-primitive nil:literal/terminal bres:integer)
+  (print-primitive nil:literal/terminal (("\n" literal)))
  ])
 
 ; compare http://www.paulgraham.com/accgen.html
diff --git a/factorial.mu b/factorial.mu
index e1c6007f..3d7d0079 100644
--- a/factorial.mu
+++ b/factorial.mu
@@ -16,7 +16,7 @@
 
 (function main [
   (1:integer <- factorial 5:literal)
-  (print-primitive (("result: " literal)))
-  (print-primitive 1:integer)
-  (print-primitive (("\n" literal)))
+  (print-primitive nil:literal/terminal (("result: " literal)))
+  (print-primitive nil:literal/terminal 1:integer)
+  (print-primitive nil:literal/terminal (("\n" literal)))
 ])
diff --git a/fork.mu b/fork.mu
index ba19e3af..edd8eb8d 100644
--- a/fork.mu
+++ b/fork.mu
@@ -3,7 +3,7 @@
   (default-space:space-address <- new space:literal 2:literal)
   (x:integer <- copy 34:literal)
   { begin
-    (print-primitive x:integer)
+    (print-primitive nil:literal/terminal x:integer)
     (loop)
   }
 ])
@@ -12,7 +12,7 @@
   (default-space:space-address <- new space:literal 2:literal)
   (y:integer <- copy 35:literal)
   { begin
-    (print-primitive y:integer)
+    (print-primitive nil:literal/terminal y:integer)
     (loop)
   }
 ])
diff --git a/generic.mu b/generic.mu
index 1392394a..6bcfd1e2 100644
--- a/generic.mu
+++ b/generic.mu
@@ -24,7 +24,7 @@
 
 (function main [
   (1:integer <- factorial 5:literal)
-  (print-primitive (("result: " literal)))
-  (print-primitive 1:integer)
-  (print-primitive (("\n" literal)))
+  (print-primitive nil:literal/terminal (("result: " literal)))
+  (print-primitive nil:literal/terminal 1:integer)
+  (print-primitive nil:literal/terminal (("\n" literal)))
 ])
diff --git a/graphics.mu b/graphics.mu
index ad408470..878df66c 100644
--- a/graphics.mu
+++ b/graphics.mu
@@ -7,10 +7,10 @@
     (loop-unless click?:boolean)
     (x:integer <- get pos:integer-integer-pair 0:offset)
     (y:integer <- get pos:integer-integer-pair 1:offset)
-    (print-primitive x:integer)
-    (print-primitive ((", " literal)))
-    (print-primitive y:integer)
-    (print-primitive (("\n" literal)))
+    (print-primitive nil:literal/terminal x:integer)
+    (print-primitive nil:literal/terminal ((", " literal)))
+    (print-primitive nil:literal/terminal y:integer)
+    (print-primitive nil:literal/terminal (("\n" literal)))
     (loop)
   }
   (window-off)
diff --git a/mu.arc b/mu.arc
index 31bba88d..09d9ad9a 100644
--- a/mu.arc
+++ b/mu.arc
@@ -196,6 +196,8 @@
               line-address-address (obj size 1  address t  elem '(line-address))
               screen (obj array t  elem '(line-address))
               screen-address (obj size 1  address t  elem '(screen))
+              terminal (obj size 3  and-record t  elems '((integer) (integer) (string-address))  fields '(rows cols data))
+              terminal-address (obj size 1  address t  elem '(terminal))
               )))
 
 ;; managing concurrent routines
@@ -1522,7 +1524,7 @@
 ;?     (reply 0:literal)
 ;?   }
 ;?   ; else return 1+length(curr.cdr)
-;?   (print-primitive (("recurse\n" literal)))
+;?   (print-primitive nil:literal/terminal (("recurse\n" literal)))
 ;?   (next:list-address <- list-next curr:list-address)
 ;?   (sub:integer <- list-length next:list-address)
 ;?   (result:integer <- add sub:integer 1:literal)
@@ -1536,8 +1538,8 @@
     (break-if empty?:boolean)
     ; ++result
     (result:integer <- add result:integer 1:literal)
-;?     (print-primitive result:integer)
-;?     (print-primitive (("\n" literal)))
+;?     (print-primitive nil:literal/terminal result:integer)
+;?     (print-primitive nil:literal/terminal (("\n" literal)))
     ; curr = curr.cdr
     (curr:list-address <- list-next curr:list-address)
     (loop)
@@ -1705,19 +1707,19 @@
     ; while arg received
     (a:string-address arg-received?:boolean <- next-input)
     (break-unless arg-received?:boolean)
-;?     (print-primitive ("arg now: " literal))
-;?     (print-primitive a:string-address)
-;?     (print-primitive "@":literal)
-;?     (print-primitive a:string-address/deref)  ; todo: test (m on scoped array)
-;?     (print-primitive "\n":literal)
+;?     (print-primitive nil:literal/terminal ("arg now: " literal))
+;?     (print-primitive nil:literal/terminal a:string-address)
+;?     (print-primitive nil:literal/terminal "@":literal)
+;?     (print-primitive nil:literal/terminal a:string-address/deref)  ; todo: test (m on scoped array)
+;?     (print-primitive nil:literal/terminal "\n":literal)
 ;? ;?     (assert nil:literal)
     ; result-len = result-len + arg.length - 1 (for the 'underscore' being replaced)
     (a-len:integer <- length a:string-address/deref)
     (result-len:integer <- add result-len:integer a-len:integer)
     (result-len:integer <- subtract result-len:integer 1:literal)
-;?     (print-primitive ("result-len now: " literal))
-;?     (print-primitive result-len:integer)
-;?     (print-primitive "\n":literal)
+;?     (print-primitive nil:literal/terminal ("result-len now: " literal))
+;?     (print-primitive nil:literal/terminal result-len:integer)
+;?     (print-primitive nil:literal/terminal "\n":literal)
     (loop)
   }
   ; rewind to start of non-template args
@@ -1749,9 +1751,9 @@
       (result-idx:integer <- add result-idx:integer 1:literal)
       (loop)
     }
-;?     (print-primitive ("i now: " literal))
-;?     (print-primitive i:integer)
-;?     (print-primitive "\n":literal)
+;?     (print-primitive nil:literal/terminal ("i now: " literal))
+;?     (print-primitive nil:literal/terminal i:integer)
+;?     (print-primitive nil:literal/terminal "\n":literal)
     ; copy 'a' into result
     (j:integer <- copy 0:literal)
     { begin
@@ -1760,11 +1762,11 @@
       (break-unless arg-done?:boolean)
       ; result[result-idx] = a[j]
       (in:byte <- index a:string-address/deref j:integer)
-;?       (print-primitive ("copying: " literal))
-;?       (print-primitive in:byte)
-;?       (print-primitive (" at: " literal))
-;?       (print-primitive result-idx:integer)
-;?       (print-primitive "\n":literal)
+;?       (print-primitive nil:literal/terminal ("copying: " literal))
+;?       (print-primitive nil:literal/terminal in:byte)
+;?       (print-primitive nil:literal/terminal (" at: " literal))
+;?       (print-primitive nil:literal/terminal result-idx:integer)
+;?       (print-primitive nil:literal/terminal "\n":literal)
       (out:byte-address <- index-address result:string-address/deref result-idx:integer)
       (out:byte-address/deref <- copy in:byte)
       ; ++j
@@ -1775,9 +1777,9 @@
     }
     ; skip '_' in template
     (i:integer <- add i:integer 1:literal)
-;?     (print-primitive ("i now: " literal))
-;?     (print-primitive i:integer)
-;?     (print-primitive "\n":literal)
+;?     (print-primitive nil:literal/terminal ("i now: " literal))
+;?     (print-primitive nil:literal/terminal i:integer)
+;?     (print-primitive nil:literal/terminal "\n":literal)
     (loop)  ; interpolate next arg
   }
   ; done with holes; copy rest of template directly into result
@@ -1787,11 +1789,11 @@
     (break-unless tem-done?:boolean)
     ; result[result-idx] = template[i]
     (in:byte <- index template:string-address/deref i:integer)
-;?     (print-primitive ("copying: " literal))
-;?     (print-primitive in:byte)
-;?     (print-primitive (" at: " literal))
-;?     (print-primitive result-idx:integer)
-;?     (print-primitive "\n":literal)
+;?     (print-primitive nil:literal/terminal ("copying: " literal))
+;?     (print-primitive nil:literal/terminal in:byte)
+;?     (print-primitive nil:literal/terminal (" at: " literal))
+;?     (print-primitive nil:literal/terminal result-idx:integer)
+;?     (print-primitive nil:literal/terminal "\n":literal)
     (out:byte-address <- index-address result:string-address/deref result-idx:integer)
     (out:byte-address/deref <- copy in:byte)
     ; ++i
@@ -1842,9 +1844,9 @@
     (loop)
   }
   ; allocate space
-;?   (print-primitive (("alloc: " literal)))
-;?   (print-primitive count:integer)
-;?   (print-primitive (("\n" literal)))
+;?   (print-primitive nil:literal/terminal (("alloc: " literal)))
+;?   (print-primitive nil:literal/terminal count:integer)
+;?   (print-primitive nil:literal/terminal (("\n" literal)))
   (result:string-address-array-address <- new string-address-array:literal count:integer)
   ; repeatedly copy slices (start..end) until delimiter into result[curr-result]
   (curr-result:integer <- copy 0:literal)
@@ -1854,13 +1856,13 @@
     (done?:boolean <- greater-or-equal start:integer len:integer)
     (break-if done?:boolean)
     (end:integer <- find-next s:string-address delim:character start:integer)
-;?     (print-primitive (("i: " literal)))
-;?     (print-primitive start:integer)
-;?     (print-primitive (("-" literal)))
-;?     (print-primitive end:integer)
-;?     (print-primitive ((" => " literal)))
-;?     (print-primitive curr-result:integer)
-;?     (print-primitive (("\n" literal)))
+;?     (print-primitive nil:literal/terminal (("i: " literal)))
+;?     (print-primitive nil:literal/terminal start:integer)
+;?     (print-primitive nil:literal/terminal (("-" literal)))
+;?     (print-primitive nil:literal/terminal end:integer)
+;?     (print-primitive nil:literal/terminal ((" => " literal)))
+;?     (print-primitive nil:literal/terminal curr-result:integer)
+;?     (print-primitive nil:literal/terminal (("\n" literal)))
     ; compute length of slice
     (slice-len:integer <- subtract end:integer start:integer)
     ; allocate result[curr-result]
@@ -1902,24 +1904,46 @@
 )
 
 (init-fn clear-screen
+  (default-space:space-address <- new space:literal 30:literal)
+  (x:terminal-address <- next-input)
+  { begin
+    (break-unless x:terminal-address)
+    (reply)
+  }
   (clear-host-screen)
 )
 
 (init-fn cursor
   (default-space:space-address <- new space:literal 30:literal)
+  (x:terminal-address <- next-input)
   (row:integer <- next-input)
   (col:integer <- next-input)
+  { begin
+    (break-unless x:terminal-address)
+    (reply)
+  }
   (cursor-on-host row:integer col:integer)
 )
 
 (init-fn cursor-to-next-line
+  (default-space:space-address <- new space:literal 30:literal)
+  (x:terminal-address <- next-input)
+  { begin
+    (break-unless x:terminal-address)
+    (reply)
+  }
   (cursor-on-host-to-next-line)
 )
 
 (init-fn print-primitive
   (default-space:space-address <- new space:literal 30:literal)
-  (x:location <- next-input)
-  (print-primitive-to-host x:location)
+  (x:terminal-address <- next-input)
+  { begin
+    (break-unless x:terminal-address)
+    (reply)
+  }
+  (c:location <- next-input)
+  (print-primitive-to-host c:location)
 )
 
 (init-fn send-prints-to-stdout
@@ -1928,7 +1952,7 @@
   { begin
     (x:tagged-value stdout:channel-address/deref <- read stdout:channel-address)
     (c:character <- maybe-coerce x:tagged-value character:literal)
-    (print-primitive c:character)
+    (print-primitive nil:literal/terminal c:character)
     (loop)
   }
 )
diff --git a/stdin.mu b/stdin.mu
index b5362f5b..d45f91ef 100644
--- a/stdin.mu
+++ b/stdin.mu
@@ -4,23 +4,23 @@
   (clear-screen)
   ; hook up stdin
   (stdin:channel-address <- init-channel 1:literal)
-;?   (print-primitive (("main: stdin is " literal)))
-;?   (print-primitive stdin:channel-address)
-;?   (print-primitive (("\n" literal)))
+;?   (print-primitive nil:literal/terminal (("main: stdin is " literal)))
+;?   (print-primitive nil:literal/terminal stdin:channel-address)
+;?   (print-primitive nil:literal/terminal (("\n" literal)))
   (fork-helper send-keys-to-stdin:fn nil:literal/globals nil:literal/limit stdin:channel-address)
   ; now read characters from stdin until a 'q' is typed
-  (print-primitive (("? " literal)))
+  (print-primitive nil:literal/terminal (("? " literal)))
   { begin
     (x:tagged-value stdin:channel-address/deref <- read stdin:channel-address)
     (c:character <- maybe-coerce x:tagged-value character:literal)
-;?     (print-primitive (("main: stdin is " literal)))
-;?     (print-primitive stdin:channel-address)
-;?     (print-primitive (("\n" literal)))
-;?     (print-primitive (("check: " literal)))
-;?     (print-primitive c:character)
+;?     (print-primitive nil:literal/terminal (("main: stdin is " literal)))
+;?     (print-primitive nil:literal/terminal stdin:channel-address)
+;?     (print-primitive nil:literal/terminal (("\n" literal)))
+;?     (print-primitive nil:literal/terminal (("check: " literal)))
+;?     (print-primitive nil:literal/terminal c:character)
     (done?:boolean <- equal c:character ((#\q literal)))
     (break-if done?:boolean)
-    (print-primitive c:character)
+    (print-primitive nil:literal/terminal c:character)
     (loop)
   }
 ])
diff --git a/tangle.mu b/tangle.mu
index b975fd2a..1004ef15 100644
--- a/tangle.mu
+++ b/tangle.mu
@@ -29,7 +29,7 @@
 
 (function main [
   (1:integer <- factorial 5:literal)
-  (print-primitive (("result: " literal)))
-  (print-primitive 1:integer)
-  (print-primitive (("\n" literal)))
+  (print-primitive nil:literal/terminal (("result: " literal)))
+  (print-primitive nil:literal/terminal 1:integer)
+  (print-primitive nil:literal/terminal (("\n" literal)))
 ])