about summary refs log tree commit diff stats
path: root/test/tc_commandlist.py
diff options
context:
space:
mode:
pre { line-height: 125%; } td.linenos .normal { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; } span.linenos { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; } td.linenos .special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; } span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; } .highlight .hll { background-color: #ffffcc } .highlight .c { color: #888888 } /* Comment */ .highlight .err { color: #a61717; background-color: #e3d2d2 } /* Error */ .highlight .k { color: #008800; font-weight: bold } /* Keyword */ .highlight .ch { color: #888888 } /* Comment.Hashbang */ .highlight .cm { color: #888888 } /* Comment.Multiline */ .highlight .cp { color: #cc0000; font-weight: bold } /* Comment.Preproc */ .highlight .cpf { color: #888888 } /* Comment.PreprocFile */ .highlight .c1 { color: #888888 } /* Comment.Single */ .highlight .cs { color: #cc0000; font-weight: bold; background-color: #fff0f0 } /* Comment.Special */ .highlight .gd { color: #000000; background-color: #ffdddd } /* Generic.Deleted */ .highlight .ge { font-style: italic } /* Generic.Emph */ .highlight .ges { font-weight: bold; font-style: italic } /* Generic.EmphStrong */ .highlight .gr { color: #aa0000 } /* Generic.Error */ .highlight .gh { color: #333333 } /* Generic.Heading */ .highlight .gi { color: #000000; background-color: #ddffdd } /* Generic.Inserted */ .highlight .go { color: #888888 } /* Generic.Output */ .highlight .gp { color: #555555 } /* Generic.Prompt */ .highlight .gs { font-weight: bold } /* Generic.Strong */ .highlight .gu { color: #666666 } /* Generic.Subheading */ .highlight .gt { color: #aa0000 } /* Generic.Traceback */ .highlight .kc { color: #008800; font-weight: bold } /* Keyword.Constant */ .highlight .kd { color: #008800; font-weight: bold } /* Keyword.Declaration */ .highlight .kn { color: #008800; font-weight: bold } /* Keyword.Namespace */ .highlight .kp { color: #008800 } /* Keyword.Pseudo */ .highlight .kr { color: #008800; font-weight: bold } /* Keyword.Reserved */ .highlight .kt { color: #888888; font-weight: bold } /* Keyword.Type */ .highlight .m { color: #0000DD; font-weight: bold } /* Literal.Number */ .highlight .s { color: #dd2200; background-color: #fff0f0 } /* Literal.String */ .highlight .na { color: #336699 } /* Name.Attribute */ .highlight .nb { color: #003388 } /* Name.Builtin */ .highlight .nc { color: #bb0066; font-weight: bold } /* Name.Class */ .highlight .no { color: #003366; font-weight: bold } /* Name.Constant */ .highlight .nd { color: #555555 } /* Name.Decorator */ .highlight .ne { color: #bb0066; font-weight: bold } /* Name.Exception */ .highlight .nf { color: #0066bb; font-weight: bold } /* Name.Function */ .highlight .nl { color: #336699; font-style: italic } /* Name.Label */ .highlight .nn { color: #bb0066; font-weight: bold } /* Name.Namespace */ .highlight .py { color: #336699; font-weight: bold } /* Name.Property */ .highlight .nt { color: #bb0066; font-weight: bold } /* Name.Tag */ .highlight .nv { color: #336699 } /* Name.Variable */ .highlight .ow { color: #008800 } /* Operator.Word */ .highlight .w { color: #bbbbbb } /* Text.Whitespace */ .highlight .mb { color: #0000DD; font-weight: bold } /* Literal.Number.Bin */ .highlight .mf { color: #0000DD; font-weight: bold } /* Literal.Number.Float */ .highlight .mh { color: #0000DD; font-weight: bold } /* Literal.Number.Hex */ .highlight .mi { color: #0000DD; font-weight: bold } /* Literal.Number.Integer */ .highlight .mo { color: #0000DD; font-weight: bold } /* Literal.Number.Oct */ .highlight .sa { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Affix */ .highlight .sb { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Backtick */ .highlight .sc { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Char */ .highlight .dl { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Delimiter */ .highlight .sd { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Doc */ .highlight .s2 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Double */ .highlight .se { color: #0044dd; background-color: #fff0f0 } /* Literal.String.Escape */ .highlight .sh { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Heredoc */ .highlight .si { color: #3333bb; background-color: #fff0f0 } /* Literal.String.Interpol */ .highlight .sx { color: #22bb22; background-color: #f0fff0 } /* Literal.String.Other */ .highlight .sr { color: #008800; background-color: #fff0ff } /* Literal.String.Regex */ .highlight .s1 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Single */ .highlight .ss { color: #aa6600; background-color: #fff0f0 } /* Literal.String.Symbol */ .highlight .bp { color: #003388 } /* Name.Builtin.Pseudo */ .highlight .fm { color: #0066bb; font-weight: bold } /* Name.Function.Magic */ .highlight .vc { color: #336699 } /* Name.Variable.Class */ .highlight .vg { color: #dd7700 } /* Name.Variable.Global */ .highlight .vi { color: #3333bb } /* Name.Variable.Instance */ .highlight .vm { color: #336699 } /* Name.Variable.Magic */ .highlight .il { color: #0000DD; font-weight: bold } /* Literal.Number.Integer.Long */
void create_jid_from_null_returns_null(void **state);
void create_jid_from_empty_string_returns_null(void **state);
void create_jid_from_full_returns_full(void **state);
void create_jid_from_full_returns_bare(void **state);
void create_jid_from_full_returns_resourcepart(void **state);
void create_jid_from_full_returns_localpart(void **state);
void create_jid_from_full_returns_domainpart(void **state);
void create_jid_from_full_nolocal_returns_full(void **state);
void create_jid_from_full_nolocal_returns_bare(void **state);
void create_jid_from_full_nolocal_returns_resourcepart(void **state);
void create_jid_from_full_nolocal_returns_domainpart(void **state);
void create_jid_from_full_nolocal_returns_null_localpart(void **state);
void create_jid_from_bare_returns_null_full(void **state);
void create_jid_from_bare_returns_null_resource(void **state);
void create_jid_from_bare_returns_bare(void **state);
void create_jid_from_bare_returns_localpart(void **state);
void create_jid_from_bare_returns_domainpart(void **state);
void create_room_jid_returns_room(void **state);
void create_room_jid_returns_nick(void **state);
void create_with_slash_in_resource(void **state);
void create_with_at_in_resource(void **state);
void create_with_at_and_slash_in_resource(void **state);
void create_full_with_trailing_slash(void **state);
void returns_fulljid_when_exists(void **state);
void returns_barejid_when_fulljid_not_exists(void **state);
> 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 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/7.4">
<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; }
.muRecipe { color: #ff8700; }
.muScenario { color: #00af00; }
.Special { color: #c00000; }
.Delimiter { color: #800080; }
.SalientComment { color: #00ffff; }
.Comment { color: #9090ff; }
.Comment a { color:#0000ee; text-decoration:underline; }
.Constant { color: #00a0a0; }
.LineNr { color: #444444; }
.CommentedCode { color: #6c6c6c; }
.muControl { color: #c0a020; }
.muData { color: #ffff00; }
-->
</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">0/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 0, 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">0/screen</span>, <span class="Constant">0/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">0/dummy</span>
<span id="L253" class="LineNr">253 </span>  <span class="muControl">return-if</span> error?, <span class="Constant">0/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">0/dummy</span>
<span id="L259" class="LineNr">259 </span>  <span class="muControl">return-if</span> error?, <span class="Constant">0/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">0/dummy</span>, <span class="Constant">0/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">0/dummy</span>
<span id="L265" class="LineNr">265 </span>  <span class="muControl">return-if</span> error?, <span class="Constant">0/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">0/dummy</span>
<span id="L269" class="LineNr">269 </span>  <span class="muControl">return-if</span> error?, <span class="Constant">0/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">0/dummy</span>, <span class="Constant">0/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">1/quit</span>, <span class="Constant">0/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">1/quit</span>, <span class="Constant">0/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">1/quit</span>, <span class="Constant">0/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">1/quit</span>, <span class="Constant">0/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">0/quit</span>, <span class="Constant">1/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">0/quit</span>, <span class="Constant">1/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">0/quit</span>, <span class="Constant">1/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">0/quit</span>, <span class="Constant">0/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">1/quit</span>, <span class="Constant">0/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">1/quit</span>, <span class="Constant">0/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">1/quit</span>, <span class="Constant">0/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">1/quit</span>, <span class="Constant">0/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">0/quit</span>, <span class="Constant">1/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">0/quit</span>, <span class="Constant">1/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">0/quit</span>, <span class="Constant">1/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">0/quit</span>, <span class="Constant">0/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">1/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 : -->