summary refs log tree commit diff stats
path: root/tests/cpp
Commit message (Collapse)AuthorAgeFilesLines
* fixes #5142Araq2016-12-231-0/+8
|
* make travis greenAraq2016-12-221-1/+2
|
* fixes #5140Araq2016-12-221-0/+28
|
* added missing fileAndreas Rumpf2016-12-211-0/+4
|
* fixes #5136Andreas Rumpf2016-12-211-0/+10
|
* Merge branch 'devel' into sighashesAraq2016-12-171-0/+22
|\
| * reworked emit pragma; fixes #4730Andreas Rumpf2016-12-171-0/+22
| |
* | make tsigbreak.nim compileAndreas Rumpf2016-12-121-0/+28
|/
* attempt to make travis green againAraq2016-12-011-1/+1
|
* fixes #5081Araq2016-12-011-0/+3
|
* fixes #4625Andreas Rumpf2016-09-131-0/+22
|
* fixes #2259, fixes #1389Andreas Rumpf2016-06-021-0/+10
|
* Added test casemjendrusch2016-04-171-0/+9
| | | | Previously offending code
* Fix a few deprecation warningsdef2016-01-251-1/+1
|
* fixes #3299Araq2015-10-151-0/+11
|
* Rename rawsockets module to nativesocketsAdam Strzelecki2015-10-031-1/+1
| | | | | | | | | | This change was done to avoid confusion with TCP/IP raw sockets. Native sockets module represents handling native system low level socket API in general and is not just limited anyhow to TCP/IP raw sockets. A stub lib/deprecated/pure/rawsockets.nim module has been added as compatibility layer for old code using rawsockets, so this change will not break existing code.
* tests: Trim .nim files trailing whitespaceAdam Strzelecki2015-09-041-1/+1
| | | | via OSX: find . -name '*.nim' -exec sed -i '' -E 's/[[:space:]]+$//' {} +
* fixes #2841Araq2015-07-221-0/+6
|
* fixes #1888Araq2015-04-271-0/+17
|
* added test for #2536Araq2015-04-241-0/+38
|
* fixes #2505, fixes #1853, fixes #2522Araq2015-04-202-1/+2
|
* The getSubsystem<T> example in the manual currently fails with a codegen errorZahary Karadjov2015-04-142-4/+24
| | | | | | | | A faulty proc declaration is generated: N_NIMCALL(System::Input*, SystemManager::getSubsystem<'*0>())(void); The manual has been edited to add a nodecl pragma, which alleviates the issue Fix a typo in the vector_iterator example from the previous commit.
* importing of C++ nested generics like std::vector<T>::iterator, using the ↵Zahary Karadjov2015-04-131-0/+21
| | | | apostrophe operator
* fixes #1717, fixes #2324Araq2015-03-221-0/+20
|
* Add test for fix in f8d6d74368ea14403d1d455db30b669750e71651.Philip Wernersbach2015-03-151-0/+14
|
* some love for the testsuite; fixed regressionsAraq2015-03-012-2/+2
|
* Add test for #1460def2015-02-041-0/+5
|
* Add test for #1459def2015-02-041-0/+5
id='n491' href='#n491'>491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Mu - chessboard.mu</title>
<meta name="Generator" content="Vim/8.0">
<meta name="plugin-version" content="vim7.4_v2">
<meta name="syntax" content="none">
<meta name="settings" content="number_lines,use_css,pre_wrap,no_foldcolumn,expand_tabs,line_ids,prevent_copy=">
<meta name="colorscheme" content="minimal">
<style type="text/css">
<!--
pre { white-space: pre-wrap; font-family: monospace; color: #aaaaaa; background-color: #080808; }
body { font-size: 12pt; font-family: monospace; color: #aaaaaa; background-color: #080808; }
a { color:#eeeeee; text-decoration: none; }
a:hover { text-decoration: underline; }
* { font-size: 12pt; font-size: 1em; }
.CommentedCode { color: #6c6c6c; }
.muControl { color: #c0a020; }
.muRecipe { color: #ff8700; }
.muScenario { color: #00af00; }
.LineNr { color: #444444; }
.muData { color: #ffff00; }
.Delimiter { color: #800080; }
.Constant { color: #00a0a0; }
.Special { color: #c00000; }
.Comment { color: #9090ff; }
.Comment a { color:#0000ee; text-decoration:underline; }
.SalientComment { color: #00ffff; }
-->
</style>

<script type='text/javascript'>
<!--

/* function to open any folds containing a jumped-to line before jumping to it */
function JumpToLine()
{
  var lineNum;
  lineNum = window.location.hash;
  lineNum = lineNum.substr(1); /* strip off '#' */

  if (lineNum.indexOf('L') == -1) {
    lineNum = 'L'+lineNum;
  }
  lineElem = document.getElementById(lineNum);
  /* Always jump to new location even if the line was hidden inside a fold, or
   * we corrected the raw number to a line ID.
   */
  if (lineElem) {
    lineElem.scrollIntoView(true);
  }
  return true;
}
if ('onhashchange' in window) {
  window.onhashchange = JumpToLine;
}

-->
</script>
</head>
<body onload='JumpToLine();'>
<pre id='vimCodeElement'>
<span id="L1" class="LineNr">  1 </span><span class="Comment"># Chessboard program: you type in moves in algebraic notation, and it'll</span>
<span id="L2" class="LineNr">  2 </span><span class="Comment"># display the position after each move.</span>
<span id="L3" class="LineNr">  3 </span>
<span id="L4" class="LineNr">  4 </span><span class="muRecipe">def</span> <a href='chessboard.mu.html#L4'>main</a> [
<span id="L5" class="LineNr">  5 </span>  <span class="Constant">local-scope</span>
<span id="L6" class="LineNr">  6 </span>  open-console  <span class="Comment"># take control of screen, keyboard and mouse</span>
<span id="L7" class="LineNr">  7 </span>  <a href='081print.mu.html#L46'>clear-screen</a><span class="Constant"> null/screen</span>  <span class="Comment"># non-scrolling app</span>
<span id="L8" class="LineNr">  8 </span>
<span id="L9" class="LineNr">  9 </span>  <span class="Comment"># The chessboard function takes keyboard and screen objects as inputs.</span>
<span id="L10" class="LineNr"> 10 </span>  <span class="Comment">#</span>
<span id="L11" class="LineNr"> 11 </span>  <span class="Comment"># In Mu it is good form (though not required) to explicitly state what</span>
<span id="L12" class="LineNr"> 12 </span>  <span class="Comment"># hardware a function needs.</span>
<span id="L13" class="LineNr"> 13 </span>  <span class="Comment">#</span>
<span id="L14" class="LineNr"> 14 </span>  <span class="Comment"># Here the console and screen are both null, which usually indicates real</span>
<span id="L15" class="LineNr"> 15 </span>  <span class="Comment"># hardware rather than a fake for testing as you'll see below.</span>
<span id="L16" class="LineNr"> 16 </span>  <a href='chessboard.mu.html#L69'>chessboard</a><span class="Constant"> null/screen, null/console</span>
<span id="L17" class="LineNr"> 17 </span>
<span id="L18" class="LineNr"> 18 </span>  close-console  <span class="Comment"># clean up screen, keyboard and mouse</span>
<span id="L19" class="LineNr"> 19 </span>]
<span id="L20" class="LineNr"> 20 </span>
<span id="L21" class="LineNr"> 21 </span><span class="SalientComment">## But enough about Mu. Here's what it looks like to run the chessboard program.</span>
<span id="L22" class="LineNr"> 22 </span>
<span id="L23" class="LineNr"> 23 </span><span class="muScenario">scenario</span> print-board-and-read-move [
<span id="L24" class="LineNr"> 24 </span>  <span class="Constant">local-scope</span>
<span id="L25" class="LineNr"> 25 </span>  trace-until <span class="Constant">100/app</span>
<span id="L26" class="LineNr"> 26 </span>  <span class="Comment"># we'll make the screen really wide because the program currently prints out a long line</span>
<span id="L27" class="LineNr"> 27 </span>  assume-screen <span class="Constant">120/width</span>, <span class="Constant">20/height</span>
<span id="L28" class="LineNr"> 28 </span>  <span class="Comment"># initialize keyboard to type in a move</span>
<span id="L29" class="LineNr"> 29 </span>  assume-console [
<span id="L30" class="LineNr"> 30 </span>    type <span class="Constant">[a2-a4</span>
<span id="L31" class="LineNr"> 31 </span><span class="Constant">]</span>
<span id="L32" class="LineNr"> 32 </span>  ]
<span id="L33" class="LineNr"> 33 </span>  run [
<span id="L34" class="LineNr"> 34 </span>    <a href='081print.mu.html#L16'>screen</a>, <a href='084console.mu.html#L23'>console</a> <span class="Special">&lt;-</span> <a href='chessboard.mu.html#L69'>chessboard</a> <a href='081print.mu.html#L16'>screen</a>, <a href='084console.mu.html#L23'>console</a>
<span id="L35" class="LineNr"> 35 </span>    <span class="Comment"># icon for the cursor</span>
<span id="L36" class="LineNr"> 36 </span>    cursor-icon:char <span class="Special">&lt;-</span> copy <span class="Constant">9251/␣</span>
<span id="L37" class="LineNr"> 37 </span>    <a href='081print.mu.html#L16'>screen</a> <span class="Special">&lt;-</span> print <a href='081print.mu.html#L16'>screen</a>, cursor-icon
<span id="L38" class="LineNr"> 38 </span>  ]
<span id="L39" class="LineNr"> 39 </span>  screen-should-contain [
<span id="L40" class="LineNr"> 40 </span>  <span class="Comment">#            1         2         3         4         5         6         7         8         9         10        11</span>
<span id="L41" class="LineNr"> 41 </span>  <span class="Comment">#  012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789</span>
<span id="L42" class="LineNr"> 42 </span>   <span class="Constant"> .Stupid text-mode chessboard. White pieces in uppercase; black pieces in lowercase. No checking for legal moves.         .</span>
<span id="L43" class="LineNr"> 43 </span>   <span class="Constant"> .                                                                                                                        .</span>
<span id="L44" class="LineNr"> 44 </span>   <span class="Constant"> .8 | r n b q k b n r                                                                                                     .</span>
<span id="L45" class="LineNr"> 45 </span>   <span class="Constant"> .7 | p p p p p p p p                                                                                                     .</span>
<span id="L46" class="LineNr"> 46 </span>   <span class="Constant"> .6 |                                                                                                                     .</span>
<span id="L47" class="LineNr"> 47 </span>   <span class="Constant"> .5 |                                                                                                                     .</span>
<span id="L48" class="LineNr"> 48 </span>   <span class="Constant"> .4 | P                                                                                                                   .</span>
<span id="L49" class="LineNr"> 49 </span>   <span class="Constant"> .3 |                                                                                                                     .</span>
<span id="L50" class="LineNr"> 50 </span>   <span class="Constant"> .2 |   P P P P P P P                                                                                                     .</span>
<span id="L51" class="LineNr"> 51 </span>   <span class="Constant"> .1 | R N B Q K B N R                                                                                                     .</span>
<span id="L52" class="LineNr"> 52 </span>   <span class="Constant"> .  +----------------                                                                                                     .</span>
<span id="L53" class="LineNr"> 53 </span>   <span class="Constant"> .    a b c d e f g h                                                                                                     .</span>
<span id="L54" class="LineNr"> 54 </span>   <span class="Constant"> .                                                                                                                        .</span>
<span id="L55" class="LineNr"> 55 </span>   <span class="Constant"> .Type in your <a href='chessboard.mu.html#L239'>move</a> as &lt;from square&gt;-&lt;to square&gt;. For example: 'a2-a4'. Then press &lt;enter&gt;.                               .</span>
<span id="L56" class="LineNr"> 56 </span>   <span class="Constant"> .                                                                                                                        .</span>
<span id="L57" class="LineNr"> 57 </span>   <span class="Constant"> .Hit 'q' to exit.                                                                                                        .</span>
<span id="L58" class="LineNr"> 58 </span>   <span class="Constant"> .                                                                                                                        .</span>
<span id="L59" class="LineNr"> 59 </span>   <span class="Constant"> .move: ␣                                                                                                                 .</span>
<span id="L60" class="LineNr"> 60 </span>   <span class="Constant"> .                                                                                                                        .</span>
<span id="L61" class="LineNr"> 61 </span>   <span class="Constant"> .                                                                                                                        .</span>
<span id="L62" class="LineNr"> 62 </span>  ]
<span id="L63" class="LineNr"> 63 </span>]
<span id="L64" class="LineNr"> 64 </span>
<span id="L65" class="LineNr"> 65 </span><span class="SalientComment">## Here's how 'chessboard' is implemented.</span>
<span id="L66" class="LineNr"> 66 </span>
<span id="L67" class="LineNr"> 67 </span><span class="muData">type</span> <a href='chessboard.mu.html#L67'>board</a> = &amp;:@:&amp;:@:char  <span class="Comment"># a 2-D array of arrays of characters</span>
<span id="L68" class="LineNr"> 68 </span>
<span id="L69" class="LineNr"> 69 </span><span class="muRecipe">def</span> <a href='chessboard.mu.html#L69'>chessboard</a> <a href='081print.mu.html#L16'>screen</a>:&amp;:<a href='081print.mu.html#L16'>screen</a>, <a href='084console.mu.html#L23'>console</a>:&amp;:<a href='084console.mu.html#L23'>console</a><span class="muRecipe"> -&gt; </span><a href='081print.mu.html#L16'>screen</a>:&amp;:<a href='081print.mu.html#L16'>screen</a>, <a href='084console.mu.html#L23'>console</a>:&amp;:<a href='084console.mu.html#L23'>console</a> [
<span id="L70" class="LineNr"> 70 </span>  <span class="Constant">local-scope</span>
<span id="L71" class="LineNr"> 71 </span>  <span class="Constant">load-inputs</span>
<span id="L72" class="LineNr"> 72 </span>  <a href='chessboard.mu.html#L67'>board</a>:<a href='chessboard.mu.html#L67'>board</a> <span class="Special">&lt;-</span> <a href='chessboard.mu.html#L190'>initial-position</a>
<span id="L73" class="LineNr"> 73 </span>  <span class="Comment"># hook up stdin</span>
<span id="L74" class="LineNr"> 74 </span>  stdin-in:&amp;:<a href='075channel.mu.html#L36'>source</a>:char, stdin-out:&amp;:<a href='075channel.mu.html#L40'>sink</a>:char <span class="Special">&lt;-</span> <a href='075channel.mu.html#L44'>new-channel</a> <span class="Constant">10/capacity</span>
<span id="L75" class="LineNr"> 75 </span>  <span class="muControl">start-running</span> <a href='084console.mu.html#L73'>send-keys-to-channel</a>, <a href='084console.mu.html#L23'>console</a>, stdin-out, <a href='081print.mu.html#L16'>screen</a>
<span id="L76" class="LineNr"> 76 </span>  <span class="Comment"># buffer lines in stdin</span>
<span id="L77" class="LineNr"> 77 </span>  buffered-stdin-in:&amp;:<a href='075channel.mu.html#L36'>source</a>:char, buffered-stdin-out:&amp;:<a href='075channel.mu.html#L40'>sink</a>:char <span class="Special">&lt;-</span> <a href='075channel.mu.html#L44'>new-channel</a> <span class="Constant">10/capacity</span>
<span id="L78" class="LineNr"> 78 </span>  <span class="muControl">start-running</span> <a href='075channel.mu.html#L400'>buffer-lines</a>, stdin-in, buffered-stdin-out
<span id="L79" class="LineNr"> 79 </span>  <span class="Delimiter">{</span>
<span id="L80" class="LineNr"> 80 </span>    print <a href='081print.mu.html#L16'>screen</a>, <span class="Constant">[Stupid text-mode chessboard. White pieces in uppercase; black pieces in lowercase. No checking for legal moves.</span>
<span id="L81" class="LineNr"> 81 </span><span class="Constant">]</span>
<span id="L82" class="LineNr"> 82 </span>    <a href='081print.mu.html#L752'>cursor-to-next-line</a> <a href='081print.mu.html#L16'>screen</a>
<span id="L83" class="LineNr"> 83 </span>    print <a href='081print.mu.html#L16'>screen</a>, <a href='chessboard.mu.html#L67'>board</a>
<span id="L84" class="LineNr"> 84 </span>    <a href='081print.mu.html#L752'>cursor-to-next-line</a> <a href='081print.mu.html#L16'>screen</a>
<span id="L85" class="LineNr"> 85 </span>    print <a href='081print.mu.html#L16'>screen</a>, <span class="Constant">[Type in your <a href='chessboard.mu.html#L239'>move</a> as &lt;from square&gt;-&lt;to square&gt;. For example: 'a2-a4'. Then press &lt;enter&gt;.</span>
<span id="L86" class="LineNr"> 86 </span><span class="Constant">]</span>
<span id="L87" class="LineNr"> 87 </span>    <a href='081print.mu.html#L752'>cursor-to-next-line</a> <a href='081print.mu.html#L16'>screen</a>
<span id="L88" class="LineNr"> 88 </span>    print <a href='081print.mu.html#L16'>screen</a> <span class="Constant">[Hit 'q' to exit.</span>
<span id="L89" class="LineNr"> 89 </span><span class="Constant">]</span>
<span id="L90" class="LineNr"> 90 </span>    <span class="Delimiter">{</span>
<span id="L91" class="LineNr"> 91 </span>      <a href='081print.mu.html#L752'>cursor-to-next-line</a> <a href='081print.mu.html#L16'>screen</a>
<span id="L92" class="LineNr"> 92 </span>      <a href='081print.mu.html#L16'>screen</a> <span class="Special">&lt;-</span> print <a href='081print.mu.html#L16'>screen</a>, <span class="Constant">[move: ]</span>
<span id="L93" class="LineNr"> 93 </span>      m:&amp;:<a href='chessboard.mu.html#L239'>move</a>, quit:bool, error:bool <span class="Special">&lt;-</span> <a href='chessboard.mu.html#L248'>read-move</a> buffered-stdin-in, <a href='081print.mu.html#L16'>screen</a>
<span id="L94" class="LineNr"> 94 </span>      <span class="muControl">break-if</span> quit, <span class="Constant">+quit</span>
<span id="L95" class="LineNr"> 95 </span>      buffered-stdin-in <span class="Special">&lt;-</span> <a href='075channel.mu.html#L304'>clear</a> buffered-stdin-in  <span class="Comment"># cleanup after error. todo: test this?</span>
<span id="L96" class="LineNr"> 96 </span>      <span class="muControl">loop-if</span> error
<span id="L97" class="LineNr"> 97 </span>    <span class="Delimiter">}</span>
<span id="L98" class="LineNr"> 98 </span>    <a href='chessboard.mu.html#L67'>board</a> <span class="Special">&lt;-</span> <a href='chessboard.mu.html#L534'>make-move</a> <a href='chessboard.mu.html#L67'>board</a>, m
<span id="L99" class="LineNr"> 99 </span>    <a href='081print.mu.html#L16'>screen</a> <span class="Special">&lt;-</span> <a href='081print.mu.html#L46'>clear-screen</a> <a href='081print.mu.html#L16'>screen</a>
<span id="L100" class="LineNr">100 </span>   <span class="muControl"> loop</span>
<span id="L101" class="LineNr">101 </span>  <span class="Delimiter">}</span>
<span id="L102" class="LineNr">102 </span><span class="Constant">  +quit</span>
<span id="L103" class="LineNr">103 </span>]
<span id="L104" class="LineNr">104 </span>
<span id="L105" class="LineNr">105 </span><span class="SalientComment">## a board is an array of files, a file is an array of characters (squares)</span>
<span id="L106" class="LineNr">106 </span>
<span id="L107" class="LineNr">107 </span><span class="muRecipe">def</span> <a href='chessboard.mu.html#L107'>new-board</a> <a href='chessboard.mu.html#L190'>initial-position</a>:&amp;:@:char<span class="muRecipe"> -&gt; </span><a href='chessboard.mu.html#L67'>board</a>:<a href='chessboard.mu.html#L67'>board</a> [
<span id="L108" class="LineNr">108 </span>  <span class="Constant">local-scope</span>
<span id="L109" class="LineNr">109 </span>  <span class="Constant">load-inputs</span>
<span id="L110" class="LineNr">110 </span>  <span class="Comment"># assert(length(initial-position) == 64)</span>
<span id="L111" class="LineNr">111 </span>  len:num <span class="Special">&lt;-</span> length *initial-position
<span id="L112" class="LineNr">112 </span>  correct-length?:bool <span class="Special">&lt;-</span> equal len,<span class="Constant"> 64</span>
<span id="L113" class="LineNr">113 </span>  assert correct-length?, <span class="Constant">[chessboard had incorrect size]</span>
<span id="L114" class="LineNr">114 </span>  <span class="Comment"># board is an array of pointers to files; file is an array of characters</span>
<span id="L115" class="LineNr">115 </span>  <a href='chessboard.mu.html#L67'>board</a> <span class="Special">&lt;-</span> new <span class="Delimiter">{</span>(address array character): type<span class="Delimiter">}</span>,<span class="Constant"> 8</span>
<span id="L116" class="LineNr">116 </span>  col:num <span class="Special">&lt;-</span> copy<span class="Constant"> 0</span>
<span id="L117" class="LineNr">117 </span>  <span class="Delimiter">{</span>
<span id="L118" class="LineNr">118 </span>    done?:bool <span class="Special">&lt;-</span> equal col,<span class="Constant"> 8</span>
<span id="L119" class="LineNr">119 </span>    <span class="muControl">break-if</span> done?
<span id="L120" class="LineNr">120 </span>    file:&amp;:@:char <span class="Special">&lt;-</span> <a href='chessboard.mu.html#L127'>new-file</a> <a href='chessboard.mu.html#L190'>initial-position</a>, col
<span id="L121" class="LineNr">121 </span>    *board <span class="Special">&lt;-</span> put-index *board, col, file
<span id="L122" class="LineNr">122 </span>    col <span class="Special">&lt;-</span> add col,<span class="Constant"> 1</span>
<span id="L123" class="LineNr">123 </span>   <span class="muControl"> loop</span>
<span id="L124" class="LineNr">124 </span>  <span class="Delimiter">}</span>
<span id="L125" class="LineNr">125 </span>]
<span id="L126" class="LineNr">126 </span>
<span id="L127" class="LineNr">127 </span><span class="muRecipe">def</span> <a href='chessboard.mu.html#L127'>new-file</a> position:&amp;:@:char, index:num<span class="muRecipe"> -&gt; </span>result:&amp;:@:char [
<span id="L128" class="LineNr">128 </span>  <span class="Constant">local-scope</span>
<span id="L129" class="LineNr">129 </span>  <span class="Constant">load-inputs</span>
<span id="L130" class="LineNr">130 </span>  index <span class="Special">&lt;-</span> multiply index,<span class="Constant"> 8</span>
<span id="L131" class="LineNr">131 </span>  result <span class="Special">&lt;-</span> new <span class="Constant">character:type</span>,<span class="Constant"> 8</span>
<span id="L132" class="LineNr">132 </span>  row:num <span class="Special">&lt;-</span> copy<span class="Constant"> 0</span>
<span id="L133" class="LineNr">133 </span>  <span class="Delimiter">{</span>
<span id="L134" class="LineNr">134 </span>    done?:bool <span class="Special">&lt;-</span> equal row,<span class="Constant"> 8</span>
<span id="L135" class="LineNr">135 </span>    <span class="muControl">break-if</span> done?
<span id="L136" class="LineNr">136 </span>    square:char <span class="Special">&lt;-</span> index *position, index
<span id="L137" class="LineNr">137 </span>    *result <span class="Special">&lt;-</span> put-index *result, row, square
<span id="L138" class="LineNr">138 </span>    row <span class="Special">&lt;-</span> add row,<span class="Constant"> 1</span>
<span id="L139" class="LineNr">139 </span>    index <span class="Special">&lt;-</span> add index,<span class="Constant"> 1</span>
<span id="L140" class="LineNr">140 </span>   <span class="muControl"> loop</span>
<span id="L141" class="LineNr">141 </span>  <span class="Delimiter">}</span>
<span id="L142" class="LineNr">142 </span>]
<span id="L143" class="LineNr">143 </span>
<span id="L144" class="LineNr">144 </span><span class="muRecipe">def</span> print <a href='081print.mu.html#L16'>screen</a>:&amp;:<a href='081print.mu.html#L16'>screen</a>, <a href='chessboard.mu.html#L67'>board</a>:<a href='chessboard.mu.html#L67'>board</a><span class="muRecipe"> -&gt; </span><a href='081print.mu.html#L16'>screen</a>:&amp;:<a href='081print.mu.html#L16'>screen</a> [
<span id="L145" class="LineNr">145 </span>  <span class="Constant">local-scope</span>
<span id="L146" class="LineNr">146 </span>  <span class="Constant">load-inputs</span>
<span id="L147" class="LineNr">147 </span>  row:num <span class="Special">&lt;-</span> copy<span class="Constant"> 7</span>  <span class="Comment"># start printing from the top of the board</span>
<span id="L148" class="LineNr">148 </span>  space:char <span class="Special">&lt;-</span> copy <span class="Constant">32/space</span>
<span id="L149" class="LineNr">149 </span>  <span class="Comment"># print each row</span>
<span id="L150" class="LineNr">150 </span>  <span class="Delimiter">{</span>
<span id="L151" class="LineNr">151 </span>    done?:bool <span class="Special">&lt;-</span> lesser-than row,<span class="Constant"> 0</span>
<span id="L152" class="LineNr">152 </span>    <span class="muControl">break-if</span> done?
<span id="L153" class="LineNr">153 </span>    <span class="Comment"># print rank number as a legend</span>
<span id="L154" class="LineNr">154 </span>    rank:num <span class="Special">&lt;-</span> add row,<span class="Constant"> 1</span>
<span id="L155" class="LineNr">155 </span>    print <a href='081print.mu.html#L16'>screen</a>, rank
<span id="L156" class="LineNr">156 </span>    print <a href='081print.mu.html#L16'>screen</a>, <span class="Constant">[ | ]</span>
<span id="L157" class="LineNr">157 </span>    <span class="Comment"># print each square in the row</span>
<span id="L158" class="LineNr">158 </span>    col:num <span class="Special">&lt;-</span> copy<span class="Constant"> 0</span>
<span id="L159" class="LineNr">159 </span>    <span class="Delimiter">{</span>
<span id="L160" class="LineNr">160 </span>      done?:bool <span class="Special">&lt;-</span> equal col:num,<span class="Constant"> 8</span>
<span id="L161" class="LineNr">161 </span>      <span class="muControl">break-if</span> done?
<span id="L162" class="LineNr">162 </span>      f:&amp;:@:char <span class="Special">&lt;-</span> index *board, col
<span id="L163" class="LineNr">163 </span>      c:char <span class="Special">&lt;-</span> index *f, row
<span id="L164" class="LineNr">164 </span>      bg:num <span class="Special">&lt;-</span> <a href='chessboard.mu.html#L181'>square-color</a> row, col
<span id="L165" class="LineNr">165 </span>      print <a href='081print.mu.html#L16'>screen</a>, c, <span class="Constant">7/white</span>, bg
<span id="L166" class="LineNr">166 </span>      print <a href='081print.mu.html#L16'>screen</a>, space
<span id="L167" class="LineNr">167 </span>      col <span class="Special">&lt;-</span> add col,<span class="Constant"> 1</span>
<span id="L168" class="LineNr">168 </span>     <span class="muControl"> loop</span>
<span id="L169" class="LineNr">169 </span>    <span class="Delimiter">}</span>
<span id="L170" class="LineNr">170 </span>    row <span class="Special">&lt;-</span> subtract row,<span class="Constant"> 1</span>
<span id="L171" class="LineNr">171 </span>    <a href='081print.mu.html#L752'>cursor-to-next-line</a> <a href='081print.mu.html#L16'>screen</a>
<span id="L172" class="LineNr">172 </span>   <span class="muControl"> loop</span>
<span id="L173" class="LineNr">173 </span>  <span class="Delimiter">}</span>
<span id="L174" class="LineNr">174 </span>  <span class="Comment"># print file letters as legend</span>
<span id="L175" class="LineNr">175 </span>  print <a href='081print.mu.html#L16'>screen</a>, <span class="Constant">[  +----------------]</span>
<span id="L176" class="LineNr">176 </span>  <a href='081print.mu.html#L752'>cursor-to-next-line</a> <a href='081print.mu.html#L16'>screen</a>
<span id="L177" class="LineNr">177 </span>  print <a href='081print.mu.html#L16'>screen</a>, <span class="Constant">[    a b c d e f g h]</span>
<span id="L178" class="LineNr">178 </span>  <a href='081print.mu.html#L752'>cursor-to-next-line</a> <a href='081print.mu.html#L16'>screen</a>
<span id="L179" class="LineNr">179 </span>]
<span id="L180" class="LineNr">180 </span>
<span id="L181" class="LineNr">181 </span><span class="muRecipe">def</span> <a href='chessboard.mu.html#L181'>square-color</a> row:num, col:num<span class="muRecipe"> -&gt; </span>result:num [
<span id="L182" class="LineNr">182 </span>  <span class="Constant">local-scope</span>
<span id="L183" class="LineNr">183 </span>  <span class="Constant">load-inputs</span>
<span id="L184" class="LineNr">184 </span>  result <span class="Special">&lt;-</span> copy <span class="Constant">0/black</span>
<span id="L185" class="LineNr">185 </span>  x:num <span class="Special">&lt;-</span> add row, col
<span id="L186" class="LineNr">186 </span>  _, rem:num <span class="Special">&lt;-</span> divide-with-remainder x,<span class="Constant"> 2</span>
<span id="L187" class="LineNr">187 </span>  <span class="muControl">return-if</span> rem,<span class="Constant"> 238</span>
<span id="L188" class="LineNr">188 </span>]
<span id="L189" class="LineNr">189 </span>
<span id="L190" class="LineNr">190 </span><span class="muRecipe">def</span> <a href='chessboard.mu.html#L190'>initial-position</a><span class="muRecipe"> -&gt; </span><a href='chessboard.mu.html#L67'>board</a>:<a href='chessboard.mu.html#L67'>board</a> [
<span id="L191" class="LineNr">191 </span>  <span class="Constant">local-scope</span>
<span id="L192" class="LineNr">192 </span>  <span class="Comment"># layout in memory (in raster order):</span>
<span id="L193" class="LineNr">193 </span>  <span class="Comment">#   R P _ _ _ _ p r</span>
<span id="L194" class="LineNr">194 </span>  <span class="Comment">#   N P _ _ _ _ p n</span>
<span id="L195" class="LineNr">195 </span>  <span class="Comment">#   B P _ _ _ _ p b</span>
<span id="L196" class="LineNr">196 </span>  <span class="Comment">#   Q P _ _ _ _ p q</span>
<span id="L197" class="LineNr">197 </span>  <span class="Comment">#   K P _ _ _ _ p k</span>
<span id="L198" class="LineNr">198 </span>  <span class="Comment">#   B P _ _ _ _ p B</span>
<span id="L199" class="LineNr">199 </span>  <span class="Comment">#   N P _ _ _ _ p n</span>
<span id="L200" class="LineNr">200 </span>  <span class="Comment">#   R P _ _ _ _ p r</span>
<span id="L201" class="LineNr">201 </span>  <a href='chessboard.mu.html#L190'>initial-position</a>:&amp;:@:char <span class="Special">&lt;-</span> <a href='063array.mu.html#L16'>new-array</a> <span class="Constant">82/R</span>, <span class="Constant">80/P</span>, <span class="Constant">32/blank</span>, <span class="Constant">32/blank</span>, <span class="Constant">32/blank</span>, <span class="Constant">32/blank</span>, <span class="Constant">112/p</span>, <span class="Constant">114/r</span>, <span class="Constant">78/N</span>, <span class="Constant">80/P</span>, <span class="Constant">32/blank</span>, <span class="Constant">32/blank</span>, <span class="Constant">32/blank</span>, <span class="Constant">32/blank</span>, <span class="Constant">112/p</span>, <span class="Constant">110/n</span>, <span class="Constant">66/B</span>, <span class="Constant">80/P</span>, <span class="Constant">32/blank</span>, <span class="Constant">32/blank</span>, <span class="Constant">32/blank</span>, <span class="Constant">32/blank</span>, <span class="Constant">112/p</span>, <span class="Constant">98/b</span>, <span class="Constant">81/Q</span>, <span class="Constant">80/P</span>, <span class="Constant">32/blank</span>, <span class="Constant">32/blank</span>, <span class="Constant">32/blank</span>, <span class="Constant">32/blank</span>, <span class="Constant">112/p</span>, <span class="Constant">113/q</span>, <span class="Constant">75/K</span>, <span class="Constant">80/P</span>, <span class="Constant">32/blank</span>, <span class="Constant">32/blank</span>, <span class="Constant">32/blank</span>, <span class="Constant">32/blank</span>, <span class="Constant">112/p</span>, <span class="Constant">107/k</span>, <span class="Constant">66/B</span>, <span class="Constant">80/P</span>, <span class="Constant">32/blank</span>, <span class="Constant">32/blank</span>, <span class="Constant">32/blank</span>, <span class="Constant">32/blank</span>, <span class="Constant">112/p</span>, <span class="Constant">98/b</span>, <span class="Constant">78/N</span>, <span class="Constant">80/P</span>, <span class="Constant">32/blank</span>, <span class="Constant">32/blank</span>, <span class="Constant">32/blank</span>, <span class="Constant">32/blank</span>, <span class="Constant">112/p</span>, <span class="Constant">110/n</span>, <span class="Constant">82/R</span>, <span class="Constant">80/P</span>, <span class="Constant">32/blank</span>, <span class="Constant">32/blank</span>, <span class="Constant">32/blank</span>, <span class="Constant">32/blank</span>, <span class="Constant">112/p</span>, <span class="Constant">114/r</span>
<span id="L202" class="LineNr">202 </span><span class="CommentedCode">#?       82/R, 80/P, 32/blank, 32/blank, 32/blank, 32/blank, 112/p, 114/r,</span>
<span id="L203" class="LineNr">203 </span><span class="CommentedCode">#?       78/N, 80/P, 32/blank, 32/blank, 32/blank, 32/blank, 112/p, 110/n,</span>
<span id="L204" class="LineNr">204 </span><span class="CommentedCode">#?       66/B, 80/P, 32/blank, 32/blank, 32/blank, 32/blank, 112/p, 98/b, </span>
<span id="L205" class="LineNr">205 </span><span class="CommentedCode">#?       81/Q, 80/P, 32/blank, 32/blank, 32/blank, 32/blank, 112/p, 113/q,</span>
<span id="L206" class="LineNr">206 </span><span class="CommentedCode">#?       75/K, 80/P, 32/blank, 32/blank, 32/blank, 32/blank, 112/p, 107/k,</span>
<span id="L207" class="LineNr">207 </span><span class="CommentedCode">#?       66/B, 80/P, 32/blank, 32/blank, 32/blank, 32/blank, 112/p, 98/b,</span>
<span id="L208" class="LineNr">208 </span><span class="CommentedCode">#?       78/N, 80/P, 32/blank, 32/blank, 32/blank, 32/blank, 112/p, 110/n,</span>
<span id="L209" class="LineNr">209 </span><span class="CommentedCode">#?       82/R, 80/P, 32/blank, 32/blank, 32/blank, 32/blank, 112/p, 114/r</span>
<span id="L210" class="LineNr">210 </span>  <a href='chessboard.mu.html#L67'>board</a> <span class="Special">&lt;-</span> <a href='chessboard.mu.html#L107'>new-board</a> <a href='chessboard.mu.html#L190'>initial-position</a>
<span id="L211" class="LineNr">211 </span>]
<span id="L212" class="LineNr">212 </span>
<span id="L213" class="LineNr">213 </span><span class="muScenario">scenario</span> printing-the-board [
<span id="L214" class="LineNr">214 </span>  <span class="Constant">local-scope</span>
<span id="L215" class="LineNr">215 </span>  <a href='chessboard.mu.html#L67'>board</a>:<a href='chessboard.mu.html#L67'>board</a> <span class="Special">&lt;-</span> <a href='chessboard.mu.html#L190'>initial-position</a>
<span id="L216" class="LineNr">216 </span>  assume-screen <span class="Constant">30/width</span>, <span class="Constant">12/height</span>
<span id="L217" class="LineNr">217 </span>  run [
<span id="L218" class="LineNr">218 </span>    <a href='081print.mu.html#L16'>screen</a> <span class="Special">&lt;-</span> print <a href='081print.mu.html#L16'>screen</a>, <a href='chessboard.mu.html#L67'>board</a>
<span id="L219" class="LineNr">219 </span>  ]
<span id="L220" class="LineNr">220 </span>  screen-should-contain [
<span id="L221" class="LineNr">221 </span>  <span class="Comment">#  012345678901234567890123456789</span>
<span id="L222" class="LineNr">222 </span>   <span class="Constant"> .8 | r n b q k b n r           .</span>
<span id="L223" class="LineNr">223 </span>   <span class="Constant"> .7 | p p p p p p p p           .</span>
<span id="L224" class="LineNr">224 </span>   <span class="Constant"> .6 |                           .</span>
<span id="L225" class="LineNr">225 </span>   <span class="Constant"> .5 |                           .</span>
<span id="L226" class="LineNr">226 </span>   <span class="Constant"> .4 |                           .</span>
<span id="L227" class="LineNr">227 </span>   <span class="Constant"> .3 |                           .</span>
<span id="L228" class="LineNr">228 </span>   <span class="Constant"> .2 | P P P P P P P P           .</span>
<span id="L229" class="LineNr">229 </span>   <span class="Constant"> .1 | R N B Q K B N R           .</span>
<span id="L230" class="LineNr">230 </span>   <span class="Constant"> .  +----------------           .</span>
<span id="L231" class="LineNr">231 </span>   <span class="Constant"> .    a b c d e f g h           .</span>
<span id="L232" class="LineNr">232 </span>   <span class="Constant"> .                              .</span>
<span id="L233" class="LineNr">233 </span>   <span class="Constant"> .                              .</span>
<span id="L234" class="LineNr">234 </span>  ]
<span id="L235" class="LineNr">235 </span>]
<span id="L236" class="LineNr">236 </span>
<span id="L237" class="LineNr">237 </span><span class="SalientComment">## data structure: move</span>
<span id="L238" class="LineNr">238 </span>
<span id="L239" class="LineNr">239 </span><span class="muData">container</span> <a href='chessboard.mu.html#L239'>move</a> [
<span id="L240" class="LineNr">240 </span>  <span class="Comment"># valid range: 0-7</span>
<span id="L241" class="LineNr">241 </span>  from-file:num
<span id="L242" class="LineNr">242 </span>  from-rank:num
<span id="L243" class="LineNr">243 </span>  to-file:num
<span id="L244" class="LineNr">244 </span>  to-rank:num
<span id="L245" class="LineNr">245 </span>]
<span id="L246" class="LineNr">246 </span>
<span id="L247" class="LineNr">247 </span><span class="Comment"># prints only error messages to screen</span>
<span id="L248" class="LineNr">248 </span><span class="muRecipe">def</span> <a href='chessboard.mu.html#L248'>read-move</a> stdin:&amp;:<a href='075channel.mu.html#L36'>source</a>:char, <a href='081print.mu.html#L16'>screen</a>:&amp;:<a href='081print.mu.html#L16'>screen</a><span class="muRecipe"> -&gt; </span>result:&amp;:<a href='chessboard.mu.html#L239'>move</a>, quit?:bool, error?:bool, stdin:&amp;:<a href='075channel.mu.html#L36'>source</a>:char, <a href='081print.mu.html#L16'>screen</a>:&amp;:<a href='081print.mu.html#L16'>screen</a> [
<span id="L249" class="LineNr">249 </span>  <span class="Constant">local-scope</span>
<span id="L250" class="LineNr">250 </span>  <span class="Constant">load-inputs</span>
<span id="L251" class="LineNr">251 </span>  from-file:num, quit?:bool, error?:bool <span class="Special">&lt;-</span> <a href='chessboard.mu.html#L276'>read-file</a> stdin, <a href='081print.mu.html#L16'>screen</a>
<span id="L252" class="LineNr">252 </span>  <span class="muControl">return-if</span> quit?,<span class="Constant"> null/dummy</span>
<span id="L253" class="LineNr">253 </span>  <span class="muControl">return-if</span> error?,<span class="Constant"> null/dummy</span>
<span id="L254" class="LineNr">254 </span>  <span class="Comment"># construct the move object</span>
<span id="L255" class="LineNr">255 </span>  result:&amp;:<a href='chessboard.mu.html#L239'>move</a> <span class="Special">&lt;-</span> new <span class="Constant"><a href='chessboard.mu.html#L239'>move</a>:type</span>
<span id="L256" class="LineNr">256 </span>  *result <span class="Special">&lt;-</span> put *result, <span class="Constant">from-file:offset</span>, from-file
<span id="L257" class="LineNr">257 </span>  from-rank:num, quit?, error? <span class="Special">&lt;-</span> <a href='chessboard.mu.html#L314'>read-rank</a> stdin, <a href='081print.mu.html#L16'>screen</a>
<span id="L258" class="LineNr">258 </span>  <span class="muControl">return-if</span> quit?,<span class="Constant"> null/dummy</span>
<span id="L259" class="LineNr">259 </span>  <span class="muControl">return-if</span> error?,<span class="Constant"> null/dummy</span>
<span id="L260" class="LineNr">260 </span>  *result <span class="Special">&lt;-</span> put *result, <span class="Constant">from-rank:offset</span>, from-rank
<span id="L261" class="LineNr">261 </span>  error? <span class="Special">&lt;-</span> <a href='chessboard.mu.html#L352'>expect-from-channel</a> stdin, <span class="Constant">45/dash</span>, <a href='081print.mu.html#L16'>screen</a>
<span id="L262" class="LineNr">262 </span>  <span class="muControl">return-if</span> error?,<span class="Constant"> null/dummy, false/quit</span>
<span id="L263" class="LineNr">263 </span>  to-file:num, quit?, error? <span class="Special">&lt;-</span> <a href='chessboard.mu.html#L276'>read-file</a> stdin, <a href='081print.mu.html#L16'>screen</a>
<span id="L264" class="LineNr">264 </span>  <span class="muControl">return-if</span> quit?,<span class="Constant"> null/dummy</span>
<span id="L265" class="LineNr">265 </span>  <span class="muControl">return-if</span> error?,<span class="Constant"> null/dummy</span>
<span id="L266" class="LineNr">266 </span>  *result <span class="Special">&lt;-</span> put *result, <span class="Constant">to-file:offset</span>, to-file
<span id="L267" class="LineNr">267 </span>  to-rank:num, quit?, error? <span class="Special">&lt;-</span> <a href='chessboard.mu.html#L314'>read-rank</a> stdin, <a href='081print.mu.html#L16'>screen</a>
<span id="L268" class="LineNr">268 </span>  <span class="muControl">return-if</span> quit?,<span class="Constant"> null/dummy</span>
<span id="L269" class="LineNr">269 </span>  <span class="muControl">return-if</span> error?,<span class="Constant"> null/dummy</span>
<span id="L270" class="LineNr">270 </span>  *result <span class="Special">&lt;-</span> put *result, <span class="Constant">to-rank:offset</span>, to-rank
<span id="L271" class="LineNr">271 </span>  error? <span class="Special">&lt;-</span> <a href='chessboard.mu.html#L352'>expect-from-channel</a> stdin, <span class="Constant">10/newline</span>, <a href='081print.mu.html#L16'>screen</a>
<span id="L272" class="LineNr">272 </span>  <span class="muControl">return-if</span> error?,<span class="Constant"> null/dummy, false/quit</span>
<span id="L273" class="LineNr">273 </span>]
<span id="L274" class="LineNr">274 </span>
<span id="L275" class="LineNr">275 </span><span class="Comment"># valid values for file: 0-7</span>
<span id="L276" class="LineNr">276 </span><span class="muRecipe">def</span> <a href='chessboard.mu.html#L276'>read-file</a> stdin:&amp;:<a href='075channel.mu.html#L36'>source</a>:char, <a href='081print.mu.html#L16'>screen</a>:&amp;:<a href='081print.mu.html#L16'>screen</a><span class="muRecipe"> -&gt; </span>file:num, quit:bool, error:bool, stdin:&amp;:<a href='075channel.mu.html#L36'>source</a>:char, <a href='081print.mu.html#L16'>screen</a>:&amp;:<a href='081print.mu.html#L16'>screen</a> [
<span id="L277" class="LineNr">277 </span>  <span class="Constant">local-scope</span>
<span id="L278" class="LineNr">278 </span>  <span class="Constant">load-inputs</span>
<span id="L279" class="LineNr">279 </span>  c:char, eof?:bool, stdin <span class="Special">&lt;-</span> read stdin
<span id="L280" class="LineNr">280 </span>  <span class="muControl">return-if</span> eof?, <span class="Constant">0/dummy</span>,<span class="Constant"> true/quit, false/no-error</span>
<span id="L281" class="LineNr">281 </span>  q-pressed?:bool <span class="Special">&lt;-</span> equal c, <span class="Constant">81/Q</span>
<span id="L282" class="LineNr">282 </span>  <span class="muControl">return-if</span> q-pressed?, <span class="Constant">0/dummy</span>,<span class="Constant"> true/quit, false/no-error</span>
<span id="L283" class="LineNr">283 </span>  q-pressed? <span class="Special">&lt;-</span> equal c, <span class="Constant">113/q</span>
<span id="L284" class="LineNr">284 </span>  <span class="muControl">return-if</span> q-pressed?, <span class="Constant">0/dummy</span>,<span class="Constant"> true/quit, false/no-error</span>
<span id="L285" class="LineNr">285 </span>  empty-fake-keyboard?:bool <span class="Special">&lt;-</span> equal c, <span class="Constant">0/eof</span>
<span id="L286" class="LineNr">286 </span>  <span class="muControl">return-if</span> empty-fake-keyboard?, <span class="Constant">0/dummy</span>,<span class="Constant"> true/quit, false/no-error</span>
<span id="L287" class="LineNr">287 </span>  <span class="Delimiter">{</span>
<span id="L288" class="LineNr">288 </span>    newline?:bool <span class="Special">&lt;-</span> equal c, <span class="Constant">10/newline</span>
<span id="L289" class="LineNr">289 </span>    <span class="muControl">break-unless</span> newline?
<span id="L290" class="LineNr">290 </span>    print <a href='081print.mu.html#L16'>screen</a>, <span class="Constant">[that's not enough]</span>
<span id="L291" class="LineNr">291 </span>   <span class="muControl"> return</span> <span class="Constant">0/dummy</span>,<span class="Constant"> false/don't-quit, true/error</span>
<span id="L292" class="LineNr">292 </span>  <span class="Delimiter">}</span>
<span id="L293" class="LineNr">293 </span>  file:num <span class="Special">&lt;-</span> subtract c, <span class="Constant">97/a</span>
<span id="L294" class="LineNr">294 </span>  <span class="Comment"># 'a' &lt;= file &lt;= 'h'</span>
<span id="L295" class="LineNr">295 </span>  <span class="Delimiter">{</span>
<span id="L296" class="LineNr">296 </span>    above-min:bool <span class="Special">&lt;-</span> greater-or-equal file,<span class="Constant"> 0</span>
<span id="L297" class="LineNr">297 </span>    <span class="muControl">break-if</span> above-min
<span id="L298" class="LineNr">298 </span>    print <a href='081print.mu.html#L16'>screen</a>, <span class="Constant">[file too low: ]</span>
<span id="L299" class="LineNr">299 </span>    print <a href='081print.mu.html#L16'>screen</a>, c
<span id="L300" class="LineNr">300 </span>    <a href='081print.mu.html#L752'>cursor-to-next-line</a> <a href='081print.mu.html#L16'>screen</a>
<span id="L301" class="LineNr">301 </span>   <span class="muControl"> return</span> <span class="Constant">0/dummy</span>,<span class="Constant"> false/don't-quit, true/error</span>
<span id="L302" class="LineNr">302 </span>  <span class="Delimiter">}</span>
<span id="L303" class="LineNr">303 </span>  <span class="Delimiter">{</span>
<span id="L304" class="LineNr">304 </span>    below-max:bool <span class="Special">&lt;-</span> lesser-than file,<span class="Constant"> 8</span>
<span id="L305" class="LineNr">305 </span>    <span class="muControl">break-if</span> below-max
<span id="L306" class="LineNr">306 </span>    print <a href='081print.mu.html#L16'>screen</a>, <span class="Constant">[file too high: ]</span>
<span id="L307" class="LineNr">307 </span>    print <a href='081print.mu.html#L16'>screen</a>, c
<span id="L308" class="LineNr">308 </span>   <span class="muControl"> return</span> <span class="Constant">0/dummy</span>,<span class="Constant"> false/don't-quit, true/error</span>
<span id="L309" class="LineNr">309 </span>  <span class="Delimiter">}</span>
<span id="L310" class="LineNr">310 </span> <span class="muControl"> return</span> file,<span class="Constant"> false/don't-quit, false/no-error</span>
<span id="L311" class="LineNr">311 </span>]
<span id="L312" class="LineNr">312 </span>
<span id="L313" class="LineNr">313 </span><span class="Comment"># valid values for rank: 0-7</span>
<span id="L314" class="LineNr">314 </span><span class="muRecipe">def</span> <a href='chessboard.mu.html#L314'>read-rank</a> stdin:&amp;:<a href='075channel.mu.html#L36'>source</a>:char, <a href='081print.mu.html#L16'>screen</a>:&amp;:<a href='081print.mu.html#L16'>screen</a><span class="muRecipe"> -&gt; </span>rank:num, quit?:bool, error?:bool, stdin:&amp;:<a href='075channel.mu.html#L36'>source</a>:char, <a href='081print.mu.html#L16'>screen</a>:&amp;:<a href='081print.mu.html#L16'>screen</a> [
<span id="L315" class="LineNr">315 </span>  <span class="Constant">local-scope</span>
<span id="L316" class="LineNr">316 </span>  <span class="Constant">load-inputs</span>
<span id="L317" class="LineNr">317 </span>  c:char, eof?:bool, stdin <span class="Special">&lt;-</span> read stdin
<span id="L318" class="LineNr">318 </span>  <span class="muControl">return-if</span> eof?, <span class="Constant">0/dummy</span>,<span class="Constant"> true/quit, false/no-error</span>
<span id="L319" class="LineNr">319 </span>  q-pressed?:bool <span class="Special">&lt;-</span> equal c, <span class="Constant">81/Q</span>
<span id="L320" class="LineNr">320 </span>  <span class="muControl">return-if</span> q-pressed?, <span class="Constant">0/dummy</span>,<span class="Constant"> true/quit, false/no-error</span>
<span id="L321" class="LineNr">321 </span>  q-pressed? <span class="Special">&lt;-</span> equal c, <span class="Constant">113/q</span>
<span id="L322" class="LineNr">322 </span>  <span class="muControl">return-if</span> q-pressed?, <span class="Constant">0/dummy</span>,<span class="Constant"> true/quit, false/no-error</span>
<span id="L323" class="LineNr">323 </span>  empty-fake-keyboard?:bool <span class="Special">&lt;-</span> equal c, <span class="Constant">0/eof</span>
<span id="L324" class="LineNr">324 </span>  <span class="muControl">return-if</span> empty-fake-keyboard?, <span class="Constant">0/dummy</span>,<span class="Constant"> true/quit, false/no-error</span>
<span id="L325" class="LineNr">325 </span>  <span class="Delimiter">{</span>
<span id="L326" class="LineNr">326 </span>    newline?:bool <span class="Special">&lt;-</span> equal c,<span class="Constant"> 10</span>  <span class="Comment"># newline</span>
<span id="L327" class="LineNr">327 </span>    <span class="muControl">break-unless</span> newline?
<span id="L328" class="LineNr">328 </span>    print <a href='081print.mu.html#L16'>screen</a>, <span class="Constant">[that's not enough]</span>
<span id="L329" class="LineNr">329 </span>   <span class="muControl"> return</span> <span class="Constant">0/dummy</span>,<span class="Constant"> false/don't-quite, true/error</span>
<span id="L330" class="LineNr">330 </span>  <span class="Delimiter">}</span>
<span id="L331" class="LineNr">331 </span>  rank:num <span class="Special">&lt;-</span> subtract c, <span class="Constant">49/'1'</span>
<span id="L332" class="LineNr">332 </span>  <span class="Comment"># assert'1' &lt;= rank &lt;= '8'</span>
<span id="L333" class="LineNr">333 </span>  <span class="Delimiter">{</span>
<span id="L334" class="LineNr">334 </span>    above-min:bool <span class="Special">&lt;-</span> greater-or-equal rank,<span class="Constant"> 0</span>
<span id="L335" class="LineNr">335 </span>    <span class="muControl">break-if</span> above-min
<span id="L336" class="LineNr">336 </span>    print <a href='081print.mu.html#L16'>screen</a>, <span class="Constant">[rank too low: ]</span>
<span id="L337" class="LineNr">337 </span>    print <a href='081print.mu.html#L16'>screen</a>, c
<span id="L338" class="LineNr">338 </span>   <span class="muControl"> return</span> <span class="Constant">0/dummy</span>,<span class="Constant"> false/don't-quite, true/error</span>
<span id="L339" class="LineNr">339 </span>  <span class="Delimiter">}</span>
<span id="L340" class="LineNr">340 </span>  <span class="Delimiter">{</span>
<span id="L341" class="LineNr">341 </span>    below-max:bool <span class="Special">&lt;-</span> lesser-or-equal rank,<span class="Constant"> 7</span>
<span id="L342" class="LineNr">342 </span>    <span class="muControl">break-if</span> below-max
<span id="L343" class="LineNr">343 </span>    print <a href='081print.mu.html#L16'>screen</a>, <span class="Constant">[rank too high: ]</span>
<span id="L344" class="LineNr">344 </span>    print <a href='081print.mu.html#L16'>screen</a>, c
<span id="L345" class="LineNr">345 </span>   <span class="muControl"> return</span> <span class="Constant">0/dummy</span>,<span class="Constant"> false/don't-quite, true/error</span>
<span id="L346" class="LineNr">346 </span>  <span class="Delimiter">}</span>
<span id="L347" class="LineNr">347 </span> <span class="muControl"> return</span> rank,<span class="Constant"> false/don't-quite, false/no-error</span>
<span id="L348" class="LineNr">348 </span>]
<span id="L349" class="LineNr">349 </span>
<span id="L350" class="LineNr">350 </span><span class="Comment"># read a character from the given channel and check that it's what we expect</span>
<span id="L351" class="LineNr">351 </span><span class="Comment"># return true on error</span>
<span id="L352" class="LineNr">352 </span><span class="muRecipe">def</span> <a href='chessboard.mu.html#L352'>expect-from-channel</a> stdin:&amp;:<a href='075channel.mu.html#L36'>source</a>:char, expected:char, <a href='081print.mu.html#L16'>screen</a>:&amp;:<a href='081print.mu.html#L16'>screen</a><span class="muRecipe"> -&gt; </span>result:bool, stdin:&amp;:<a href='075channel.mu.html#L36'>source</a>:char, <a href='081print.mu.html#L16'>screen</a>:&amp;:<a href='081print.mu.html#L16'>screen</a> [
<span id="L353" class="LineNr">353 </span>  <span class="Constant">local-scope</span>
<span id="L354" class="LineNr">354 </span>  <span class="Constant">load-inputs</span>
<span id="L355" class="LineNr">355 </span>  c:char, eof?:bool, stdin <span class="Special">&lt;-</span> read stdin
<span id="L356" class="LineNr">356 </span>  <span class="muControl">return-if</span> eof?<span class="Constant"> true</span>
<span id="L357" class="LineNr">357 </span>  <span class="Delimiter">{</span>
<span id="L358" class="LineNr">358 </span>    match?:bool <span class="Special">&lt;-</span> equal c, expected
<span id="L359" class="LineNr">359 </span>    <span class="muControl">break-if</span> match?
<span id="L360" class="LineNr">360 </span>    print <a href='081print.mu.html#L16'>screen</a>, <span class="Constant">[expected character not found]</span>
<span id="L361" class="LineNr">361 </span>  <span class="Delimiter">}</span>
<span id="L362" class="LineNr">362 </span>  result <span class="Special">&lt;-</span> not match?
<span id="L363" class="LineNr">363 </span>]
<span id="L364" class="LineNr">364 </span>
<span id="L365" class="LineNr">365 </span><span class="muScenario">scenario</span> read-move-blocking [
<span id="L366" class="LineNr">366 </span>  <span class="Constant">local-scope</span>
<span id="L367" class="LineNr">367 </span>  assume-screen <span class="Constant">20/width</span>, <span class="Constant">2/height</span>
<span id="L368" class="LineNr">368 </span>  <a href='075channel.mu.html#L36'>source</a>:&amp;:<a href='075channel.mu.html#L36'>source</a>:char, <a href='075channel.mu.html#L40'>sink</a>:&amp;:<a href='075channel.mu.html#L40'>sink</a>:char <span class="Special">&lt;-</span> <a href='075channel.mu.html#L44'>new-channel</a> <span class="Constant">2/capacity</span>
<span id="L369" class="LineNr">369 </span>  read-move-routine:num/routine <span class="Special">&lt;-</span> <span class="muControl">start-running</span> <a href='chessboard.mu.html#L248'>read-move</a>, <a href='075channel.mu.html#L36'>source</a>, <a href='081print.mu.html#L16'>screen</a>
<span id="L370" class="LineNr">370 </span>  run [
<span id="L371" class="LineNr">371 </span>    <span class="Comment"># 'read-move' is waiting for keypress</span>
<span id="L372" class="LineNr">372 </span>    wait-for-routine-to-block read-move-routine
<span id="L373" class="LineNr">373 </span>    read-move-state:num <span class="Special">&lt;-</span> routine-state read-move-routine
<span id="L374" class="LineNr">374 </span>    waiting?:bool <span class="Special">&lt;-</span> not-equal read-move-state, <span class="Constant">2/discontinued</span>
<span id="L375" class="LineNr">375 </span>    assert waiting?, <span class="Constant">[ </span>
<span id="L376" class="LineNr">376 </span><span class="Constant">F read-move-blocking: routine failed to pause after coming up (before any keys were pressed)]</span>
<span id="L377" class="LineNr">377 </span>    <span class="Comment"># press 'a'</span>
<span id="L378" class="LineNr">378 </span>    <a href='075channel.mu.html#L40'>sink</a> <span class="Special">&lt;-</span> <a href='075channel.mu.html#L60'>write</a> <a href='075channel.mu.html#L40'>sink</a>, <span class="Constant">97/a</span>
<span id="L379" class="LineNr">379 </span>    restart read-move-routine
<span id="L380" class="LineNr">380 </span>    <span class="Comment"># 'read-move' still waiting for keypress</span>
<span id="L381" class="LineNr">381 </span>    wait-for-routine-to-block read-move-routine
<span id="L382" class="LineNr">382 </span>    read-move-state <span class="Special">&lt;-</span> routine-state read-move-routine
<span id="L383" class="LineNr">383 </span>    waiting? <span class="Special">&lt;-</span> not-equal read-move-state, <span class="Constant">2/discontinued</span>
<span id="L384" class="LineNr">384 </span>    assert waiting?, <span class="Constant">[ </span>
<span id="L385" class="LineNr">385 </span><span class="Constant">F read-move-blocking: routine failed to pause after rank 'a']</span>
<span id="L386" class="LineNr">386 </span>    <span class="Comment"># press '2'</span>
<span id="L387" class="LineNr">387 </span>    <a href='075channel.mu.html#L40'>sink</a> <span class="Special">&lt;-</span> <a href='075channel.mu.html#L60'>write</a> <a href='075channel.mu.html#L40'>sink</a>, <span class="Constant">50/'2'</span>
<span id="L388" class="LineNr">388 </span>    restart read-move-routine
<span id="L389" class="LineNr">389 </span>    <span class="Comment"># 'read-move' still waiting for keypress</span>
<span id="L390" class="LineNr">390 </span>    wait-for-routine-to-block read-move-routine
<span id="L391" class="LineNr">391 </span>    read-move-state <span class="Special">&lt;-</span> routine-state read-move-routine
<span id="L392" class="LineNr">392 </span>    waiting? <span class="Special">&lt;-</span> not-equal read-move-state, <span class="Constant">2/discontinued</span>
<span id="L393" class="LineNr">393 </span>    assert waiting?, <span class="Constant">[ </span>
<span id="L394" class="LineNr">394 </span><span class="Constant">F read-move-blocking: routine failed to pause after file 'a2']</span>
<span id="L395" class="LineNr">395 </span>    <span class="Comment"># press '-'</span>
<span id="L396" class="LineNr">396 </span>    <a href='075channel.mu.html#L40'>sink</a> <span class="Special">&lt;-</span> <a href='075channel.mu.html#L60'>write</a> <a href='075channel.mu.html#L40'>sink</a>, <span class="Constant">45/'-'</span>
<span id="L397" class="LineNr">397 </span>    restart read-move-routine
<span id="L398" class="LineNr">398 </span>    <span class="Comment"># 'read-move' still waiting for keypress</span>
<span id="L399" class="LineNr">399 </span>    wait-for-routine-to-block read-move-routine
<span id="L400" class="LineNr">400 </span>    read-move-state <span class="Special">&lt;-</span> routine-state read-move-routine
<span id="L401" class="LineNr">401 </span>    waiting? <span class="Special">&lt;-</span> not-equal read-move-state, <span class="Constant">2/discontinued</span>
<span id="L402" class="LineNr">402 </span>    assert waiting?, <span class="Constant">[ </span>
<span id="L403" class="LineNr">403 </span><span class="Constant">F read-move-blocking: routine failed to pause after hyphen 'a2-']</span>
<span id="L404" class="LineNr">404 </span>    <span class="Comment"># press 'a'</span>
<span id="L405" class="LineNr">405 </span>    <a href='075channel.mu.html#L40'>sink</a> <span class="Special">&lt;-</span> <a href='075channel.mu.html#L60'>write</a> <a href='075channel.mu.html#L40'>sink</a>, <span class="Constant">97/a</span>
<span id="L406" class="LineNr">406 </span>    restart read-move-routine
<span id="L407" class="LineNr">407 </span>    <span class="Comment"># 'read-move' still waiting for keypress</span>
<span id="L408" class="LineNr">408 </span>    wait-for-routine-to-block read-move-routine
<span id="L409" class="LineNr">409 </span>    read-move-state <span class="Special">&lt;-</span> routine-state read-move-routine
<span id="L410" class="LineNr">410 </span>    waiting? <span class="Special">&lt;-</span> not-equal read-move-state, <span class="Constant">2/discontinued</span>
<span id="L411" class="LineNr">411 </span>    assert waiting?, <span class="Constant">[ </span>
<span id="L412" class="LineNr">412 </span><span class="Constant">F read-move-blocking: routine failed to pause after rank 'a2-a']</span>
<span id="L413" class="LineNr">413 </span>    <span class="Comment"># press '4'</span>
<span id="L414" class="LineNr">414 </span>    <a href='075channel.mu.html#L40'>sink</a> <span class="Special">&lt;-</span> <a href='075channel.mu.html#L60'>write</a> <a href='075channel.mu.html#L40'>sink</a>, <span class="Constant">52/'4'</span>
<span id="L415" class="LineNr">415 </span>    restart read-move-routine
<span id="L416" class="LineNr">416 </span>    <span class="Comment"># 'read-move' still waiting for keypress</span>
<span id="L417" class="LineNr">417 </span>    wait-for-routine-to-block read-move-routine
<span id="L418" class="LineNr">418 </span>    read-move-state <span class="Special">&lt;-</span> routine-state read-move-routine
<span id="L419" class="LineNr">419 </span>    waiting? <span class="Special">&lt;-</span> not-equal read-move-state, <span class="Constant">2/discontinued</span>
<span id="L420" class="LineNr">420 </span>    assert waiting?, <span class="Constant">[ </span>
<span id="L421" class="LineNr">421 </span><span class="Constant">F read-move-blocking: routine failed to pause after file 'a2-a4']</span>
<span id="L422" class="LineNr">422 </span>    <span class="Comment"># press 'newline'</span>
<span id="L423" class="LineNr">423 </span>    <a href='075channel.mu.html#L40'>sink</a> <span class="Special">&lt;-</span> <a href='075channel.mu.html#L60'>write</a> <a href='075channel.mu.html#L40'>sink</a>,<span class="Constant"> 10</span>  <span class="Comment"># newline</span>
<span id="L424" class="LineNr">424 </span>    restart read-move-routine
<span id="L425" class="LineNr">425 </span>    <span class="Comment"># 'read-move' now completes</span>
<span id="L426" class="LineNr">426 </span>    wait-for-routine-to-block read-move-routine
<span id="L427" class="LineNr">427 </span>    read-move-state <span class="Special">&lt;-</span> routine-state read-move-routine
<span id="L428" class="LineNr">428 </span>    completed?:bool <span class="Special">&lt;-</span> equal read-move-state, <span class="Constant">1/completed</span>
<span id="L429" class="LineNr">429 </span>    assert completed?, <span class="Constant">[ </span>
<span id="L430" class="LineNr">430 </span><span class="Constant">F read-move-blocking: routine failed to terminate on newline]</span>
<span id="L431" class="LineNr">431 </span>    trace<span class="Constant"> 1</span>, <span class="Constant">[test]</span>, <span class="Constant">[reached end]</span>
<span id="L432" class="LineNr">432 </span>  ]
<span id="L433" class="LineNr">433 </span>  trace-should-contain [
<span id="L434" class="LineNr">434 </span>    test: reached end
<span id="L435" class="LineNr">435 </span>  ]
<span id="L436" class="LineNr">436 </span>]
<span id="L437" class="LineNr">437 </span>
<span id="L438" class="LineNr">438 </span><span class="muScenario">scenario</span> read-move-quit [
<span id="L439" class="LineNr">439 </span>  <span class="Constant">local-scope</span>
<span id="L440" class="LineNr">440 </span>  assume-screen <span class="Constant">20/width</span>, <span class="Constant">2/height</span>
<span id="L441" class="LineNr">441 </span>  <a href='075channel.mu.html#L36'>source</a>:&amp;:<a href='075channel.mu.html#L36'>source</a>:char, <a href='075channel.mu.html#L40'>sink</a>:&amp;:<a href='075channel.mu.html#L40'>sink</a>:char <span class="Special">&lt;-</span> <a href='075channel.mu.html#L44'>new-channel</a> <span class="Constant">2/capacity</span>
<span id="L442" class="LineNr">442 </span>  read-move-routine:num <span class="Special">&lt;-</span> <span class="muControl">start-running</span> <a href='chessboard.mu.html#L248'>read-move</a>, <a href='075channel.mu.html#L36'>source</a>, <a href='081print.mu.html#L16'>screen</a>
<span id="L443" class="LineNr">443 </span>  run [
<span id="L444" class="LineNr">444 </span>    <span class="Comment"># 'read-move' is waiting for keypress</span>
<span id="L445" class="LineNr">445 </span>    wait-for-routine-to-block read-move-routine
<span id="L446" class="LineNr">446 </span>    read-move-state:num <span class="Special">&lt;-</span> routine-state read-move-routine
<span id="L447" class="LineNr">447 </span>    waiting?:bool <span class="Special">&lt;-</span> not-equal read-move-state, <span class="Constant">2/discontinued</span>
<span id="L448" class="LineNr">448 </span>    assert waiting?, <span class="Constant">[ </span>
<span id="L449" class="LineNr">449 </span><span class="Constant">F read-move-quit: routine failed to pause after coming up (before any keys were pressed)]</span>
<span id="L450" class="LineNr">450 </span>    <span class="Comment"># press 'q'</span>
<span id="L451" class="LineNr">451 </span>    <a href='075channel.mu.html#L40'>sink</a> <span class="Special">&lt;-</span> <a href='075channel.mu.html#L60'>write</a> <a href='075channel.mu.html#L40'>sink</a>, <span class="Constant">113/q</span>
<span id="L452" class="LineNr">452 </span>    restart read-move-routine
<span id="L453" class="LineNr">453 </span>    <span class="Comment"># 'read-move' completes</span>
<span id="L454" class="LineNr">454 </span>    wait-for-routine-to-block read-move-routine
<span id="L455" class="LineNr">455 </span>    read-move-state <span class="Special">&lt;-</span> routine-state read-move-routine
<span id="L456" class="LineNr">456 </span>    completed?:bool <span class="Special">&lt;-</span> equal read-move-state, <span class="Constant">1/completed</span>
<span id="L457" class="LineNr">457 </span>    assert completed?, <span class="Constant">[ </span>
<span id="L458" class="LineNr">458 </span><span class="Constant">F read-move-quit: routine failed to terminate on 'q']</span>
<span id="L459" class="LineNr">459 </span>    trace<span class="Constant"> 1</span>, <span class="Constant">[test]</span>, <span class="Constant">[reached end]</span>
<span id="L460" class="LineNr">460 </span>  ]
<span id="L461" class="LineNr">461 </span>  trace-should-contain [
<span id="L462" class="LineNr">462 </span>    test: reached end
<span id="L463" class="LineNr">463 </span>  ]
<span id="L464" class="LineNr">464 </span>]
<span id="L465" class="LineNr">465 </span>
<span id="L466" class="LineNr">466 </span><span class="muScenario">scenario</span> read-move-illegal-file [
<span id="L467" class="LineNr">467 </span>  <span class="Constant">local-scope</span>
<span id="L468" class="LineNr">468 </span>  assume-screen <span class="Constant">20/width</span>, <span class="Constant">2/height</span>
<span id="L469" class="LineNr">469 </span>  <a href='075channel.mu.html#L36'>source</a>:&amp;:<a href='075channel.mu.html#L36'>source</a>:char, <a href='075channel.mu.html#L40'>sink</a>:&amp;:<a href='075channel.mu.html#L40'>sink</a>:char <span class="Special">&lt;-</span> <a href='075channel.mu.html#L44'>new-channel</a> <span class="Constant">2/capacity</span>
<span id="L470" class="LineNr">470 </span>  read-move-routine:num <span class="Special">&lt;-</span> <span class="muControl">start-running</span> <a href='chessboard.mu.html#L248'>read-move</a>, <a href='075channel.mu.html#L36'>source</a>, <a href='081print.mu.html#L16'>screen</a>
<span id="L471" class="LineNr">471 </span>  run [
<span id="L472" class="LineNr">472 </span>    <span class="Comment"># 'read-move' is waiting for keypress</span>
<span id="L473" class="LineNr">473 </span>    wait-for-routine-to-block read-move-routine
<span id="L474" class="LineNr">474 </span>    read-move-state:num <span class="Special">&lt;-</span> routine-state read-move-routine
<span id="L475" class="LineNr">475 </span>    waiting?:bool <span class="Special">&lt;-</span> not-equal read-move-state, <span class="Constant">2/discontinued</span>
<span id="L476" class="LineNr">476 </span>    assert waiting?, <span class="Constant">[ </span>
<span id="L477" class="LineNr">477 </span><span class="Constant">F read-move-illegal-file: routine failed to pause after coming up (before any keys were pressed)]</span>
<span id="L478" class="LineNr">478 </span>    <a href='075channel.mu.html#L40'>sink</a> <span class="Special">&lt;-</span> <a href='075channel.mu.html#L60'>write</a> <a href='075channel.mu.html#L40'>sink</a>, <span class="Constant">50/'2'</span>
<span id="L479" class="LineNr">479 </span>    restart read-move-routine
<span id="L480" class="LineNr">480 </span>    wait-for-routine-to-block read-move-routine
<span id="L481" class="LineNr">481 </span>  ]
<span id="L482" class="LineNr">482 </span>  screen-should-contain [
<span id="L483" class="LineNr">483 </span>   <span class="Constant"> .file too low: 2     .</span>
<span id="L484" class="LineNr">484 </span>   <span class="Constant"> .                    .</span>
<span id="L485" class="LineNr">485 </span>  ]
<span id="L486" class="LineNr">486 </span>]
<span id="L487" class="LineNr">487 </span>
<span id="L488" class="LineNr">488 </span><span class="muScenario">scenario</span> read-move-illegal-rank [
<span id="L489" class="LineNr">489 </span>  <span class="Constant">local-scope</span>
<span id="L490" class="LineNr">490 </span>  assume-screen <span class="Constant">20/width</span>, <span class="Constant">2/height</span>
<span id="L491" class="LineNr">491 </span>  <a href='075channel.mu.html#L36'>source</a>:&amp;:<a href='075channel.mu.html#L36'>source</a>:char, <a href='075channel.mu.html#L40'>sink</a>:&amp;:<a href='075channel.mu.html#L40'>sink</a>:char <span class="Special">&lt;-</span> <a href='075channel.mu.html#L44'>new-channel</a> <span class="Constant">2/capacity</span>
<span id="L492" class="LineNr">492 </span>  read-move-routine:num <span class="Special">&lt;-</span> <span class="muControl">start-running</span> <a href='chessboard.mu.html#L248'>read-move</a>, <a href='075channel.mu.html#L36'>source</a>, <a href='081print.mu.html#L16'>screen</a>
<span id="L493" class="LineNr">493 </span>  run [
<span id="L494" class="LineNr">494 </span>    <span class="Comment"># 'read-move' is waiting for keypress</span>
<span id="L495" class="LineNr">495 </span>    wait-for-routine-to-block read-move-routine
<span id="L496" class="LineNr">496 </span>    read-move-state:num <span class="Special">&lt;-</span> routine-state read-move-routine
<span id="L497" class="LineNr">497 </span>    waiting?:bool <span class="Special">&lt;-</span> not-equal read-move-state, <span class="Constant">2/discontinued</span>
<span id="L498" class="LineNr">498 </span>    assert waiting?, <span class="Constant">[ </span>
<span id="L499" class="LineNr">499 </span><span class="Constant">F read-move-illegal-rank: routine failed to pause after coming up (before any keys were pressed)]</span>
<span id="L500" class="LineNr">500 </span>    <a href='075channel.mu.html#L40'>sink</a> <span class="Special">&lt;-</span> <a href='075channel.mu.html#L60'>write</a> <a href='075channel.mu.html#L40'>sink</a>, <span class="Constant">97/a</span>
<span id="L501" class="LineNr">501 </span>    <a href='075channel.mu.html#L40'>sink</a> <span class="Special">&lt;-</span> <a href='075channel.mu.html#L60'>write</a> <a href='075channel.mu.html#L40'>sink</a>, <span class="Constant">97/a</span>
<span id="L502" class="LineNr">502 </span>    restart read-move-routine
<span id="L503" class="LineNr">503 </span>    wait-for-routine-to-block read-move-routine
<span id="L504" class="LineNr">504 </span>  ]
<span id="L505" class="LineNr">505 </span>  screen-should-contain [
<span id="L506" class="LineNr">506 </span>   <span class="Constant"> .rank too high: a    .</span>
<span id="L507" class="LineNr">507 </span>   <span class="Constant"> .                    .</span>
<span id="L508" class="LineNr">508 </span>  ]
<span id="L509" class="LineNr">509 </span>]
<span id="L510" class="LineNr">510 </span>
<span id="L511" class="LineNr">511 </span><span class="muScenario">scenario</span> read-move-empty [
<span id="L512" class="LineNr">512 </span>  <span class="Constant">local-scope</span>
<span id="L513" class="LineNr">513 </span>  assume-screen <span class="Constant">20/width</span>, <span class="Constant">2/height</span>
<span id="L514" class="LineNr">514 </span>  <a href='075channel.mu.html#L36'>source</a>:&amp;:<a href='075channel.mu.html#L36'>source</a>:char, <a href='075channel.mu.html#L40'>sink</a>:&amp;:<a href='075channel.mu.html#L40'>sink</a>:char <span class="Special">&lt;-</span> <a href='075channel.mu.html#L44'>new-channel</a> <span class="Constant">2/capacity</span>
<span id="L515" class="LineNr">515 </span>  read-move-routine:num <span class="Special">&lt;-</span> <span class="muControl">start-running</span> <a href='chessboard.mu.html#L248'>read-move</a>, <a href='075channel.mu.html#L36'>source</a>, <a href='081print.mu.html#L16'>screen</a>
<span id="L516" class="LineNr">516 </span>  run [
<span id="L517" class="LineNr">517 </span>    <span class="Comment"># 'read-move' is waiting for keypress</span>
<span id="L518" class="LineNr">518 </span>    wait-for-routine-to-block read-move-routine
<span id="L519" class="LineNr">519 </span>    read-move-state:num <span class="Special">&lt;-</span> routine-state read-move-routine
<span id="L520" class="LineNr">520 </span>    waiting?:bool <span class="Special">&lt;-</span> not-equal read-move-state, <span class="Constant">2/discontinued</span>
<span id="L521" class="LineNr">521 </span>    assert waiting?, <span class="Constant">[ </span>
<span id="L522" class="LineNr">522 </span><span class="Constant">F read-move-empty: routine failed to pause after coming up (before any keys were pressed)]</span>
<span id="L523" class="LineNr">523 </span>    <a href='075channel.mu.html#L40'>sink</a> <span class="Special">&lt;-</span> <a href='075channel.mu.html#L60'>write</a> <a href='075channel.mu.html#L40'>sink</a>, <span class="Constant">10/newline</span>
<span id="L524" class="LineNr">524 </span>    <a href='075channel.mu.html#L40'>sink</a> <span class="Special">&lt;-</span> <a href='075channel.mu.html#L60'>write</a> <a href='075channel.mu.html#L40'>sink</a>, <span class="Constant">97/a</span>
<span id="L525" class="LineNr">525 </span>    restart read-move-routine
<span id="L526" class="LineNr">526 </span>    wait-for-routine-to-block read-move-routine
<span id="L527" class="LineNr">527 </span>  ]
<span id="L528" class="LineNr">528 </span>  screen-should-contain [
<span id="L529" class="LineNr">529 </span>   <span class="Constant"> .that's not enough   .</span>
<span id="L530" class="LineNr">530 </span>   <span class="Constant"> .                    .</span>
<span id="L531" class="LineNr">531 </span>  ]
<span id="L532" class="LineNr">532 </span>]
<span id="L533" class="LineNr">533 </span>
<span id="L534" class="LineNr">534 </span><span class="muRecipe">def</span> <a href='chessboard.mu.html#L534'>make-move</a> <a href='chessboard.mu.html#L67'>board</a>:<a href='chessboard.mu.html#L67'>board</a>, m:&amp;:<a href='chessboard.mu.html#L239'>move</a><span class="muRecipe"> -&gt; </span><a href='chessboard.mu.html#L67'>board</a>:<a href='chessboard.mu.html#L67'>board</a> [
<span id="L535" class="LineNr">535 </span>  <span class="Constant">local-scope</span>
<span id="L536" class="LineNr">536 </span>  <span class="Constant">load-inputs</span>
<span id="L537" class="LineNr">537 </span>  from-file:num <span class="Special">&lt;-</span> get *m, <span class="Constant">from-file:offset</span>
<span id="L538" class="LineNr">538 </span>  from-rank:num <span class="Special">&lt;-</span> get *m, <span class="Constant">from-rank:offset</span>
<span id="L539" class="LineNr">539 </span>  to-file:num <span class="Special">&lt;-</span> get *m, <span class="Constant">to-file:offset</span>
<span id="L540" class="LineNr">540 </span>  to-rank:num <span class="Special">&lt;-</span> get *m, <span class="Constant">to-rank:offset</span>
<span id="L541" class="LineNr">541 </span>  from-f:&amp;:@:char <span class="Special">&lt;-</span> index *board, from-file
<span id="L542" class="LineNr">542 </span>  to-f:&amp;:@:char <span class="Special">&lt;-</span> index *board, to-file
<span id="L543" class="LineNr">543 </span>  src:char/square <span class="Special">&lt;-</span> index *from-f, from-rank
<span id="L544" class="LineNr">544 </span>  *to-f <span class="Special">&lt;-</span> put-index *to-f, to-rank, src
<span id="L545" class="LineNr">545 </span>  *from-f <span class="Special">&lt;-</span> put-index *from-f, from-rank, <span class="Constant">32/space</span>
<span id="L546" class="LineNr">546 </span>]
<span id="L547" class="LineNr">547 </span>
<span id="L548" class="LineNr">548 </span><span class="muScenario">scenario</span> making-a-move [
<span id="L549" class="LineNr">549 </span>  <span class="Constant">local-scope</span>
<span id="L550" class="LineNr">550 </span>  assume-screen <span class="Constant">30/width</span>, <span class="Constant">12/height</span>
<span id="L551" class="LineNr">551 </span>  <a href='chessboard.mu.html#L67'>board</a>:<a href='chessboard.mu.html#L67'>board</a> <span class="Special">&lt;-</span> <a href='chessboard.mu.html#L190'>initial-position</a>
<span id="L552" class="LineNr">552 </span>  <a href='chessboard.mu.html#L239'>move</a>:&amp;:<a href='chessboard.mu.html#L239'>move</a> <span class="Special">&lt;-</span> new <span class="Constant"><a href='chessboard.mu.html#L239'>move</a>:type</span>
<span id="L553" class="LineNr">553 </span>  *move <span class="Special">&lt;-</span> merge <span class="Constant">6/g</span>, <span class="Constant">1/'2'</span>, <span class="Constant">6/g</span>, <span class="Constant">3/'4'</span>
<span id="L554" class="LineNr">554 </span>  run [
<span id="L555" class="LineNr">555 </span>    <a href='chessboard.mu.html#L67'>board</a> <span class="Special">&lt;-</span> <a href='chessboard.mu.html#L534'>make-move</a> <a href='chessboard.mu.html#L67'>board</a>, <a href='chessboard.mu.html#L239'>move</a>
<span id="L556" class="LineNr">556 </span>    <a href='081print.mu.html#L16'>screen</a> <span class="Special">&lt;-</span> print <a href='081print.mu.html#L16'>screen</a>, <a href='chessboard.mu.html#L67'>board</a>
<span id="L557" class="LineNr">557 </span>  ]
<span id="L558" class="LineNr">558 </span>  screen-should-contain [
<span id="L559" class="LineNr">559 </span>  <span class="Comment">#  012345678901234567890123456789</span>
<span id="L560" class="LineNr">560 </span>   <span class="Constant"> .8 | r n b q k b n r           .</span>
<span id="L561" class="LineNr">561 </span>   <span class="Constant"> .7 | p p p p p p p p           .</span>
<span id="L562" class="LineNr">562 </span>   <span class="Constant"> .6 |                           .</span>
<span id="L563" class="LineNr">563 </span>   <span class="Constant"> .5 |                           .</span>
<span id="L564" class="LineNr">564 </span>   <span class="Constant"> .4 |             P             .</span>
<span id="L565" class="LineNr">565 </span>   <span class="Constant"> .3 |                           .</span>
<span id="L566" class="LineNr">566 </span>   <span class="Constant"> .2 | P P P P P P   P           .</span>
<span id="L567" class="LineNr">567 </span>   <span class="Constant"> .1 | R N B Q K B N R           .</span>
<span id="L568" class="LineNr">568 </span>   <span class="Constant"> .  +----------------           .</span>
<span id="L569" class="LineNr">569 </span>   <span class="Constant"> .    a b c d e f g h           .</span>
<span id="L570" class="LineNr">570 </span>   <span class="Constant"> .                              .</span>
<span id="L571" class="LineNr">571 </span>  ]
<span id="L572" class="LineNr">572 </span>]
</pre>
</body>
</html>
<!-- vim: set foldmethod=manual : -->