From 2c56af2d8f791902f5ff59754c0277eddeb27a3e Mon Sep 17 00:00:00 2001 From: Kartik Agaram Date: Wed, 11 Nov 2020 23:43:04 -0800 Subject: 7227 --- html/405screen.mu.html | 2227 ++++++++++++++++++++++++------------------------ 1 file changed, 1113 insertions(+), 1114 deletions(-) (limited to 'html/405screen.mu.html') diff --git a/html/405screen.mu.html b/html/405screen.mu.html index c0c6e8ac..21f91871 100644 --- a/html/405screen.mu.html +++ b/html/405screen.mu.html @@ -261,7 +261,7 @@ if ('onhashchange' in window) { 201 print-string screen, " " 202 } 203 var x/ecx: (addr int) <- index a, i - 204 print-int32-decimal screen, *x + 204 print-int32-decimal screen, *x 205 i <- increment 206 loop 207 } @@ -376,1119 +376,1118 @@ if ('onhashchange' in window) { 316 var offset/ecx: (offset screen-cell) <- compute-offset data, idx 317 var cell/eax: (addr screen-cell) <- index data, offset 318 var src/eax: (addr grapheme) <- get cell, data - 319 var result/eax: grapheme <- copy *src - 320 return result - 321 } - 322 - 323 fn screen-color-at screen-on-stack: (addr screen), row: int, col: int -> _/eax: int { - 324 var screen-addr/esi: (addr screen) <- copy screen-on-stack - 325 var idx/ecx: int <- screen-cell-index screen-addr, row, col - 326 var result/eax: int <- screen-color-at-idx screen-addr, idx - 327 return result - 328 } - 329 - 330 fn screen-color-at-idx screen-on-stack: (addr screen), idx-on-stack: int -> _/eax: int { - 331 var screen-addr/esi: (addr screen) <- copy screen-on-stack - 332 var data-ah/eax: (addr handle array screen-cell) <- get screen-addr, data - 333 var data/eax: (addr array screen-cell) <- lookup *data-ah - 334 var idx/ecx: int <- copy idx-on-stack - 335 var offset/ecx: (offset screen-cell) <- compute-offset data, idx - 336 var cell/eax: (addr screen-cell) <- index data, offset - 337 var src/eax: (addr int) <- get cell, color - 338 var result/eax: int <- copy *src - 339 return result - 340 } - 341 - 342 fn screen-background-color-at screen-on-stack: (addr screen), row: int, col: int -> _/eax: int { - 343 var screen-addr/esi: (addr screen) <- copy screen-on-stack - 344 var idx/ecx: int <- screen-cell-index screen-addr, row, col - 345 var result/eax: int <- screen-background-color-at-idx screen-addr, idx - 346 return result - 347 } - 348 - 349 fn screen-background-color-at-idx screen-on-stack: (addr screen), idx-on-stack: int -> _/eax: int { - 350 var screen-addr/esi: (addr screen) <- copy screen-on-stack - 351 var data-ah/eax: (addr handle array screen-cell) <- get screen-addr, data - 352 var data/eax: (addr array screen-cell) <- lookup *data-ah - 353 var idx/ecx: int <- copy idx-on-stack - 354 var offset/ecx: (offset screen-cell) <- compute-offset data, idx - 355 var cell/eax: (addr screen-cell) <- index data, offset - 356 var src/eax: (addr int) <- get cell, background-color - 357 return *src - 358 } - 359 - 360 fn screen-bold-at? screen-on-stack: (addr screen), row: int, col: int -> _/eax: boolean { - 361 var screen-addr/esi: (addr screen) <- copy screen-on-stack - 362 var idx/ecx: int <- screen-cell-index screen-addr, row, col - 363 var result/eax: boolean <- screen-bold-at-idx? screen-addr, idx - 364 return result - 365 } - 366 - 367 fn screen-bold-at-idx? screen-on-stack: (addr screen), idx-on-stack: int -> _/eax: boolean { - 368 var screen-addr/esi: (addr screen) <- copy screen-on-stack - 369 var data-ah/eax: (addr handle array screen-cell) <- get screen-addr, data - 370 var data/eax: (addr array screen-cell) <- lookup *data-ah - 371 var idx/ecx: int <- copy idx-on-stack - 372 var offset/ecx: (offset screen-cell) <- compute-offset data, idx - 373 var cell/eax: (addr screen-cell) <- index data, offset - 374 var src/eax: (addr boolean) <- get cell, bold? - 375 return *src - 376 } - 377 - 378 fn screen-underline-at? screen-on-stack: (addr screen), row: int, col: int -> _/eax: boolean { - 379 var screen-addr/esi: (addr screen) <- copy screen-on-stack - 380 var idx/ecx: int <- screen-cell-index screen-addr, row, col - 381 var result/eax: boolean <- screen-underline-at-idx? screen-addr, idx - 382 return result - 383 } - 384 - 385 fn screen-underline-at-idx? screen-on-stack: (addr screen), idx-on-stack: int -> _/eax: boolean { - 386 var screen-addr/esi: (addr screen) <- copy screen-on-stack - 387 var data-ah/eax: (addr handle array screen-cell) <- get screen-addr, data - 388 var data/eax: (addr array screen-cell) <- lookup *data-ah - 389 var idx/ecx: int <- copy idx-on-stack - 390 var offset/ecx: (offset screen-cell) <- compute-offset data, idx - 391 var cell/eax: (addr screen-cell) <- index data, offset - 392 var src/eax: (addr boolean) <- get cell, underline? - 393 return *src - 394 } - 395 - 396 fn screen-reverse-at? screen-on-stack: (addr screen), row: int, col: int -> _/eax: boolean { - 397 var screen-addr/esi: (addr screen) <- copy screen-on-stack - 398 var idx/ecx: int <- screen-cell-index screen-addr, row, col - 399 var result/eax: boolean <- screen-reverse-at-idx? screen-addr, idx - 400 return result - 401 } - 402 - 403 fn screen-reverse-at-idx? screen-on-stack: (addr screen), idx-on-stack: int -> _/eax: boolean { - 404 var screen-addr/esi: (addr screen) <- copy screen-on-stack - 405 var data-ah/eax: (addr handle array screen-cell) <- get screen-addr, data - 406 var data/eax: (addr array screen-cell) <- lookup *data-ah - 407 var idx/ecx: int <- copy idx-on-stack - 408 var offset/ecx: (offset screen-cell) <- compute-offset data, idx - 409 var cell/eax: (addr screen-cell) <- index data, offset - 410 var src/eax: (addr boolean) <- get cell, reverse? - 411 return *src - 412 } - 413 - 414 fn screen-blink-at? screen-on-stack: (addr screen), row: int, col: int -> _/eax: boolean { - 415 var screen-addr/esi: (addr screen) <- copy screen-on-stack - 416 var idx/ecx: int <- screen-cell-index screen-addr, row, col - 417 var result/eax: boolean <- screen-blink-at-idx? screen-addr, idx - 418 return result - 419 } - 420 - 421 fn screen-blink-at-idx? screen-on-stack: (addr screen), idx-on-stack: int -> _/eax: boolean { - 422 var screen-addr/esi: (addr screen) <- copy screen-on-stack - 423 var data-ah/eax: (addr handle array screen-cell) <- get screen-addr, data - 424 var data/eax: (addr array screen-cell) <- lookup *data-ah - 425 var idx/ecx: int <- copy idx-on-stack - 426 var offset/ecx: (offset screen-cell) <- compute-offset data, idx - 427 var cell/eax: (addr screen-cell) <- index data, offset - 428 var src/eax: (addr boolean) <- get cell, blink? - 429 return *src - 430 } - 431 - 432 fn print-code-point screen: (addr screen), c: code-point { - 433 var g/eax: grapheme <- to-grapheme c - 434 print-grapheme screen, g - 435 } - 436 - 437 fn print-int32-hex screen: (addr screen), n: int { - 438 compare screen, 0 - 439 { - 440 break-if-!= - 441 print-int32-hex-to-real-screen n - 442 return - 443 } - 444 # fake screen - 445 var s2: (stream byte 0x100) - 446 var s2-addr/esi: (addr stream byte) <- address s2 - 447 write-int32-hex s2-addr, n - 448 var screen-addr/edi: (addr screen) <- copy screen - 449 { - 450 var done?/eax: boolean <- stream-empty? s2-addr - 451 compare done?, 0 - 452 break-if-!= - 453 var g/eax: grapheme <- read-grapheme s2-addr - 454 print-grapheme screen, g - 455 loop - 456 } - 457 } - 458 - 459 fn print-int32-hex-bits screen: (addr screen), n: int, bits: int { - 460 compare screen, 0 - 461 { - 462 break-if-!= - 463 print-int32-hex-bits-to-real-screen n, bits - 464 return - 465 } - 466 # fake screen - 467 var s2: (stream byte 0x100) - 468 var s2-addr/esi: (addr stream byte) <- address s2 - 469 write-int32-hex-bits s2-addr, n, bits - 470 var screen-addr/edi: (addr screen) <- copy screen - 471 { - 472 var done?/eax: boolean <- stream-empty? s2-addr - 473 compare done?, 0 - 474 break-if-!= - 475 var g/eax: grapheme <- read-grapheme s2-addr - 476 print-grapheme screen, g - 477 loop - 478 } - 479 } - 480 - 481 fn print-int32-decimal screen: (addr screen), n: int { - 482 compare screen, 0 - 483 { - 484 break-if-!= - 485 print-int32-decimal-to-real-screen n - 486 return - 487 } - 488 # fake screen - 489 # TODO - 490 } - 491 - 492 fn reset-formatting screen: (addr screen) { - 493 compare screen, 0 - 494 { - 495 break-if-!= - 496 reset-formatting-on-real-screen - 497 return - 498 } - 499 # fake screen - 500 var screen-addr/esi: (addr screen) <- copy screen - 501 var dest/ecx: (addr screen-cell) <- get screen-addr, curr-attributes - 502 var default-cell: screen-cell - 503 var bg/eax: (addr int) <- get default-cell, background-color - 504 copy-to *bg, 7 - 505 var default-cell-addr/eax: (addr screen-cell) <- address default-cell - 506 copy-object default-cell-addr, dest - 507 } - 508 - 509 fn start-color screen: (addr screen), fg: int, bg: int { - 510 compare screen, 0 - 511 { - 512 break-if-!= - 513 start-color-on-real-screen fg, bg - 514 return - 515 } - 516 # fake screen - 517 var screen-addr/esi: (addr screen) <- copy screen - 518 var attr/ecx: (addr screen-cell) <- get screen-addr, curr-attributes - 519 var dest/edx: (addr int) <- get attr, color - 520 var src/eax: int <- copy fg - 521 copy-to *dest, src - 522 var dest/edx: (addr int) <- get attr, background-color - 523 var src/eax: int <- copy bg - 524 copy-to *dest, src - 525 } - 526 - 527 fn start-bold screen: (addr screen) { - 528 compare screen, 0 - 529 { - 530 break-if-!= - 531 start-bold-on-real-screen - 532 return - 533 } - 534 # fake screen - 535 var screen-addr/esi: (addr screen) <- copy screen - 536 var attr/ecx: (addr screen-cell) <- get screen-addr, curr-attributes - 537 var dest/edx: (addr boolean) <- get attr, bold? - 538 copy-to *dest, 1 - 539 } - 540 - 541 fn start-underline screen: (addr screen) { - 542 compare screen, 0 - 543 { - 544 break-if-!= - 545 start-underline-on-real-screen - 546 return - 547 } - 548 # fake screen - 549 var screen-addr/esi: (addr screen) <- copy screen - 550 var attr/ecx: (addr screen-cell) <- get screen-addr, curr-attributes - 551 var dest/edx: (addr boolean) <- get attr, underline? - 552 copy-to *dest, 1 - 553 } - 554 - 555 fn start-reverse-video screen: (addr screen) { - 556 compare screen, 0 - 557 { - 558 break-if-!= - 559 start-reverse-video-on-real-screen - 560 return - 561 } - 562 # fake screen - 563 var screen-addr/esi: (addr screen) <- copy screen - 564 var attr/ecx: (addr screen-cell) <- get screen-addr, curr-attributes - 565 var dest/edx: (addr boolean) <- get attr, reverse? - 566 copy-to *dest, 1 - 567 } - 568 - 569 fn start-blinking screen: (addr screen) { - 570 compare screen, 0 - 571 { - 572 break-if-!= - 573 start-blinking-on-real-screen - 574 return - 575 } - 576 # fake screen - 577 var screen-addr/esi: (addr screen) <- copy screen - 578 var attr/ecx: (addr screen-cell) <- get screen-addr, curr-attributes - 579 var dest/edx: (addr boolean) <- get attr, blink? - 580 copy-to *dest, 1 - 581 } - 582 - 583 fn hide-cursor screen: (addr screen) { - 584 compare screen, 0 - 585 { - 586 break-if-!= - 587 hide-cursor-on-real-screen - 588 return - 589 } - 590 # fake screen - 591 var screen-addr/esi: (addr screen) <- copy screen - 592 var hide?/ecx: (addr boolean) <- get screen-addr, cursor-hide? - 593 copy-to *hide?, 1 - 594 } - 595 - 596 fn show-cursor screen: (addr screen) { - 597 compare screen, 0 - 598 { - 599 break-if-!= - 600 show-cursor-on-real-screen - 601 return - 602 } - 603 # fake screen - 604 var screen-addr/esi: (addr screen) <- copy screen - 605 var hide?/ecx: (addr boolean) <- get screen-addr, cursor-hide? - 606 copy-to *hide?, 0 - 607 } - 608 - 609 # validate data on screen regardless of attributes (color, bold, etc.) - 610 # Mu doesn't have multi-line strings, so we provide functions for rows or portions of rows. - 611 # Tab characters (that translate into multiple screen cells) not supported. - 612 - 613 fn check-screen-row screen: (addr screen), row-idx: int, expected: (addr array byte), msg: (addr array byte) { - 614 check-screen-row-from screen, row-idx, 1, expected, msg - 615 } - 616 - 617 fn check-screen-row-from screen-on-stack: (addr screen), row-idx: int, col-idx: int, expected: (addr array byte), msg: (addr array byte) { - 618 var screen/esi: (addr screen) <- copy screen-on-stack - 619 var idx/ecx: int <- screen-cell-index screen, row-idx, col-idx - 620 # compare 'expected' with the screen contents starting at 'idx', grapheme by grapheme - 621 var e: (stream byte 0x100) - 622 var e-addr/edx: (addr stream byte) <- address e - 623 write e-addr, expected - 624 { - 625 var done?/eax: boolean <- stream-empty? e-addr - 626 compare done?, 0 - 627 break-if-!= - 628 var _g/eax: grapheme <- screen-grapheme-at-idx screen, idx - 629 var g/ebx: grapheme <- copy _g - 630 var expected-grapheme/eax: grapheme <- read-grapheme e-addr - 631 # compare graphemes - 632 $check-screen-row-from:compare-graphemes: { - 633 # if expected-grapheme is space, null grapheme is also ok - 634 { - 635 compare expected-grapheme, 0x20 - 636 break-if-!= - 637 compare g, 0 - 638 break-if-= $check-screen-row-from:compare-graphemes - 639 } - 640 # if (g == expected-grapheme) print "." - 641 compare g, expected-grapheme - 642 { - 643 break-if-!= - 644 print-string-to-real-screen "." - 645 break $check-screen-row-from:compare-graphemes - 646 } - 647 # otherwise print an error - 648 print-string-to-real-screen msg - 649 print-string-to-real-screen ": expected '" - 650 print-grapheme-to-real-screen expected-grapheme - 651 print-string-to-real-screen "' at (" - 652 print-int32-hex-to-real-screen row-idx - 653 print-string-to-real-screen ", " - 654 print-int32-hex-to-real-screen col-idx - 655 print-string-to-real-screen ") but observed '" - 656 print-grapheme-to-real-screen g - 657 print-string-to-real-screen "'\n" - 658 } - 659 idx <- increment - 660 increment col-idx - 661 loop - 662 } - 663 } - 664 - 665 # various variants by screen-cell attribute; spaces in the 'expected' data should not match the attribute - 666 - 667 fn check-screen-row-in-color screen: (addr screen), fg: int, row-idx: int, expected: (addr array byte), msg: (addr array byte) { - 668 check-screen-row-in-color-from screen, fg, row-idx, 1, expected, msg - 669 } - 670 - 671 fn check-screen-row-in-color-from screen-on-stack: (addr screen), fg: int, row-idx: int, col-idx: int, expected: (addr array byte), msg: (addr array byte) { - 672 var screen/esi: (addr screen) <- copy screen-on-stack - 673 var idx/ecx: int <- screen-cell-index screen, row-idx, col-idx - 674 # compare 'expected' with the screen contents starting at 'idx', grapheme by grapheme - 675 var e: (stream byte 0x100) - 676 var e-addr/edx: (addr stream byte) <- address e - 677 write e-addr, expected - 678 { - 679 var done?/eax: boolean <- stream-empty? e-addr - 680 compare done?, 0 - 681 break-if-!= - 682 var _g/eax: grapheme <- screen-grapheme-at-idx screen, idx - 683 var g/ebx: grapheme <- copy _g - 684 var _expected-grapheme/eax: grapheme <- read-grapheme e-addr - 685 var expected-grapheme/edi: grapheme <- copy _expected-grapheme - 686 $check-screen-row-in-color-from:compare-cells: { - 687 # if expected-grapheme is space, null grapheme is also ok - 688 { - 689 compare expected-grapheme, 0x20 - 690 break-if-!= - 691 compare g, 0 - 692 break-if-= $check-screen-row-in-color-from:compare-cells - 693 } - 694 # if expected-grapheme is space, a different color is ok - 695 { - 696 compare expected-grapheme, 0x20 - 697 break-if-!= - 698 var color/eax: int <- screen-color-at-idx screen, idx - 699 compare color, fg - 700 break-if-!= $check-screen-row-in-color-from:compare-cells - 701 } - 702 # compare graphemes - 703 $check-screen-row-in-color-from:compare-graphemes: { - 704 # if (g == expected-grapheme) print "." - 705 compare g, expected-grapheme - 706 { - 707 break-if-!= - 708 print-string-to-real-screen "." - 709 break $check-screen-row-in-color-from:compare-graphemes - 710 } - 711 # otherwise print an error - 712 print-string-to-real-screen msg - 713 print-string-to-real-screen ": expected '" - 714 print-grapheme-to-real-screen expected-grapheme - 715 print-string-to-real-screen "' at (" - 716 print-int32-hex-to-real-screen row-idx - 717 print-string-to-real-screen ", " - 718 print-int32-hex-to-real-screen col-idx - 719 print-string-to-real-screen ") but observed '" - 720 print-grapheme-to-real-screen g - 721 print-string-to-real-screen "'\n" - 722 } - 723 $check-screen-row-in-color-from:compare-colors: { - 724 var color/eax: int <- screen-color-at-idx screen, idx - 725 compare fg, color - 726 { - 727 break-if-!= - 728 print-string-to-real-screen "." - 729 break $check-screen-row-in-color-from:compare-colors - 730 } - 731 # otherwise print an error - 732 print-string-to-real-screen msg - 733 print-string-to-real-screen ": expected '" - 734 print-grapheme-to-real-screen expected-grapheme - 735 print-string-to-real-screen "' at (" - 736 print-int32-hex-to-real-screen row-idx - 737 print-string-to-real-screen ", " - 738 print-int32-hex-to-real-screen col-idx - 739 print-string-to-real-screen ") in color " - 740 print-int32-hex-to-real-screen fg - 741 print-string-to-real-screen " but observed color " - 742 print-int32-hex-to-real-screen color - 743 print-string-to-real-screen "\n" - 744 } - 745 } - 746 idx <- increment - 747 increment col-idx - 748 loop - 749 } - 750 } - 751 - 752 # background color is visible even for spaces, so 'expected' behaves as an array of booleans. - 753 # non-space = given background must match; space = background must not match - 754 fn check-screen-row-in-background-color screen: (addr screen), bg: int, row-idx: int, expected: (addr array byte), msg: (addr array byte) { - 755 check-screen-row-in-background-color-from screen, bg, row-idx, 1, expected, msg - 756 } - 757 - 758 fn check-screen-row-in-background-color-from screen-on-stack: (addr screen), bg: int, row-idx: int, col-idx: int, expected: (addr array byte), msg: (addr array byte) { - 759 var screen/esi: (addr screen) <- copy screen-on-stack - 760 var idx/ecx: int <- screen-cell-index screen, row-idx, col-idx - 761 # compare 'expected' with the screen contents starting at 'idx', grapheme by grapheme - 762 var e: (stream byte 0x100) - 763 var e-addr/edx: (addr stream byte) <- address e - 764 write e-addr, expected - 765 { - 766 var done?/eax: boolean <- stream-empty? e-addr - 767 compare done?, 0 - 768 break-if-!= - 769 var _g/eax: grapheme <- screen-grapheme-at-idx screen, idx - 770 var g/ebx: grapheme <- copy _g - 771 var _expected-grapheme/eax: grapheme <- read-grapheme e-addr - 772 var expected-grapheme/edx: grapheme <- copy _expected-grapheme - 773 $check-screen-row-in-background-color-from:compare-cells: { - 774 # if expected-grapheme is space, null grapheme is also ok - 775 { - 776 compare expected-grapheme, 0x20 - 777 break-if-!= - 778 compare g, 0 - 779 break-if-= $check-screen-row-in-background-color-from:compare-cells - 780 } - 781 # if expected-grapheme is space, a different color is ok - 782 { - 783 compare expected-grapheme, 0x20 - 784 break-if-!= - 785 var color/eax: int <- screen-background-color-at-idx screen, idx - 786 compare color, bg - 787 break-if-!= $check-screen-row-in-background-color-from:compare-cells - 788 } - 789 # compare graphemes - 790 $check-screen-row-in-background-color-from:compare-graphemes: { - 791 # if (g == expected-grapheme) print "." - 792 compare g, expected-grapheme - 793 { - 794 break-if-!= - 795 print-string-to-real-screen "." - 796 break $check-screen-row-in-background-color-from:compare-graphemes - 797 } - 798 # otherwise print an error - 799 print-string-to-real-screen msg - 800 print-string-to-real-screen ": expected '" - 801 print-grapheme-to-real-screen expected-grapheme - 802 print-string-to-real-screen "' at (" - 803 print-int32-hex-to-real-screen row-idx - 804 print-string-to-real-screen ", " - 805 print-int32-hex-to-real-screen col-idx - 806 print-string-to-real-screen ") but observed '" - 807 print-grapheme-to-real-screen g - 808 print-string-to-real-screen "'\n" - 809 } - 810 $check-screen-row-in-background-color-from:compare-colors: { - 811 var color/eax: int <- screen-background-color-at-idx screen, idx - 812 compare bg, color - 813 { - 814 break-if-!= - 815 print-string-to-real-screen "." - 816 break $check-screen-row-in-background-color-from:compare-colors - 817 } - 818 # otherwise print an error - 819 print-string-to-real-screen msg - 820 print-string-to-real-screen ": expected '" - 821 print-grapheme-to-real-screen expected-grapheme - 822 print-string-to-real-screen "' at (" - 823 print-int32-hex-to-real-screen row-idx - 824 print-string-to-real-screen ", " - 825 print-int32-hex-to-real-screen col-idx - 826 print-string-to-real-screen ") in background color " - 827 print-int32-hex-to-real-screen bg - 828 print-string-to-real-screen " but observed color " - 829 print-int32-hex-to-real-screen color - 830 print-string-to-real-screen "\n" - 831 } - 832 } - 833 idx <- increment - 834 increment col-idx - 835 loop - 836 } - 837 } - 838 - 839 fn check-screen-row-in-bold screen: (addr screen), row-idx: int, expected: (addr array byte), msg: (addr array byte) { - 840 check-screen-row-in-bold-from screen, row-idx, 1, expected, msg - 841 } - 842 - 843 fn check-screen-row-in-bold-from screen-on-stack: (addr screen), row-idx: int, col-idx: int, expected: (addr array byte), msg: (addr array byte) { - 844 var screen/esi: (addr screen) <- copy screen-on-stack - 845 var idx/ecx: int <- screen-cell-index screen, row-idx, col-idx - 846 # compare 'expected' with the screen contents starting at 'idx', grapheme by grapheme - 847 var e: (stream byte 0x100) - 848 var e-addr/edx: (addr stream byte) <- address e - 849 write e-addr, expected - 850 { - 851 var done?/eax: boolean <- stream-empty? e-addr - 852 compare done?, 0 - 853 break-if-!= - 854 var _g/eax: grapheme <- screen-grapheme-at-idx screen, idx - 855 var g/ebx: grapheme <- copy _g - 856 var _expected-grapheme/eax: grapheme <- read-grapheme e-addr - 857 var expected-grapheme/edx: grapheme <- copy _expected-grapheme - 858 $check-screen-row-in-bold-from:compare-cells: { - 859 # if expected-grapheme is space, null grapheme is also ok - 860 { - 861 compare expected-grapheme, 0x20 - 862 break-if-!= - 863 compare g, 0 - 864 break-if-= $check-screen-row-in-bold-from:compare-cells - 865 } - 866 # if expected-grapheme is space, non-bold is ok - 867 { - 868 compare expected-grapheme, 0x20 - 869 break-if-!= - 870 var bold?/eax: boolean <- screen-bold-at-idx? screen, idx - 871 compare bold?, 1 - 872 break-if-!= $check-screen-row-in-bold-from:compare-cells - 873 } - 874 # compare graphemes - 875 $check-screen-row-in-bold-from:compare-graphemes: { - 876 # if (g == expected-grapheme) print "." - 877 compare g, expected-grapheme - 878 { - 879 break-if-!= - 880 print-string-to-real-screen "." - 881 break $check-screen-row-in-bold-from:compare-graphemes - 882 } - 883 # otherwise print an error - 884 print-string-to-real-screen msg - 885 print-string-to-real-screen ": expected '" - 886 print-grapheme-to-real-screen expected-grapheme - 887 print-string-to-real-screen "' at (" - 888 print-int32-hex-to-real-screen row-idx - 889 print-string-to-real-screen ", " - 890 print-int32-hex-to-real-screen col-idx - 891 print-string-to-real-screen ") but observed '" - 892 print-grapheme-to-real-screen g - 893 print-string-to-real-screen "'\n" - 894 } - 895 $check-screen-row-in-bold-from:compare-bold: { - 896 var bold?/eax: boolean <- screen-bold-at-idx? screen, idx - 897 compare bold?, 1 - 898 { - 899 break-if-!= - 900 print-string-to-real-screen "." - 901 break $check-screen-row-in-bold-from:compare-bold - 902 } - 903 # otherwise print an error - 904 print-string-to-real-screen msg - 905 print-string-to-real-screen ": expected '" - 906 print-grapheme-to-real-screen expected-grapheme - 907 print-string-to-real-screen "' at (" - 908 print-int32-hex-to-real-screen row-idx - 909 print-string-to-real-screen ", " - 910 print-int32-hex-to-real-screen col-idx - 911 print-string-to-real-screen ") to be in bold\n" - 912 } - 913 } - 914 idx <- increment - 915 increment col-idx - 916 loop - 917 } - 918 } - 919 - 920 fn check-screen-row-in-underline screen: (addr screen), row-idx: int, expected: (addr array byte), msg: (addr array byte) { - 921 check-screen-row-in-underline-from screen, row-idx, 1, expected, msg - 922 } - 923 - 924 fn check-screen-row-in-underline-from screen-on-stack: (addr screen), row-idx: int, col-idx: int, expected: (addr array byte), msg: (addr array byte) { - 925 var screen/esi: (addr screen) <- copy screen-on-stack - 926 var idx/ecx: int <- screen-cell-index screen, row-idx, col-idx - 927 # compare 'expected' with the screen contents starting at 'idx', grapheme by grapheme - 928 var e: (stream byte 0x100) - 929 var e-addr/edx: (addr stream byte) <- address e - 930 write e-addr, expected - 931 { - 932 var done?/eax: boolean <- stream-empty? e-addr - 933 compare done?, 0 - 934 break-if-!= - 935 var _g/eax: grapheme <- screen-grapheme-at-idx screen, idx - 936 var g/ebx: grapheme <- copy _g - 937 var _expected-grapheme/eax: grapheme <- read-grapheme e-addr - 938 var expected-grapheme/edx: grapheme <- copy _expected-grapheme - 939 $check-screen-row-in-underline-from:compare-cells: { - 940 # if expected-grapheme is space, null grapheme is also ok - 941 { - 942 compare expected-grapheme, 0x20 - 943 break-if-!= - 944 compare g, 0 - 945 break-if-= $check-screen-row-in-underline-from:compare-cells - 946 } - 947 # if expected-grapheme is space, non-underline is ok - 948 { - 949 compare expected-grapheme, 0x20 - 950 break-if-!= - 951 var underline?/eax: boolean <- screen-underline-at-idx? screen, idx - 952 compare underline?, 1 - 953 break-if-!= $check-screen-row-in-underline-from:compare-cells - 954 } - 955 # compare graphemes - 956 $check-screen-row-in-underline-from:compare-graphemes: { - 957 # if (g == expected-grapheme) print "." - 958 compare g, expected-grapheme - 959 { - 960 break-if-!= - 961 print-string-to-real-screen "." - 962 break $check-screen-row-in-underline-from:compare-graphemes - 963 } - 964 # otherwise print an error - 965 print-string-to-real-screen msg - 966 print-string-to-real-screen ": expected '" - 967 print-grapheme-to-real-screen expected-grapheme - 968 print-string-to-real-screen "' at (" - 969 print-int32-hex-to-real-screen row-idx - 970 print-string-to-real-screen ", " - 971 print-int32-hex-to-real-screen col-idx - 972 print-string-to-real-screen ") but observed '" - 973 print-grapheme-to-real-screen g - 974 print-string-to-real-screen "'\n" - 975 } - 976 $check-screen-row-in-underline-from:compare-underline: { - 977 var underline?/eax: boolean <- screen-underline-at-idx? screen, idx - 978 compare underline?, 1 - 979 { - 980 break-if-!= - 981 print-string-to-real-screen "." - 982 break $check-screen-row-in-underline-from:compare-underline - 983 } - 984 # otherwise print an error - 985 print-string-to-real-screen msg - 986 print-string-to-real-screen ": expected '" - 987 print-grapheme-to-real-screen expected-grapheme - 988 print-string-to-real-screen "' at (" - 989 print-int32-hex-to-real-screen row-idx - 990 print-string-to-real-screen ", " - 991 print-int32-hex-to-real-screen col-idx - 992 print-string-to-real-screen ") to be underlined\n" - 993 } - 994 } - 995 idx <- increment - 996 increment col-idx - 997 loop - 998 } - 999 } -1000 -1001 fn check-screen-row-in-reverse screen: (addr screen), row-idx: int, expected: (addr array byte), msg: (addr array byte) { -1002 check-screen-row-in-reverse-from screen, row-idx, 1, expected, msg -1003 } -1004 -1005 fn check-screen-row-in-reverse-from screen-on-stack: (addr screen), row-idx: int, col-idx: int, expected: (addr array byte), msg: (addr array byte) { -1006 var screen/esi: (addr screen) <- copy screen-on-stack -1007 var idx/ecx: int <- screen-cell-index screen, row-idx, col-idx -1008 # compare 'expected' with the screen contents starting at 'idx', grapheme by grapheme -1009 var e: (stream byte 0x100) -1010 var e-addr/edx: (addr stream byte) <- address e -1011 write e-addr, expected -1012 { -1013 var done?/eax: boolean <- stream-empty? e-addr -1014 compare done?, 0 -1015 break-if-!= -1016 var _g/eax: grapheme <- screen-grapheme-at-idx screen, idx -1017 var g/ebx: grapheme <- copy _g -1018 var _expected-grapheme/eax: grapheme <- read-grapheme e-addr -1019 var expected-grapheme/edx: grapheme <- copy _expected-grapheme -1020 $check-screen-row-in-reverse-from:compare-cells: { -1021 # if expected-grapheme is space, null grapheme is also ok -1022 { -1023 compare expected-grapheme, 0x20 -1024 break-if-!= -1025 compare g, 0 -1026 break-if-= $check-screen-row-in-reverse-from:compare-cells -1027 } -1028 # if expected-grapheme is space, non-reverse is ok -1029 { -1030 compare expected-grapheme, 0x20 -1031 break-if-!= -1032 var reverse?/eax: boolean <- screen-reverse-at-idx? screen, idx -1033 compare reverse?, 1 -1034 break-if-!= $check-screen-row-in-reverse-from:compare-cells -1035 } -1036 # compare graphemes -1037 $check-screen-row-in-reverse-from:compare-graphemes: { -1038 # if (g == expected-grapheme) print "." -1039 compare g, expected-grapheme -1040 { -1041 break-if-!= -1042 print-string-to-real-screen "." -1043 break $check-screen-row-in-reverse-from:compare-graphemes -1044 } -1045 # otherwise print an error -1046 print-string-to-real-screen msg -1047 print-string-to-real-screen ": expected '" -1048 print-grapheme-to-real-screen expected-grapheme -1049 print-string-to-real-screen "' at (" -1050 print-int32-hex-to-real-screen row-idx -1051 print-string-to-real-screen ", " -1052 print-int32-hex-to-real-screen col-idx -1053 print-string-to-real-screen ") but observed '" -1054 print-grapheme-to-real-screen g -1055 print-string-to-real-screen "'\n" -1056 } -1057 $check-screen-row-in-reverse-from:compare-reverse: { -1058 var reverse?/eax: boolean <- screen-reverse-at-idx? screen, idx -1059 compare reverse?, 1 -1060 { -1061 break-if-!= -1062 print-string-to-real-screen "." -1063 break $check-screen-row-in-reverse-from:compare-reverse -1064 } -1065 # otherwise print an error -1066 print-string-to-real-screen msg -1067 print-string-to-real-screen ": expected '" -1068 print-grapheme-to-real-screen expected-grapheme -1069 print-string-to-real-screen "' at (" -1070 print-int32-hex-to-real-screen row-idx -1071 print-string-to-real-screen ", " -1072 print-int32-hex-to-real-screen col-idx -1073 print-string-to-real-screen ") to be in reverse-video\n" -1074 } -1075 } -1076 idx <- increment -1077 increment col-idx -1078 loop -1079 } -1080 } -1081 -1082 fn check-screen-row-in-blinking screen: (addr screen), row-idx: int, expected: (addr array byte), msg: (addr array byte) { -1083 check-screen-row-in-blinking-from screen, row-idx, 1, expected, msg -1084 } -1085 -1086 fn check-screen-row-in-blinking-from screen-on-stack: (addr screen), row-idx: int, col-idx: int, expected: (addr array byte), msg: (addr array byte) { -1087 var screen/esi: (addr screen) <- copy screen-on-stack -1088 var idx/ecx: int <- screen-cell-index screen, row-idx, col-idx -1089 # compare 'expected' with the screen contents starting at 'idx', grapheme by grapheme -1090 var e: (stream byte 0x100) -1091 var e-addr/edx: (addr stream byte) <- address e -1092 write e-addr, expected -1093 { -1094 var done?/eax: boolean <- stream-empty? e-addr -1095 compare done?, 0 -1096 break-if-!= -1097 var _g/eax: grapheme <- screen-grapheme-at-idx screen, idx -1098 var g/ebx: grapheme <- copy _g -1099 var _expected-grapheme/eax: grapheme <- read-grapheme e-addr -1100 var expected-grapheme/edx: grapheme <- copy _expected-grapheme -1101 $check-screen-row-in-blinking-from:compare-cells: { -1102 # if expected-grapheme is space, null grapheme is also ok -1103 { -1104 compare expected-grapheme, 0x20 -1105 break-if-!= -1106 compare g, 0 -1107 break-if-= $check-screen-row-in-blinking-from:compare-cells -1108 } -1109 # if expected-grapheme is space, non-blinking is ok -1110 { -1111 compare expected-grapheme, 0x20 -1112 break-if-!= -1113 var blinking?/eax: boolean <- screen-blink-at-idx? screen, idx -1114 compare blinking?, 1 -1115 break-if-!= $check-screen-row-in-blinking-from:compare-cells -1116 } -1117 # compare graphemes -1118 $check-screen-row-in-blinking-from:compare-graphemes: { -1119 # if (g == expected-grapheme) print "." -1120 compare g, expected-grapheme -1121 { -1122 break-if-!= -1123 print-string-to-real-screen "." -1124 break $check-screen-row-in-blinking-from:compare-graphemes -1125 } -1126 # otherwise print an error -1127 print-string-to-real-screen msg -1128 print-string-to-real-screen ": expected '" -1129 print-grapheme-to-real-screen expected-grapheme -1130 print-string-to-real-screen "' at (" -1131 print-int32-hex-to-real-screen row-idx -1132 print-string-to-real-screen ", " -1133 print-int32-hex-to-real-screen col-idx -1134 print-string-to-real-screen ") but observed '" -1135 print-grapheme-to-real-screen g -1136 print-string-to-real-screen "'\n" -1137 } -1138 $check-screen-row-in-blinking-from:compare-blinking: { -1139 var blinking?/eax: boolean <- screen-blink-at-idx? screen, idx -1140 compare blinking?, 1 -1141 { -1142 break-if-!= -1143 print-string-to-real-screen "." -1144 break $check-screen-row-in-blinking-from:compare-blinking -1145 } -1146 # otherwise print an error -1147 print-string-to-real-screen msg -1148 print-string-to-real-screen ": expected '" -1149 print-grapheme-to-real-screen expected-grapheme -1150 print-string-to-real-screen "' at (" -1151 print-int32-hex-to-real-screen row-idx -1152 print-string-to-real-screen ", " -1153 print-int32-hex-to-real-screen col-idx -1154 print-string-to-real-screen ") to be blinking\n" -1155 } -1156 } -1157 idx <- increment -1158 increment col-idx -1159 -1160 loop -1161 } -1162 } -1163 -1164 fn test-print-single-grapheme { -1165 var screen-on-stack: screen -1166 var screen/esi: (addr screen) <- address screen-on-stack -1167 initialize-screen screen, 5, 4 -1168 var c/eax: grapheme <- copy 0x61 # 'a' -1169 print-grapheme screen, c -1170 check-screen-row screen, 1, "a", "F - test-print-single-grapheme" # top-left corner of the screen -1171 } -1172 -1173 fn test-print-multiple-graphemes { -1174 var screen-on-stack: screen -1175 var screen/esi: (addr screen) <- address screen-on-stack -1176 initialize-screen screen, 5, 4 -1177 print-string screen, "Hello, 世界" -1178 check-screen-row screen, 1, "Hello, 世界", "F - test-print-multiple-graphemes" -1179 } -1180 -1181 fn test-move-cursor { -1182 var screen-on-stack: screen -1183 var screen/esi: (addr screen) <- address screen-on-stack -1184 initialize-screen screen, 5, 4 -1185 move-cursor screen, 1, 4 -1186 var c/eax: grapheme <- copy 0x61 # 'a' -1187 print-grapheme screen, c -1188 check-screen-row screen, 1, " a", "F - test-move-cursor" # top row -1189 } -1190 -1191 fn test-move-cursor-zeroes { -1192 var screen-on-stack: screen -1193 var screen/esi: (addr screen) <- address screen-on-stack -1194 initialize-screen screen, 5, 4 -1195 move-cursor screen, 0, 0 -1196 var c/eax: grapheme <- copy 0x61 # 'a' -1197 print-grapheme screen, c -1198 check-screen-row screen, 1, "a", "F - test-move-cursor-zeroes" # top-left corner of the screen -1199 } -1200 -1201 fn test-move-cursor-zero-row { -1202 var screen-on-stack: screen -1203 var screen/esi: (addr screen) <- address screen-on-stack -1204 initialize-screen screen, 5, 4 -1205 move-cursor screen, 0, 2 -1206 var c/eax: grapheme <- copy 0x61 # 'a' -1207 print-grapheme screen, c -1208 check-screen-row screen, 1, " a", "F - test-move-cursor-zero-row" # top row -1209 } -1210 -1211 fn test-move-cursor-zero-column { -1212 var screen-on-stack: screen -1213 var screen/esi: (addr screen) <- address screen-on-stack -1214 initialize-screen screen, 5, 4 -1215 move-cursor screen, 4, 0 -1216 var c/eax: grapheme <- copy 0x61 # 'a' -1217 print-grapheme screen, c -1218 check-screen-row screen, 4, "a", "F - test-move-cursor-zero-column" -1219 } -1220 -1221 fn test-move-cursor-negative-row { -1222 var screen-on-stack: screen -1223 var screen/esi: (addr screen) <- address screen-on-stack -1224 initialize-screen screen, 5, 3 -1225 move-cursor screen, -1, 2 # row -1 -1226 var c/eax: grapheme <- copy 0x61 # 'a' -1227 print-grapheme screen, c -1228 # no move -1229 check-screen-row screen, 1, "a", "F - test-move-cursor-negative-row" -1230 } -1231 -1232 fn test-move-cursor-negative-column { -1233 var screen-on-stack: screen -1234 var screen/esi: (addr screen) <- address screen-on-stack -1235 initialize-screen screen, 5, 3 -1236 move-cursor screen, 2, -1 # column -1 -1237 var c/eax: grapheme <- copy 0x61 # 'a' -1238 print-grapheme screen, c -1239 # no move -1240 check-screen-row screen, 1, "a", "F - test-move-cursor-negative-column" -1241 } -1242 -1243 fn test-move-cursor-column-too-large { -1244 var screen-on-stack: screen -1245 var screen/esi: (addr screen) <- address screen-on-stack -1246 initialize-screen screen, 5, 3 # 5 rows, 3 columns -1247 move-cursor screen, 1, 4 # row 1, column 4 (overflow) -1248 var c/eax: grapheme <- copy 0x61 # 'a' -1249 print-grapheme screen, c -1250 # top row is empty -1251 check-screen-row screen, 1, " ", "F - test-move-cursor-column-too-large" -1252 # character shows up on next row -1253 check-screen-row screen, 2, "a", "F - test-move-cursor-column-too-large" -1254 } -1255 -1256 fn test-move-cursor-column-too-large-saturates { -1257 var screen-on-stack: screen -1258 var screen/esi: (addr screen) <- address screen-on-stack -1259 initialize-screen screen, 5, 3 # 5 rows, 3 columns -1260 move-cursor screen, 1, 6 # row 1, column 6 (overflow) -1261 var c/eax: grapheme <- copy 0x61 # 'a' -1262 print-grapheme screen, c -1263 # top row is empty -1264 check-screen-row screen, 1, " ", "F - test-move-cursor-column-too-large-saturates" # top-left corner of the screen -1265 # character shows up at the start of next row -1266 check-screen-row screen, 2, "a", "F - test-move-cursor-column-too-large-saturates" # top-left corner of the screen -1267 } -1268 -1269 fn test-move-cursor-row-too-large { -1270 var screen-on-stack: screen -1271 var screen/esi: (addr screen) <- address screen-on-stack -1272 initialize-screen screen, 5, 3 # 5 rows -1273 move-cursor screen, 6, 2 # row 6 (overflow) -1274 var c/eax: grapheme <- copy 0x61 # 'a' -1275 print-grapheme screen, c -1276 # bottom row shows the character -1277 check-screen-row screen, 5, " a", "F - test-move-cursor-row-too-large" -1278 } -1279 -1280 fn test-move-cursor-row-too-large-saturates { -1281 var screen-on-stack: screen -1282 var screen/esi: (addr screen) <- address screen-on-stack -1283 initialize-screen screen, 5, 3 # 5 rows -1284 move-cursor screen, 9, 2 # row 9 (overflow) -1285 var c/eax: grapheme <- copy 0x61 # 'a' -1286 print-grapheme screen, c -1287 # bottom row shows the character -1288 check-screen-row screen, 5, " a", "F - test-move-cursor-row-too-large-saturates" -1289 } -1290 -1291 fn test-check-screen-row-from { -1292 var screen-on-stack: screen -1293 var screen/esi: (addr screen) <- address screen-on-stack -1294 initialize-screen screen, 5, 4 -1295 move-cursor screen, 1, 4 -1296 var c/eax: grapheme <- copy 0x61 # 'a' -1297 print-grapheme screen, c -1298 check-screen-row screen, 1, " a", "F - test-check-screen-row-from/baseline" -1299 check-screen-row-from screen, 1, 4, "a", "F - test-check-screen-row-from" -1300 } -1301 -1302 fn test-print-string-overflows-to-next-row { -1303 var screen-on-stack: screen -1304 var screen/esi: (addr screen) <- address screen-on-stack -1305 initialize-screen screen, 5, 4 # 5 rows, 4 columns -1306 print-string screen, "abcdefg" -1307 check-screen-row screen, 1, "abcd", "F - test-print-string-overflows-to-next-row" -1308 check-screen-row screen, 2, "efg", "F - test-print-string-overflows-to-next-row" -1309 } -1310 -1311 fn test-check-screen-scrolls-on-overflow { -1312 var screen-on-stack: screen -1313 var screen/esi: (addr screen) <- address screen-on-stack -1314 initialize-screen screen, 5, 4 -1315 # single character starting at bottom right -1316 move-cursor screen, 5, 4 -1317 var c/eax: grapheme <- copy 0x61 # 'a' -1318 print-grapheme screen, c -1319 check-screen-row-from screen, 5, 4, "a", "F - test-check-screen-scrolls-on-overflow/baseline" # bottom-right corner of the screen -1320 # multiple characters starting at bottom right -1321 move-cursor screen, 5, 4 -1322 print-string screen, "ab" -1323 # screen scrolled up one row -1324 #? check-screen-row screen, 1, " ", "F - test-check-screen-scrolls-on-overflow/x1" -1325 #? check-screen-row screen, 2, " ", "F - test-check-screen-scrolls-on-overflow/x2" -1326 #? check-screen-row screen, 3, " ", "F - test-check-screen-scrolls-on-overflow/x3" -1327 #? check-screen-row screen, 4, " a", "F - test-check-screen-scrolls-on-overflow/x4" -1328 #? check-screen-row screen, 5, "b ", "F - test-check-screen-scrolls-on-overflow/x5" -1329 check-screen-row-from screen, 4, 4, "a", "F - test-check-screen-scrolls-on-overflow/1" -1330 check-screen-row-from screen, 5, 1, "b", "F - test-check-screen-scrolls-on-overflow/2" -1331 } -1332 -1333 fn test-check-screen-color { -1334 var screen-on-stack: screen -1335 var screen/esi: (addr screen) <- address screen-on-stack -1336 initialize-screen screen, 5, 4 -1337 var c/eax: grapheme <- copy 0x61 # 'a' -1338 print-grapheme screen, c -1339 start-color screen, 1, 0 # foreground=1 -1340 c <- copy 0x62 # 'b' -1341 print-grapheme screen, c -1342 start-color screen, 0, 0 # back to default -1343 c <- copy 0x63 # 'c' -1344 print-grapheme screen, c -1345 check-screen-row-in-color screen, 0, 1, "a c", "F - test-check-screen-color" -1346 } -1347 -1348 fn test-check-screen-background-color { -1349 var screen-on-stack: screen -1350 var screen/esi: (addr screen) <- address screen-on-stack -1351 initialize-screen screen, 5, 4 -1352 var c/eax: grapheme <- copy 0x61 # 'a' -1353 print-grapheme screen, c -1354 start-color screen, 0, 1 # background=1 -1355 c <- copy 0x62 # 'b' -1356 print-grapheme screen, c -1357 start-color screen, 0, 7 # back to default -1358 c <- copy 0x63 # 'c' -1359 print-grapheme screen, c -1360 check-screen-row-in-background-color screen, 7, 1, "a c", "F - test-check-screen-background-color" -1361 } -1362 -1363 fn test-check-screen-bold { -1364 var screen-on-stack: screen -1365 var screen/esi: (addr screen) <- address screen-on-stack -1366 initialize-screen screen, 5, 4 -1367 start-bold screen -1368 var c/eax: grapheme <- copy 0x61 # 'a' -1369 print-grapheme screen, c -1370 reset-formatting screen -1371 c <- copy 0x62 # 'b' -1372 print-grapheme screen, c -1373 start-bold screen -1374 c <- copy 0x63 # 'c' -1375 print-grapheme screen, c -1376 check-screen-row-in-bold screen, 1, "a c", "F - test-check-screen-bold" -1377 } -1378 -1379 fn test-check-screen-underline { -1380 var screen-on-stack: screen -1381 var screen/esi: (addr screen) <- address screen-on-stack -1382 initialize-screen screen, 5, 4 -1383 start-underline screen -1384 var c/eax: grapheme <- copy 0x61 # 'a' -1385 print-grapheme screen, c -1386 reset-formatting screen -1387 c <- copy 0x62 # 'b' -1388 print-grapheme screen, c -1389 start-underline screen -1390 c <- copy 0x63 # 'c' -1391 print-grapheme screen, c -1392 check-screen-row-in-underline screen, 1, "a c", "F - test-check-screen-underline" -1393 } -1394 -1395 fn test-check-screen-reverse { -1396 var screen-on-stack: screen -1397 var screen/esi: (addr screen) <- address screen-on-stack -1398 initialize-screen screen, 5, 4 -1399 start-reverse-video screen -1400 var c/eax: grapheme <- copy 0x61 # 'a' -1401 print-grapheme screen, c -1402 reset-formatting screen -1403 c <- copy 0x62 # 'b' -1404 print-grapheme screen, c -1405 start-reverse-video screen -1406 c <- copy 0x63 # 'c' -1407 print-grapheme screen, c -1408 check-screen-row-in-reverse screen, 1, "a c", "F - test-check-screen-reverse" -1409 } -1410 -1411 fn test-check-screen-blinking { -1412 var screen-on-stack: screen -1413 var screen/esi: (addr screen) <- address screen-on-stack -1414 initialize-screen screen, 5, 4 -1415 start-blinking screen -1416 var c/eax: grapheme <- copy 0x61 # 'a' -1417 print-grapheme screen, c -1418 reset-formatting screen -1419 c <- copy 0x62 # 'b' -1420 print-grapheme screen, c -1421 start-blinking screen -1422 c <- copy 0x63 # 'c' -1423 print-grapheme screen, c -1424 check-screen-row-in-blinking screen, 1, "a c", "F - test-check-screen-blinking" -1425 } -1426 -1427 #? fn main -> _/ebx: int { -1428 #? #? test-check-screen-color -1429 #? run-tests -1430 #? return 0 -1431 #? } + 319 return *src + 320 } + 321 + 322 fn screen-color-at screen-on-stack: (addr screen), row: int, col: int -> _/eax: int { + 323 var screen-addr/esi: (addr screen) <- copy screen-on-stack + 324 var idx/ecx: int <- screen-cell-index screen-addr, row, col + 325 var result/eax: int <- screen-color-at-idx screen-addr, idx + 326 return result + 327 } + 328 + 329 fn screen-color-at-idx screen-on-stack: (addr screen), idx-on-stack: int -> _/eax: int { + 330 var screen-addr/esi: (addr screen) <- copy screen-on-stack + 331 var data-ah/eax: (addr handle array screen-cell) <- get screen-addr, data + 332 var data/eax: (addr array screen-cell) <- lookup *data-ah + 333 var idx/ecx: int <- copy idx-on-stack + 334 var offset/ecx: (offset screen-cell) <- compute-offset data, idx + 335 var cell/eax: (addr screen-cell) <- index data, offset + 336 var src/eax: (addr int) <- get cell, color + 337 var result/eax: int <- copy *src + 338 return result + 339 } + 340 + 341 fn screen-background-color-at screen-on-stack: (addr screen), row: int, col: int -> _/eax: int { + 342 var screen-addr/esi: (addr screen) <- copy screen-on-stack + 343 var idx/ecx: int <- screen-cell-index screen-addr, row, col + 344 var result/eax: int <- screen-background-color-at-idx screen-addr, idx + 345 return result + 346 } + 347 + 348 fn screen-background-color-at-idx screen-on-stack: (addr screen), idx-on-stack: int -> _/eax: int { + 349 var screen-addr/esi: (addr screen) <- copy screen-on-stack + 350 var data-ah/eax: (addr handle array screen-cell) <- get screen-addr, data + 351 var data/eax: (addr array screen-cell) <- lookup *data-ah + 352 var idx/ecx: int <- copy idx-on-stack + 353 var offset/ecx: (offset screen-cell) <- compute-offset data, idx + 354 var cell/eax: (addr screen-cell) <- index data, offset + 355 var src/eax: (addr int) <- get cell, background-color + 356 return *src + 357 } + 358 + 359 fn screen-bold-at? screen-on-stack: (addr screen), row: int, col: int -> _/eax: boolean { + 360 var screen-addr/esi: (addr screen) <- copy screen-on-stack + 361 var idx/ecx: int <- screen-cell-index screen-addr, row, col + 362 var result/eax: boolean <- screen-bold-at-idx? screen-addr, idx + 363 return result + 364 } + 365 + 366 fn screen-bold-at-idx? screen-on-stack: (addr screen), idx-on-stack: int -> _/eax: boolean { + 367 var screen-addr/esi: (addr screen) <- copy screen-on-stack + 368 var data-ah/eax: (addr handle array screen-cell) <- get screen-addr, data + 369 var data/eax: (addr array screen-cell) <- lookup *data-ah + 370 var idx/ecx: int <- copy idx-on-stack + 371 var offset/ecx: (offset screen-cell) <- compute-offset data, idx + 372 var cell/eax: (addr screen-cell) <- index data, offset + 373 var src/eax: (addr boolean) <- get cell, bold? + 374 return *src + 375 } + 376 + 377 fn screen-underline-at? screen-on-stack: (addr screen), row: int, col: int -> _/eax: boolean { + 378 var screen-addr/esi: (addr screen) <- copy screen-on-stack + 379 var idx/ecx: int <- screen-cell-index screen-addr, row, col + 380 var result/eax: boolean <- screen-underline-at-idx? screen-addr, idx + 381 return result + 382 } + 383 + 384 fn screen-underline-at-idx? screen-on-stack: (addr screen), idx-on-stack: int -> _/eax: boolean { + 385 var screen-addr/esi: (addr screen) <- copy screen-on-stack + 386 var data-ah/eax: (addr handle array screen-cell) <- get screen-addr, data + 387 var data/eax: (addr array screen-cell) <- lookup *data-ah + 388 var idx/ecx: int <- copy idx-on-stack + 389 var offset/ecx: (offset screen-cell) <- compute-offset data, idx + 390 var cell/eax: (addr screen-cell) <- index data, offset + 391 var src/eax: (addr boolean) <- get cell, underline? + 392 return *src + 393 } + 394 + 395 fn screen-reverse-at? screen-on-stack: (addr screen), row: int, col: int -> _/eax: boolean { + 396 var screen-addr/esi: (addr screen) <- copy screen-on-stack + 397 var idx/ecx: int <- screen-cell-index screen-addr, row, col + 398 var result/eax: boolean <- screen-reverse-at-idx? screen-addr, idx + 399 return result + 400 } + 401 + 402 fn screen-reverse-at-idx? screen-on-stack: (addr screen), idx-on-stack: int -> _/eax: boolean { + 403 var screen-addr/esi: (addr screen) <- copy screen-on-stack + 404 var data-ah/eax: (addr handle array screen-cell) <- get screen-addr, data + 405 var data/eax: (addr array screen-cell) <- lookup *data-ah + 406 var idx/ecx: int <- copy idx-on-stack + 407 var offset/ecx: (offset screen-cell) <- compute-offset data, idx + 408 var cell/eax: (addr screen-cell) <- index data, offset + 409 var src/eax: (addr boolean) <- get cell, reverse? + 410 return *src + 411 } + 412 + 413 fn screen-blink-at? screen-on-stack: (addr screen), row: int, col: int -> _/eax: boolean { + 414 var screen-addr/esi: (addr screen) <- copy screen-on-stack + 415 var idx/ecx: int <- screen-cell-index screen-addr, row, col + 416 var result/eax: boolean <- screen-blink-at-idx? screen-addr, idx + 417 return result + 418 } + 419 + 420 fn screen-blink-at-idx? screen-on-stack: (addr screen), idx-on-stack: int -> _/eax: boolean { + 421 var screen-addr/esi: (addr screen) <- copy screen-on-stack + 422 var data-ah/eax: (addr handle array screen-cell) <- get screen-addr, data + 423 var data/eax: (addr array screen-cell) <- lookup *data-ah + 424 var idx/ecx: int <- copy idx-on-stack + 425 var offset/ecx: (offset screen-cell) <- compute-offset data, idx + 426 var cell/eax: (addr screen-cell) <- index data, offset + 427 var src/eax: (addr boolean) <- get cell, blink? + 428 return *src + 429 } + 430 + 431 fn print-code-point screen: (addr screen), c: code-point { + 432 var g/eax: grapheme <- to-grapheme c + 433 print-grapheme screen, g + 434 } + 435 + 436 fn print-int32-hex screen: (addr screen), n: int { + 437 compare screen, 0 + 438 { + 439 break-if-!= + 440 print-int32-hex-to-real-screen n + 441 return + 442 } + 443 # fake screen + 444 var s2: (stream byte 0x100) + 445 var s2-addr/esi: (addr stream byte) <- address s2 + 446 write-int32-hex s2-addr, n + 447 var screen-addr/edi: (addr screen) <- copy screen + 448 { + 449 var done?/eax: boolean <- stream-empty? s2-addr + 450 compare done?, 0 + 451 break-if-!= + 452 var g/eax: grapheme <- read-grapheme s2-addr + 453 print-grapheme screen, g + 454 loop + 455 } + 456 } + 457 + 458 fn print-int32-hex-bits screen: (addr screen), n: int, bits: int { + 459 compare screen, 0 + 460 { + 461 break-if-!= + 462 print-int32-hex-bits-to-real-screen n, bits + 463 return + 464 } + 465 # fake screen + 466 var s2: (stream byte 0x100) + 467 var s2-addr/esi: (addr stream byte) <- address s2 + 468 write-int32-hex-bits s2-addr, n, bits + 469 var screen-addr/edi: (addr screen) <- copy screen + 470 { + 471 var done?/eax: boolean <- stream-empty? s2-addr + 472 compare done?, 0 + 473 break-if-!= + 474 var g/eax: grapheme <- read-grapheme s2-addr + 475 print-grapheme screen, g + 476 loop + 477 } + 478 } + 479 + 480 fn print-int32-decimal screen: (addr screen), n: int { + 481 compare screen, 0 + 482 { + 483 break-if-!= + 484 print-int32-decimal-to-real-screen n + 485 return + 486 } + 487 # fake screen + 488 # TODO + 489 } + 490 + 491 fn reset-formatting screen: (addr screen) { + 492 compare screen, 0 + 493 { + 494 break-if-!= + 495 reset-formatting-on-real-screen + 496 return + 497 } + 498 # fake screen + 499 var screen-addr/esi: (addr screen) <- copy screen + 500 var dest/ecx: (addr screen-cell) <- get screen-addr, curr-attributes + 501 var default-cell: screen-cell + 502 var bg/eax: (addr int) <- get default-cell, background-color + 503 copy-to *bg, 7 + 504 var default-cell-addr/eax: (addr screen-cell) <- address default-cell + 505 copy-object default-cell-addr, dest + 506 } + 507 + 508 fn start-color screen: (addr screen), fg: int, bg: int { + 509 compare screen, 0 + 510 { + 511 break-if-!= + 512 start-color-on-real-screen fg, bg + 513 return + 514 } + 515 # fake screen + 516 var screen-addr/esi: (addr screen) <- copy screen + 517 var attr/ecx: (addr screen-cell) <- get screen-addr, curr-attributes + 518 var dest/edx: (addr int) <- get attr, color + 519 var src/eax: int <- copy fg + 520 copy-to *dest, src + 521 var dest/edx: (addr int) <- get attr, background-color + 522 var src/eax: int <- copy bg + 523 copy-to *dest, src + 524 } + 525 + 526 fn start-bold screen: (addr screen) { + 527 compare screen, 0 + 528 { + 529 break-if-!= + 530 start-bold-on-real-screen + 531 return + 532 } + 533 # fake screen + 534 var screen-addr/esi: (addr screen) <- copy screen + 535 var attr/ecx: (addr screen-cell) <- get screen-addr, curr-attributes + 536 var dest/edx: (addr boolean) <- get attr, bold? + 537 copy-to *dest, 1 + 538 } + 539 + 540 fn start-underline screen: (addr screen) { + 541 compare screen, 0 + 542 { + 543 break-if-!= + 544 start-underline-on-real-screen + 545 return + 546 } + 547 # fake screen + 548 var screen-addr/esi: (addr screen) <- copy screen + 549 var attr/ecx: (addr screen-cell) <- get screen-addr, curr-attributes + 550 var dest/edx: (addr boolean) <- get attr, underline? + 551 copy-to *dest, 1 + 552 } + 553 + 554 fn start-reverse-video screen: (addr screen) { + 555 compare screen, 0 + 556 { + 557 break-if-!= + 558 start-reverse-video-on-real-screen + 559 return + 560 } + 561 # fake screen + 562 var screen-addr/esi: (addr screen) <- copy screen + 563 var attr/ecx: (addr screen-cell) <- get screen-addr, curr-attributes + 564 var dest/edx: (addr boolean) <- get attr, reverse? + 565 copy-to *dest, 1 + 566 } + 567 + 568 fn start-blinking screen: (addr screen) { + 569 compare screen, 0 + 570 { + 571 break-if-!= + 572 start-blinking-on-real-screen + 573 return + 574 } + 575 # fake screen + 576 var screen-addr/esi: (addr screen) <- copy screen + 577 var attr/ecx: (addr screen-cell) <- get screen-addr, curr-attributes + 578 var dest/edx: (addr boolean) <- get attr, blink? + 579 copy-to *dest, 1 + 580 } + 581 + 582 fn hide-cursor screen: (addr screen) { + 583 compare screen, 0 + 584 { + 585 break-if-!= + 586 hide-cursor-on-real-screen + 587 return + 588 } + 589 # fake screen + 590 var screen-addr/esi: (addr screen) <- copy screen + 591 var hide?/ecx: (addr boolean) <- get screen-addr, cursor-hide? + 592 copy-to *hide?, 1 + 593 } + 594 + 595 fn show-cursor screen: (addr screen) { + 596 compare screen, 0 + 597 { + 598 break-if-!= + 599 show-cursor-on-real-screen + 600 return + 601 } + 602 # fake screen + 603 var screen-addr/esi: (addr screen) <- copy screen + 604 var hide?/ecx: (addr boolean) <- get screen-addr, cursor-hide? + 605 copy-to *hide?, 0 + 606 } + 607 + 608 # validate data on screen regardless of attributes (color, bold, etc.) + 609 # Mu doesn't have multi-line strings, so we provide functions for rows or portions of rows. + 610 # Tab characters (that translate into multiple screen cells) not supported. + 611 + 612 fn check-screen-row screen: (addr screen), row-idx: int, expected: (addr array byte), msg: (addr array byte) { + 613 check-screen-row-from screen, row-idx, 1, expected, msg + 614 } + 615 + 616 fn check-screen-row-from screen-on-stack: (addr screen), row-idx: int, col-idx: int, expected: (addr array byte), msg: (addr array byte) { + 617 var screen/esi: (addr screen) <- copy screen-on-stack + 618 var idx/ecx: int <- screen-cell-index screen, row-idx, col-idx + 619 # compare 'expected' with the screen contents starting at 'idx', grapheme by grapheme + 620 var e: (stream byte 0x100) + 621 var e-addr/edx: (addr stream byte) <- address e + 622 write e-addr, expected + 623 { + 624 var done?/eax: boolean <- stream-empty? e-addr + 625 compare done?, 0 + 626 break-if-!= + 627 var _g/eax: grapheme <- screen-grapheme-at-idx screen, idx + 628 var g/ebx: grapheme <- copy _g + 629 var expected-grapheme/eax: grapheme <- read-grapheme e-addr + 630 # compare graphemes + 631 $check-screen-row-from:compare-graphemes: { + 632 # if expected-grapheme is space, null grapheme is also ok + 633 { + 634 compare expected-grapheme, 0x20 + 635 break-if-!= + 636 compare g, 0 + 637 break-if-= $check-screen-row-from:compare-graphemes + 638 } + 639 # if (g == expected-grapheme) print "." + 640 compare g, expected-grapheme + 641 { + 642 break-if-!= + 643 print-string-to-real-screen "." + 644 break $check-screen-row-from:compare-graphemes + 645 } + 646 # otherwise print an error + 647 print-string-to-real-screen msg + 648 print-string-to-real-screen ": expected '" + 649 print-grapheme-to-real-screen expected-grapheme + 650 print-string-to-real-screen "' at (" + 651 print-int32-hex-to-real-screen row-idx + 652 print-string-to-real-screen ", " + 653 print-int32-hex-to-real-screen col-idx + 654 print-string-to-real-screen ") but observed '" + 655 print-grapheme-to-real-screen g + 656 print-string-to-real-screen "'\n" + 657 } + 658 idx <- increment + 659 increment col-idx + 660 loop + 661 } + 662 } + 663 + 664 # various variants by screen-cell attribute; spaces in the 'expected' data should not match the attribute + 665 + 666 fn check-screen-row-in-color screen: (addr screen), fg: int, row-idx: int, expected: (addr array byte), msg: (addr array byte) { + 667 check-screen-row-in-color-from screen, fg, row-idx, 1, expected, msg + 668 } + 669 + 670 fn check-screen-row-in-color-from screen-on-stack: (addr screen), fg: int, row-idx: int, col-idx: int, expected: (addr array byte), msg: (addr array byte) { + 671 var screen/esi: (addr screen) <- copy screen-on-stack + 672 var idx/ecx: int <- screen-cell-index screen, row-idx, col-idx + 673 # compare 'expected' with the screen contents starting at 'idx', grapheme by grapheme + 674 var e: (stream byte 0x100) + 675 var e-addr/edx: (addr stream byte) <- address e + 676 write e-addr, expected + 677 { + 678 var done?/eax: boolean <- stream-empty? e-addr + 679 compare done?, 0 + 680 break-if-!= + 681 var _g/eax: grapheme <- screen-grapheme-at-idx screen, idx + 682 var g/ebx: grapheme <- copy _g + 683 var _expected-grapheme/eax: grapheme <- read-grapheme e-addr + 684 var expected-grapheme/edi: grapheme <- copy _expected-grapheme + 685 $check-screen-row-in-color-from:compare-cells: { + 686 # if expected-grapheme is space, null grapheme is also ok + 687 { + 688 compare expected-grapheme, 0x20 + 689 break-if-!= + 690 compare g, 0 + 691 break-if-= $check-screen-row-in-color-from:compare-cells + 692 } + 693 # if expected-grapheme is space, a different color is ok + 694 { + 695 compare expected-grapheme, 0x20 + 696 break-if-!= + 697 var color/eax: int <- screen-color-at-idx screen, idx + 698 compare color, fg + 699 break-if-!= $check-screen-row-in-color-from:compare-cells + 700 } + 701 # compare graphemes + 702 $check-screen-row-in-color-from:compare-graphemes: { + 703 # if (g == expected-grapheme) print "." + 704 compare g, expected-grapheme + 705 { + 706 break-if-!= + 707 print-string-to-real-screen "." + 708 break $check-screen-row-in-color-from:compare-graphemes + 709 } + 710 # otherwise print an error + 711 print-string-to-real-screen msg + 712 print-string-to-real-screen ": expected '" + 713 print-grapheme-to-real-screen expected-grapheme + 714 print-string-to-real-screen "' at (" + 715 print-int32-hex-to-real-screen row-idx + 716 print-string-to-real-screen ", " + 717 print-int32-hex-to-real-screen col-idx + 718 print-string-to-real-screen ") but observed '" + 719 print-grapheme-to-real-screen g + 720 print-string-to-real-screen "'\n" + 721 } + 722 $check-screen-row-in-color-from:compare-colors: { + 723 var color/eax: int <- screen-color-at-idx screen, idx + 724 compare fg, color + 725 { + 726 break-if-!= + 727 print-string-to-real-screen "." + 728 break $check-screen-row-in-color-from:compare-colors + 729 } + 730 # otherwise print an error + 731 print-string-to-real-screen msg + 732 print-string-to-real-screen ": expected '" + 733 print-grapheme-to-real-screen expected-grapheme + 734 print-string-to-real-screen "' at (" + 735 print-int32-hex-to-real-screen row-idx + 736 print-string-to-real-screen ", " + 737 print-int32-hex-to-real-screen col-idx + 738 print-string-to-real-screen ") in color " + 739 print-int32-hex-to-real-screen fg + 740 print-string-to-real-screen " but observed color " + 741 print-int32-hex-to-real-screen color + 742 print-string-to-real-screen "\n" + 743 } + 744 } + 745 idx <- increment + 746 increment col-idx + 747 loop + 748 } + 749 } + 750 + 751 # background color is visible even for spaces, so 'expected' behaves as an array of booleans. + 752 # non-space = given background must match; space = background must not match + 753 fn check-screen-row-in-background-color screen: (addr screen), bg: int, row-idx: int, expected: (addr array byte), msg: (addr array byte) { + 754 check-screen-row-in-background-color-from screen, bg, row-idx, 1, expected, msg + 755 } + 756 + 757 fn check-screen-row-in-background-color-from screen-on-stack: (addr screen), bg: int, row-idx: int, col-idx: int, expected: (addr array byte), msg: (addr array byte) { + 758 var screen/esi: (addr screen) <- copy screen-on-stack + 759 var idx/ecx: int <- screen-cell-index screen, row-idx, col-idx + 760 # compare 'expected' with the screen contents starting at 'idx', grapheme by grapheme + 761 var e: (stream byte 0x100) + 762 var e-addr/edx: (addr stream byte) <- address e + 763 write e-addr, expected + 764 { + 765 var done?/eax: boolean <- stream-empty? e-addr + 766 compare done?, 0 + 767 break-if-!= + 768 var _g/eax: grapheme <- screen-grapheme-at-idx screen, idx + 769 var g/ebx: grapheme <- copy _g + 770 var _expected-grapheme/eax: grapheme <- read-grapheme e-addr + 771 var expected-grapheme/edx: grapheme <- copy _expected-grapheme + 772 $check-screen-row-in-background-color-from:compare-cells: { + 773 # if expected-grapheme is space, null grapheme is also ok + 774 { + 775 compare expected-grapheme, 0x20 + 776 break-if-!= + 777 compare g, 0 + 778 break-if-= $check-screen-row-in-background-color-from:compare-cells + 779 } + 780 # if expected-grapheme is space, a different color is ok + 781 { + 782 compare expected-grapheme, 0x20 + 783 break-if-!= + 784 var color/eax: int <- screen-background-color-at-idx screen, idx + 785 compare color, bg + 786 break-if-!= $check-screen-row-in-background-color-from:compare-cells + 787 } + 788 # compare graphemes + 789 $check-screen-row-in-background-color-from:compare-graphemes: { + 790 # if (g == expected-grapheme) print "." + 791 compare g, expected-grapheme + 792 { + 793 break-if-!= + 794 print-string-to-real-screen "." + 795 break $check-screen-row-in-background-color-from:compare-graphemes + 796 } + 797 # otherwise print an error + 798 print-string-to-real-screen msg + 799 print-string-to-real-screen ": expected '" + 800 print-grapheme-to-real-screen expected-grapheme + 801 print-string-to-real-screen "' at (" + 802 print-int32-hex-to-real-screen row-idx + 803 print-string-to-real-screen ", " + 804 print-int32-hex-to-real-screen col-idx + 805 print-string-to-real-screen ") but observed '" + 806 print-grapheme-to-real-screen g + 807 print-string-to-real-screen "'\n" + 808 } + 809 $check-screen-row-in-background-color-from:compare-colors: { + 810 var color/eax: int <- screen-background-color-at-idx screen, idx + 811 compare bg, color + 812 { + 813 break-if-!= + 814 print-string-to-real-screen "." + 815 break $check-screen-row-in-background-color-from:compare-colors + 816 } + 817 # otherwise print an error + 818 print-string-to-real-screen msg + 819 print-string-to-real-screen ": expected '" + 820 print-grapheme-to-real-screen expected-grapheme + 821 print-string-to-real-screen "' at (" + 822 print-int32-hex-to-real-screen row-idx + 823 print-string-to-real-screen ", " + 824 print-int32-hex-to-real-screen col-idx + 825 print-string-to-real-screen ") in background color " + 826 print-int32-hex-to-real-screen bg + 827 print-string-to-real-screen " but observed color " + 828 print-int32-hex-to-real-screen color + 829 print-string-to-real-screen "\n" + 830 } + 831 } + 832 idx <- increment + 833 increment col-idx + 834 loop + 835 } + 836 } + 837 + 838 fn check-screen-row-in-bold screen: (addr screen), row-idx: int, expected: (addr array byte), msg: (addr array byte) { + 839 check-screen-row-in-bold-from screen, row-idx, 1, expected, msg + 840 } + 841 + 842 fn check-screen-row-in-bold-from screen-on-stack: (addr screen), row-idx: int, col-idx: int, expected: (addr array byte), msg: (addr array byte) { + 843 var screen/esi: (addr screen) <- copy screen-on-stack + 844 var idx/ecx: int <- screen-cell-index screen, row-idx, col-idx + 845 # compare 'expected' with the screen contents starting at 'idx', grapheme by grapheme + 846 var e: (stream byte 0x100) + 847 var e-addr/edx: (addr stream byte) <- address e + 848 write e-addr, expected + 849 { + 850 var done?/eax: boolean <- stream-empty? e-addr + 851 compare done?, 0 + 852 break-if-!= + 853 var _g/eax: grapheme <- screen-grapheme-at-idx screen, idx + 854 var g/ebx: grapheme <- copy _g + 855 var _expected-grapheme/eax: grapheme <- read-grapheme e-addr + 856 var expected-grapheme/edx: grapheme <- copy _expected-grapheme + 857 $check-screen-row-in-bold-from:compare-cells: { + 858 # if expected-grapheme is space, null grapheme is also ok + 859 { + 860 compare expected-grapheme, 0x20 + 861 break-if-!= + 862 compare g, 0 + 863 break-if-= $check-screen-row-in-bold-from:compare-cells + 864 } + 865 # if expected-grapheme is space, non-bold is ok + 866 { + 867 compare expected-grapheme, 0x20 + 868 break-if-!= + 869 var bold?/eax: boolean <- screen-bold-at-idx? screen, idx + 870 compare bold?, 1 + 871 break-if-!= $check-screen-row-in-bold-from:compare-cells + 872 } + 873 # compare graphemes + 874 $check-screen-row-in-bold-from:compare-graphemes: { + 875 # if (g == expected-grapheme) print "." + 876 compare g, expected-grapheme + 877 { + 878 break-if-!= + 879 print-string-to-real-screen "." + 880 break $check-screen-row-in-bold-from:compare-graphemes + 881 } + 882 # otherwise print an error + 883 print-string-to-real-screen msg + 884 print-string-to-real-screen ": expected '" + 885 print-grapheme-to-real-screen expected-grapheme + 886 print-string-to-real-screen "' at (" + 887 print-int32-hex-to-real-screen row-idx + 888 print-string-to-real-screen ", " + 889 print-int32-hex-to-real-screen col-idx + 890 print-string-to-real-screen ") but observed '" + 891 print-grapheme-to-real-screen g + 892 print-string-to-real-screen "'\n" + 893 } + 894 $check-screen-row-in-bold-from:compare-bold: { + 895 var bold?/eax: boolean <- screen-bold-at-idx? screen, idx + 896 compare bold?, 1 + 897 { + 898 break-if-!= + 899 print-string-to-real-screen "." + 900 break $check-screen-row-in-bold-from:compare-bold + 901 } + 902 # otherwise print an error + 903 print-string-to-real-screen msg + 904 print-string-to-real-screen ": expected '" + 905 print-grapheme-to-real-screen expected-grapheme + 906 print-string-to-real-screen "' at (" + 907 print-int32-hex-to-real-screen row-idx + 908 print-string-to-real-screen ", " + 909 print-int32-hex-to-real-screen col-idx + 910 print-string-to-real-screen ") to be in bold\n" + 911 } + 912 } + 913 idx <- increment + 914 increment col-idx + 915 loop + 916 } + 917 } + 918 + 919 fn check-screen-row-in-underline screen: (addr screen), row-idx: int, expected: (addr array byte), msg: (addr array byte) { + 920 check-screen-row-in-underline-from screen, row-idx, 1, expected, msg + 921 } + 922 + 923 fn check-screen-row-in-underline-from screen-on-stack: (addr screen), row-idx: int, col-idx: int, expected: (addr array byte), msg: (addr array byte) { + 924 var screen/esi: (addr screen) <- copy screen-on-stack + 925 var idx/ecx: int <- screen-cell-index screen, row-idx, col-idx + 926 # compare 'expected' with the screen contents starting at 'idx', grapheme by grapheme + 927 var e: (stream byte 0x100) + 928 var e-addr/edx: (addr stream byte) <- address e + 929 write e-addr, expected + 930 { + 931 var done?/eax: boolean <- stream-empty? e-addr + 932 compare done?, 0 + 933 break-if-!= + 934 var _g/eax: grapheme <- screen-grapheme-at-idx screen, idx + 935 var g/ebx: grapheme <- copy _g + 936 var _expected-grapheme/eax: grapheme <- read-grapheme e-addr + 937 var expected-grapheme/edx: grapheme <- copy _expected-grapheme + 938 $check-screen-row-in-underline-from:compare-cells: { + 939 # if expected-grapheme is space, null grapheme is also ok + 940 { + 941 compare expected-grapheme, 0x20 + 942 break-if-!= + 943 compare g, 0 + 944 break-if-= $check-screen-row-in-underline-from:compare-cells + 945 } + 946 # if expected-grapheme is space, non-underline is ok + 947 { + 948 compare expected-grapheme, 0x20 + 949 break-if-!= + 950 var underline?/eax: boolean <- screen-underline-at-idx? screen, idx + 951 compare underline?, 1 + 952 break-if-!= $check-screen-row-in-underline-from:compare-cells + 953 } + 954 # compare graphemes + 955 $check-screen-row-in-underline-from:compare-graphemes: { + 956 # if (g == expected-grapheme) print "." + 957 compare g, expected-grapheme + 958 { + 959 break-if-!= + 960 print-string-to-real-screen "." + 961 break $check-screen-row-in-underline-from:compare-graphemes + 962 } + 963 # otherwise print an error + 964 print-string-to-real-screen msg + 965 print-string-to-real-screen ": expected '" + 966 print-grapheme-to-real-screen expected-grapheme + 967 print-string-to-real-screen "' at (" + 968 print-int32-hex-to-real-screen row-idx + 969 print-string-to-real-screen ", " + 970 print-int32-hex-to-real-screen col-idx + 971 print-string-to-real-screen ") but observed '" + 972 print-grapheme-to-real-screen g + 973 print-string-to-real-screen "'\n" + 974 } + 975 $check-screen-row-in-underline-from:compare-underline: { + 976 var underline?/eax: boolean <- screen-underline-at-idx? screen, idx + 977 compare underline?, 1 + 978 { + 979 break-if-!= + 980 print-string-to-real-screen "." + 981 break $check-screen-row-in-underline-from:compare-underline + 982 } + 983 # otherwise print an error + 984 print-string-to-real-screen msg + 985 print-string-to-real-screen ": expected '" + 986 print-grapheme-to-real-screen expected-grapheme + 987 print-string-to-real-screen "' at (" + 988 print-int32-hex-to-real-screen row-idx + 989 print-string-to-real-screen ", " + 990 print-int32-hex-to-real-screen col-idx + 991 print-string-to-real-screen ") to be underlined\n" + 992 } + 993 } + 994 idx <- increment + 995 increment col-idx + 996 loop + 997 } + 998 } + 999 +1000 fn check-screen-row-in-reverse screen: (addr screen), row-idx: int, expected: (addr array byte), msg: (addr array byte) { +1001 check-screen-row-in-reverse-from screen, row-idx, 1, expected, msg +1002 } +1003 +1004 fn check-screen-row-in-reverse-from screen-on-stack: (addr screen), row-idx: int, col-idx: int, expected: (addr array byte), msg: (addr array byte) { +1005 var screen/esi: (addr screen) <- copy screen-on-stack +1006 var idx/ecx: int <- screen-cell-index screen, row-idx, col-idx +1007 # compare 'expected' with the screen contents starting at 'idx', grapheme by grapheme +1008 var e: (stream byte 0x100) +1009 var e-addr/edx: (addr stream byte) <- address e +1010 write e-addr, expected +1011 { +1012 var done?/eax: boolean <- stream-empty? e-addr +1013 compare done?, 0 +1014 break-if-!= +1015 var _g/eax: grapheme <- screen-grapheme-at-idx screen, idx +1016 var g/ebx: grapheme <- copy _g +1017 var _expected-grapheme/eax: grapheme <- read-grapheme e-addr +1018 var expected-grapheme/edx: grapheme <- copy _expected-grapheme +1019 $check-screen-row-in-reverse-from:compare-cells: { +1020 # if expected-grapheme is space, null grapheme is also ok +1021 { +1022 compare expected-grapheme, 0x20 +1023 break-if-!= +1024 compare g, 0 +1025 break-if-= $check-screen-row-in-reverse-from:compare-cells +1026 } +1027 # if expected-grapheme is space, non-reverse is ok +1028 { +1029 compare expected-grapheme, 0x20 +1030 break-if-!= +1031 var reverse?/eax: boolean <- screen-reverse-at-idx? screen, idx +1032 compare reverse?, 1 +1033 break-if-!= $check-screen-row-in-reverse-from:compare-cells +1034 } +1035 # compare graphemes +1036 $check-screen-row-in-reverse-from:compare-graphemes: { +1037 # if (g == expected-grapheme) print "." +1038 compare g, expected-grapheme +1039 { +1040 break-if-!= +1041 print-string-to-real-screen "." +1042 break $check-screen-row-in-reverse-from:compare-graphemes +1043 } +1044 # otherwise print an error +1045 print-string-to-real-screen msg +1046 print-string-to-real-screen ": expected '" +1047 print-grapheme-to-real-screen expected-grapheme +1048 print-string-to-real-screen "' at (" +1049 print-int32-hex-to-real-screen row-idx +1050 print-string-to-real-screen ", " +1051 print-int32-hex-to-real-screen col-idx +1052 print-string-to-real-screen ") but observed '" +1053 print-grapheme-to-real-screen g +1054 print-string-to-real-screen "'\n" +1055 } +1056 $check-screen-row-in-reverse-from:compare-reverse: { +1057 var reverse?/eax: boolean <- screen-reverse-at-idx? screen, idx +1058 compare reverse?, 1 +1059 { +1060 break-if-!= +1061 print-string-to-real-screen "." +1062 break $check-screen-row-in-reverse-from:compare-reverse +1063 } +1064 # otherwise print an error +1065 print-string-to-real-screen msg +1066 print-string-to-real-screen ": expected '" +1067 print-grapheme-to-real-screen expected-grapheme +1068 print-string-to-real-screen "' at (" +1069 print-int32-hex-to-real-screen row-idx +1070 print-string-to-real-screen ", " +1071 print-int32-hex-to-real-screen col-idx +1072 print-string-to-real-screen ") to be in reverse-video\n" +1073 } +1074 } +1075 idx <- increment +1076 increment col-idx +1077 loop +1078 } +1079 } +1080 +1081 fn check-screen-row-in-blinking screen: (addr screen), row-idx: int, expected: (addr array byte), msg: (addr array byte) { +1082 check-screen-row-in-blinking-from screen, row-idx, 1, expected, msg +1083 } +1084 +1085 fn check-screen-row-in-blinking-from screen-on-stack: (addr screen), row-idx: int, col-idx: int, expected: (addr array byte), msg: (addr array byte) { +1086 var screen/esi: (addr screen) <- copy screen-on-stack +1087 var idx/ecx: int <- screen-cell-index screen, row-idx, col-idx +1088 # compare 'expected' with the screen contents starting at 'idx', grapheme by grapheme +1089 var e: (stream byte 0x100) +1090 var e-addr/edx: (addr stream byte) <- address e +1091 write e-addr, expected +1092 { +1093 var done?/eax: boolean <- stream-empty? e-addr +1094 compare done?, 0 +1095 break-if-!= +1096 var _g/eax: grapheme <- screen-grapheme-at-idx screen, idx +1097 var g/ebx: grapheme <- copy _g +1098 var _expected-grapheme/eax: grapheme <- read-grapheme e-addr +1099 var expected-grapheme/edx: grapheme <- copy _expected-grapheme +1100 $check-screen-row-in-blinking-from:compare-cells: { +1101 # if expected-grapheme is space, null grapheme is also ok +1102 { +1103 compare expected-grapheme, 0x20 +1104 break-if-!= +1105 compare g, 0 +1106 break-if-= $check-screen-row-in-blinking-from:compare-cells +1107 } +1108 # if expected-grapheme is space, non-blinking is ok +1109 { +1110 compare expected-grapheme, 0x20 +1111 break-if-!= +1112 var blinking?/eax: boolean <- screen-blink-at-idx? screen, idx +1113 compare blinking?, 1 +1114 break-if-!= $check-screen-row-in-blinking-from:compare-cells +1115 } +1116 # compare graphemes +1117 $check-screen-row-in-blinking-from:compare-graphemes: { +1118 # if (g == expected-grapheme) print "." +1119 compare g, expected-grapheme +1120 { +1121 break-if-!= +1122 print-string-to-real-screen "." +1123 break $check-screen-row-in-blinking-from:compare-graphemes +1124 } +1125 # otherwise print an error +1126 print-string-to-real-screen msg +1127 print-string-to-real-screen ": expected '" +1128 print-grapheme-to-real-screen expected-grapheme +1129 print-string-to-real-screen "' at (" +1130 print-int32-hex-to-real-screen row-idx +1131 print-string-to-real-screen ", " +1132 print-int32-hex-to-real-screen col-idx +1133 print-string-to-real-screen ") but observed '" +1134 print-grapheme-to-real-screen g +1135 print-string-to-real-screen "'\n" +1136 } +1137 $check-screen-row-in-blinking-from:compare-blinking: { +1138 var blinking?/eax: boolean <- screen-blink-at-idx? screen, idx +1139 compare blinking?, 1 +1140 { +1141 break-if-!= +1142 print-string-to-real-screen "." +1143 break $check-screen-row-in-blinking-from:compare-blinking +1144 } +1145 # otherwise print an error +1146 print-string-to-real-screen msg +1147 print-string-to-real-screen ": expected '" +1148 print-grapheme-to-real-screen expected-grapheme +1149 print-string-to-real-screen "' at (" +1150 print-int32-hex-to-real-screen row-idx +1151 print-string-to-real-screen ", " +1152 print-int32-hex-to-real-screen col-idx +1153 print-string-to-real-screen ") to be blinking\n" +1154 } +1155 } +1156 idx <- increment +1157 increment col-idx +1158 +1159 loop +1160 } +1161 } +1162 +1163 fn test-print-single-grapheme { +1164 var screen-on-stack: screen +1165 var screen/esi: (addr screen) <- address screen-on-stack +1166 initialize-screen screen, 5, 4 +1167 var c/eax: grapheme <- copy 0x61 # 'a' +1168 print-grapheme screen, c +1169 check-screen-row screen, 1, "a", "F - test-print-single-grapheme" # top-left corner of the screen +1170 } +1171 +1172 fn test-print-multiple-graphemes { +1173 var screen-on-stack: screen +1174 var screen/esi: (addr screen) <- address screen-on-stack +1175 initialize-screen screen, 5, 4 +1176 print-string screen, "Hello, 世界" +1177 check-screen-row screen, 1, "Hello, 世界", "F - test-print-multiple-graphemes" +1178 } +1179 +1180 fn test-move-cursor { +1181 var screen-on-stack: screen +1182 var screen/esi: (addr screen) <- address screen-on-stack +1183 initialize-screen screen, 5, 4 +1184 move-cursor screen, 1, 4 +1185 var c/eax: grapheme <- copy 0x61 # 'a' +1186 print-grapheme screen, c +1187 check-screen-row screen, 1, " a", "F - test-move-cursor" # top row +1188 } +1189 +1190 fn test-move-cursor-zeroes { +1191 var screen-on-stack: screen +1192 var screen/esi: (addr screen) <- address screen-on-stack +1193 initialize-screen screen, 5, 4 +1194 move-cursor screen, 0, 0 +1195 var c/eax: grapheme <- copy 0x61 # 'a' +1196 print-grapheme screen, c +1197 check-screen-row screen, 1, "a", "F - test-move-cursor-zeroes" # top-left corner of the screen +1198 } +1199 +1200 fn test-move-cursor-zero-row { +1201 var screen-on-stack: screen +1202 var screen/esi: (addr screen) <- address screen-on-stack +1203 initialize-screen screen, 5, 4 +1204 move-cursor screen, 0, 2 +1205 var c/eax: grapheme <- copy 0x61 # 'a' +1206 print-grapheme screen, c +1207 check-screen-row screen, 1, " a", "F - test-move-cursor-zero-row" # top row +1208 } +1209 +1210 fn test-move-cursor-zero-column { +1211 var screen-on-stack: screen +1212 var screen/esi: (addr screen) <- address screen-on-stack +1213 initialize-screen screen, 5, 4 +1214 move-cursor screen, 4, 0 +1215 var c/eax: grapheme <- copy 0x61 # 'a' +1216 print-grapheme screen, c +1217 check-screen-row screen, 4, "a", "F - test-move-cursor-zero-column" +1218 } +1219 +1220 fn test-move-cursor-negative-row { +1221 var screen-on-stack: screen +1222 var screen/esi: (addr screen) <- address screen-on-stack +1223 initialize-screen screen, 5, 3 +1224 move-cursor screen, -1, 2 # row -1 +1225 var c/eax: grapheme <- copy 0x61 # 'a' +1226 print-grapheme screen, c +1227 # no move +1228 check-screen-row screen, 1, "a", "F - test-move-cursor-negative-row" +1229 } +1230 +1231 fn test-move-cursor-negative-column { +1232 var screen-on-stack: screen +1233 var screen/esi: (addr screen) <- address screen-on-stack +1234 initialize-screen screen, 5, 3 +1235 move-cursor screen, 2, -1 # column -1 +1236 var c/eax: grapheme <- copy 0x61 # 'a' +1237 print-grapheme screen, c +1238 # no move +1239 check-screen-row screen, 1, "a", "F - test-move-cursor-negative-column" +1240 } +1241 +1242 fn test-move-cursor-column-too-large { +1243 var screen-on-stack: screen +1244 var screen/esi: (addr screen) <- address screen-on-stack +1245 initialize-screen screen, 5, 3 # 5 rows, 3 columns +1246 move-cursor screen, 1, 4 # row 1, column 4 (overflow) +1247 var c/eax: grapheme <- copy 0x61 # 'a' +1248 print-grapheme screen, c +1249 # top row is empty +1250 check-screen-row screen, 1, " ", "F - test-move-cursor-column-too-large" +1251 # character shows up on next row +1252 check-screen-row screen, 2, "a", "F - test-move-cursor-column-too-large" +1253 } +1254 +1255 fn test-move-cursor-column-too-large-saturates { +1256 var screen-on-stack: screen +1257 var screen/esi: (addr screen) <- address screen-on-stack +1258 initialize-screen screen, 5, 3 # 5 rows, 3 columns +1259 move-cursor screen, 1, 6 # row 1, column 6 (overflow) +1260 var c/eax: grapheme <- copy 0x61 # 'a' +1261 print-grapheme screen, c +1262 # top row is empty +1263 check-screen-row screen, 1, " ", "F - test-move-cursor-column-too-large-saturates" # top-left corner of the screen +1264 # character shows up at the start of next row +1265 check-screen-row screen, 2, "a", "F - test-move-cursor-column-too-large-saturates" # top-left corner of the screen +1266 } +1267 +1268 fn test-move-cursor-row-too-large { +1269 var screen-on-stack: screen +1270 var screen/esi: (addr screen) <- address screen-on-stack +1271 initialize-screen screen, 5, 3 # 5 rows +1272 move-cursor screen, 6, 2 # row 6 (overflow) +1273 var c/eax: grapheme <- copy 0x61 # 'a' +1274 print-grapheme screen, c +1275 # bottom row shows the character +1276 check-screen-row screen, 5, " a", "F - test-move-cursor-row-too-large" +1277 } +1278 +1279 fn test-move-cursor-row-too-large-saturates { +1280 var screen-on-stack: screen +1281 var screen/esi: (addr screen) <- address screen-on-stack +1282 initialize-screen screen, 5, 3 # 5 rows +1283 move-cursor screen, 9, 2 # row 9 (overflow) +1284 var c/eax: grapheme <- copy 0x61 # 'a' +1285 print-grapheme screen, c +1286 # bottom row shows the character +1287 check-screen-row screen, 5, " a", "F - test-move-cursor-row-too-large-saturates" +1288 } +1289 +1290 fn test-check-screen-row-from { +1291 var screen-on-stack: screen +1292 var screen/esi: (addr screen) <- address screen-on-stack +1293 initialize-screen screen, 5, 4 +1294 move-cursor screen, 1, 4 +1295 var c/eax: grapheme <- copy 0x61 # 'a' +1296 print-grapheme screen, c +1297 check-screen-row screen, 1, " a", "F - test-check-screen-row-from/baseline" +1298 check-screen-row-from screen, 1, 4, "a", "F - test-check-screen-row-from" +1299 } +1300 +1301 fn test-print-string-overflows-to-next-row { +1302 var screen-on-stack: screen +1303 var screen/esi: (addr screen) <- address screen-on-stack +1304 initialize-screen screen, 5, 4 # 5 rows, 4 columns +1305 print-string screen, "abcdefg" +1306 check-screen-row screen, 1, "abcd", "F - test-print-string-overflows-to-next-row" +1307 check-screen-row screen, 2, "efg", "F - test-print-string-overflows-to-next-row" +1308 } +1309 +1310 fn test-check-screen-scrolls-on-overflow { +1311 var screen-on-stack: screen +1312 var screen/esi: (addr screen) <- address screen-on-stack +1313 initialize-screen screen, 5, 4 +1314 # single character starting at bottom right +1315 move-cursor screen, 5, 4 +1316 var c/eax: grapheme <- copy 0x61 # 'a' +1317 print-grapheme screen, c +1318 check-screen-row-from screen, 5, 4, "a", "F - test-check-screen-scrolls-on-overflow/baseline" # bottom-right corner of the screen +1319 # multiple characters starting at bottom right +1320 move-cursor screen, 5, 4 +1321 print-string screen, "ab" +1322 # screen scrolled up one row +1323 #? check-screen-row screen, 1, " ", "F - test-check-screen-scrolls-on-overflow/x1" +1324 #? check-screen-row screen, 2, " ", "F - test-check-screen-scrolls-on-overflow/x2" +1325 #? check-screen-row screen, 3, " ", "F - test-check-screen-scrolls-on-overflow/x3" +1326 #? check-screen-row screen, 4, " a", "F - test-check-screen-scrolls-on-overflow/x4" +1327 #? check-screen-row screen, 5, "b ", "F - test-check-screen-scrolls-on-overflow/x5" +1328 check-screen-row-from screen, 4, 4, "a", "F - test-check-screen-scrolls-on-overflow/1" +1329 check-screen-row-from screen, 5, 1, "b", "F - test-check-screen-scrolls-on-overflow/2" +1330 } +1331 +1332 fn test-check-screen-color { +1333 var screen-on-stack: screen +1334 var screen/esi: (addr screen) <- address screen-on-stack +1335 initialize-screen screen, 5, 4 +1336 var c/eax: grapheme <- copy 0x61 # 'a' +1337 print-grapheme screen, c +1338 start-color screen, 1, 0 # foreground=1 +1339 c <- copy 0x62 # 'b' +1340 print-grapheme screen, c +1341 start-color screen, 0, 0 # back to default +1342 c <- copy 0x63 # 'c' +1343 print-grapheme screen, c +1344 check-screen-row-in-color screen, 0, 1, "a c", "F - test-check-screen-color" +1345 } +1346 +1347 fn test-check-screen-background-color { +1348 var screen-on-stack: screen +1349 var screen/esi: (addr screen) <- address screen-on-stack +1350 initialize-screen screen, 5, 4 +1351 var c/eax: grapheme <- copy 0x61 # 'a' +1352 print-grapheme screen, c +1353 start-color screen, 0, 1 # background=1 +1354 c <- copy 0x62 # 'b' +1355 print-grapheme screen, c +1356 start-color screen, 0, 7 # back to default +1357 c <- copy 0x63 # 'c' +1358 print-grapheme screen, c +1359 check-screen-row-in-background-color screen, 7, 1, "a c", "F - test-check-screen-background-color" +1360 } +1361 +1362 fn test-check-screen-bold { +1363 var screen-on-stack: screen +1364 var screen/esi: (addr screen) <- address screen-on-stack +1365 initialize-screen screen, 5, 4 +1366 start-bold screen +1367 var c/eax: grapheme <- copy 0x61 # 'a' +1368 print-grapheme screen, c +1369 reset-formatting screen +1370 c <- copy 0x62 # 'b' +1371 print-grapheme screen, c +1372 start-bold screen +1373 c <- copy 0x63 # 'c' +1374 print-grapheme screen, c +1375 check-screen-row-in-bold screen, 1, "a c", "F - test-check-screen-bold" +1376 } +1377 +1378 fn test-check-screen-underline { +1379 var screen-on-stack: screen +1380 var screen/esi: (addr screen) <- address screen-on-stack +1381 initialize-screen screen, 5, 4 +1382 start-underline screen +1383 var c/eax: grapheme <- copy 0x61 # 'a' +1384 print-grapheme screen, c +1385 reset-formatting screen +1386 c <- copy 0x62 # 'b' +1387 print-grapheme screen, c +1388 start-underline screen +1389 c <- copy 0x63 # 'c' +1390 print-grapheme screen, c +1391 check-screen-row-in-underline screen, 1, "a c", "F - test-check-screen-underline" +1392 } +1393 +1394 fn test-check-screen-reverse { +1395 var screen-on-stack: screen +1396 var screen/esi: (addr screen) <- address screen-on-stack +1397 initialize-screen screen, 5, 4 +1398 start-reverse-video screen +1399 var c/eax: grapheme <- copy 0x61 # 'a' +1400 print-grapheme screen, c +1401 reset-formatting screen +1402 c <- copy 0x62 # 'b' +1403 print-grapheme screen, c +1404 start-reverse-video screen +1405 c <- copy 0x63 # 'c' +1406 print-grapheme screen, c +1407 check-screen-row-in-reverse screen, 1, "a c", "F - test-check-screen-reverse" +1408 } +1409 +1410 fn test-check-screen-blinking { +1411 var screen-on-stack: screen +1412 var screen/esi: (addr screen) <- address screen-on-stack +1413 initialize-screen screen, 5, 4 +1414 start-blinking screen +1415 var c/eax: grapheme <- copy 0x61 # 'a' +1416 print-grapheme screen, c +1417 reset-formatting screen +1418 c <- copy 0x62 # 'b' +1419 print-grapheme screen, c +1420 start-blinking screen +1421 c <- copy 0x63 # 'c' +1422 print-grapheme screen, c +1423 check-screen-row-in-blinking screen, 1, "a c", "F - test-check-screen-blinking" +1424 } +1425 +1426 #? fn main -> _/ebx: int { +1427 #? #? test-check-screen-color +1428 #? run-tests +1429 #? return 0 +1430 #? } -- cgit 1.4.1-2-gfad0