From 91a5f3e10300fd84db26690095329592de0942d7 Mon Sep 17 00:00:00 2001 From: Kartik Agaram Date: Fri, 11 Sep 2020 00:59:56 -0700 Subject: 6774 --- html/apps/mu.subx.html | 336 ++++++++++++++++++++++++------------------------- 1 file changed, 168 insertions(+), 168 deletions(-) (limited to 'html/apps/mu.subx.html') diff --git a/html/apps/mu.subx.html b/html/apps/mu.subx.html index e96bafb5..37d71ac7 100644 --- a/html/apps/mu.subx.html +++ b/html/apps/mu.subx.html @@ -623,7 +623,7 @@ if ('onhashchange' in window) { 561 # convert 562 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 563 (flush _test-output-buffered-file) - 564 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 564 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 570 # check output 571 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-skeleton/0") 572 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-skeleton/1") @@ -655,7 +655,7 @@ if ('onhashchange' in window) { 598 # convert 599 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 600 (flush _test-output-buffered-file) - 601 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 601 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 607 # check first function 608 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-multiple-function-skeletons/0") 609 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-multiple-function-skeletons/1") @@ -694,7 +694,7 @@ if ('onhashchange' in window) { 642 # convert 643 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 644 (flush _test-output-buffered-file) - 645 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 645 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 651 # check output 652 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-arg/0") 653 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-arg/1") @@ -725,7 +725,7 @@ if ('onhashchange' in window) { 678 # convert 679 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 680 (flush _test-output-buffered-file) - 681 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 681 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 687 # check output 688 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-arg-and-body/0") 689 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-arg-and-body/1") @@ -761,7 +761,7 @@ if ('onhashchange' in window) { 719 # convert 720 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 721 (flush _test-output-buffered-file) - 722 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 722 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 728 # check output 729 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-distinguishes-args/0") 730 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-distinguishes-args/1") @@ -798,7 +798,7 @@ if ('onhashchange' in window) { 761 # convert 762 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 763 (flush _test-output-buffered-file) - 764 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 764 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 770 # check output 771 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-returns-result/0") 772 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-returns-result/1") @@ -836,7 +836,7 @@ if ('onhashchange' in window) { 804 # convert 805 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 806 (flush _test-output-buffered-file) - 807 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 807 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 813 # check output 814 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-literal-arg/0") 815 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-literal-arg/1") @@ -874,7 +874,7 @@ if ('onhashchange' in window) { 847 # convert 848 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 849 (flush _test-output-buffered-file) - 850 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 850 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 856 # check output 857 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-literal-arg-2/0") 858 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-literal-arg-2/1") @@ -915,7 +915,7 @@ if ('onhashchange' in window) { 893 # convert 894 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 895 (flush _test-output-buffered-file) - 896 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 896 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 902 # check output 903 (check-next-stream-line-equal _test-output-stream "main:" "F - test-convert-function-call-with-literal-arg/0") 904 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-literal-arg/1") @@ -966,7 +966,7 @@ if ('onhashchange' in window) { 949 # convert 950 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 951 (flush _test-output-buffered-file) - 952 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 952 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 958 # check output 959 (check-next-stream-line-equal _test-output-stream "main:" "F - test-convert-function-call-with-signature/0") 960 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-signature/1") @@ -1003,7 +1003,7 @@ if ('onhashchange' in window) { 991 # convert 992 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 993 (flush _test-output-buffered-file) - 994 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 994 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1000 # check output 1001 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-in-mem/0") 1002 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-in-mem/1") @@ -1052,7 +1052,7 @@ if ('onhashchange' in window) { 1045 89/<- %edx 4/r32/esp 1046 (flush _test-output-buffered-file) 1047 (flush _test-error-buffered-file) - 1048 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 1048 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1054 # check output 1055 (check-stream-equal _test-output-stream "" "F - test-convert-invalid-literal: output should be empty") 1056 (check-next-stream-line-equal _test-error-stream "fn foo: variable '1n' cannot begin with a digit (or do you have a typo in a number?)" "F - test-convert-invalid-literal: error message") @@ -1092,7 +1092,7 @@ if ('onhashchange' in window) { 1090 89/<- %edx 4/r32/esp 1091 (flush _test-output-buffered-file) 1092 (flush _test-error-buffered-file) - 1093 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 1093 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1099 # check output 1100 (check-stream-equal _test-output-stream "" "F - test-var-in-mem-has-no-initializer: output should be empty") 1101 (check-next-stream-line-equal _test-error-stream "fn foo: var x: variables on the stack can't take an initializer" "F - test-var-in-mem-has-no-initializer: error message") @@ -1121,7 +1121,7 @@ if ('onhashchange' in window) { 1124 # convert 1125 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 1126 (flush _test-output-buffered-file) - 1127 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 1127 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1133 # check output 1134 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-with-compound-type-in-mem/0") 1135 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-with-compound-type-in-mem/1") @@ -1160,7 +1160,7 @@ if ('onhashchange' in window) { 1168 # convert 1169 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 1170 (flush _test-output-buffered-file) - 1171 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 1171 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1177 # check output 1178 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-in-reg/0") 1179 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-in-reg/1") @@ -1200,7 +1200,7 @@ if ('onhashchange' in window) { 1213 # convert 1214 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 1215 (flush _test-output-buffered-file) - 1216 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 1216 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1222 # check output 1223 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-allocate/0") 1224 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-allocate/1") @@ -1250,7 +1250,7 @@ if ('onhashchange' in window) { 1268 89/<- %edx 4/r32/esp 1269 (flush _test-output-buffered-file) 1270 (flush _test-error-buffered-file) - 1271 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 1271 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1277 # check output 1278 (check-stream-equal _test-output-stream "" "F - test-initializer-in-hex: output should be empty") 1279 (check-next-stream-line-equal _test-error-stream "literal integers are always hex in Mu; either start '10' with a '0x' to be unambiguous, or convert it to decimal." "F - test-initializer-in-hex: error message") @@ -1280,7 +1280,7 @@ if ('onhashchange' in window) { 1303 # convert 1304 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 1305 (flush _test-output-buffered-file) - 1306 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 1306 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1312 # check output 1313 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-second-local-var-in-same-reg/0") 1314 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-second-local-var-in-same-reg/1") @@ -1333,7 +1333,7 @@ if ('onhashchange' in window) { 1361 89/<- %edx 4/r32/esp 1362 (flush _test-output-buffered-file) 1363 (flush _test-error-buffered-file) - 1364 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 1364 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1370 # check output 1371 (check-stream-equal _test-output-stream "" "F - test-read-clobbered-reg-var: output should be empty") 1372 (check-next-stream-line-equal _test-error-stream "fn foo: register ecx reads var 'x' after writing var 'y'" "F - test-read-clobbered-reg-var: error message") @@ -1364,7 +1364,7 @@ if ('onhashchange' in window) { 1397 # convert 1398 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 1399 (flush _test-output-buffered-file) - 1400 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 1400 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1406 # check output 1407 (check-next-stream-line-equal _test-output-stream "main:" "F - test-convert-function-call/0") 1408 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call/1") @@ -1416,7 +1416,7 @@ if ('onhashchange' in window) { 1454 # convert 1455 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 1456 (flush _test-output-buffered-file) - 1457 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 1457 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1463 # check output 1464 (check-next-stream-line-equal _test-output-stream "f:" "F - test-convert-function-call-with-inout-with-compound-type/0") 1465 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-inout-with-compound-type/1") @@ -1476,7 +1476,7 @@ if ('onhashchange' in window) { 1519 89/<- %edx 4/r32/esp 1520 (flush _test-output-buffered-file) 1521 (flush _test-error-buffered-file) - 1522 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 1522 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1528 # no error; types matched 1529 (check-stream-equal _test-error-stream "" "F - test-convert-function-call-with-inout-with-type-parameter: error stream should be empty") 1530 # don't bother checking the generated code; that's in the test 'test-local-clobbered-by-fn-output' below @@ -1516,7 +1516,7 @@ if ('onhashchange' in window) { 1564 89/<- %edx 4/r32/esp 1565 (flush _test-output-buffered-file) 1566 (flush _test-error-buffered-file) - 1567 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 1567 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1573 # check output 1574 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-incorrect-inout-type: output should be empty") 1575 (check-next-stream-line-equal _test-error-stream "fn f: call g: type for inout 'x' is not right" "F - test-convert-function-call-with-incorrect-inout-type: error message") @@ -1557,7 +1557,7 @@ if ('onhashchange' in window) { 1610 89/<- %edx 4/r32/esp 1611 (flush _test-output-buffered-file) 1612 (flush _test-error-buffered-file) - 1613 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 1613 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1619 # check output 1620 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-inout-with-incorrect-compound-type: output should be empty") 1621 (check-next-stream-line-equal _test-error-stream "fn f: call g: type for inout 'x' is not right" "F - test-convert-function-call-with-inout-with-incorrect-compound-type: error message") @@ -1598,7 +1598,7 @@ if ('onhashchange' in window) { 1656 89/<- %edx 4/r32/esp 1657 (flush _test-output-buffered-file) 1658 (flush _test-error-buffered-file) - 1659 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 1659 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1665 # no errors 1666 (check-stream-equal _test-error-stream "" "F - test-convert-function-call-with-inout-with-multiple-type-parameters: error stream should be empty") 1667 # don't bother checking the generated code @@ -1638,7 +1638,7 @@ if ('onhashchange' in window) { 1701 89/<- %edx 4/r32/esp 1702 (flush _test-output-buffered-file) 1703 (flush _test-error-buffered-file) - 1704 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 1704 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1710 # no errors 1711 (check-stream-equal _test-error-stream "" "F - test-type-parameter-matches-rest-of-type: error stream should be empty") 1712 # don't bother checking the generated code @@ -1679,7 +1679,7 @@ if ('onhashchange' in window) { 1747 89/<- %edx 4/r32/esp 1748 (flush _test-output-buffered-file) 1749 (flush _test-error-buffered-file) - 1750 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 1750 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1756 # check output 1757 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-inout-with-incompatible-type-parameters: output should be empty") 1758 (check-next-stream-line-equal _test-error-stream "fn f: call g: type for inout 'y' is not right" "F - test-convert-function-call-with-inout-with-incompatible-type-parameters: error message") @@ -1718,7 +1718,7 @@ if ('onhashchange' in window) { 1791 89/<- %edx 4/r32/esp 1792 (flush _test-output-buffered-file) 1793 (flush _test-error-buffered-file) - 1794 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 1794 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1800 # check output 1801 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-too-few-inouts: output should be empty") 1802 (check-next-stream-line-equal _test-error-stream "fn f: call g: too few inouts" "F - test-convert-function-call-with-too-few-inouts: error message") @@ -1759,7 +1759,7 @@ if ('onhashchange' in window) { 1837 89/<- %edx 4/r32/esp 1838 (flush _test-output-buffered-file) 1839 (flush _test-error-buffered-file) - 1840 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 1840 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1846 # check output 1847 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-too-many-inouts: output should be empty") 1848 (check-next-stream-line-equal _test-error-stream "fn f: call g: too many inouts" "F - test-convert-function-call-with-too-many-inouts: error message") @@ -1799,7 +1799,7 @@ if ('onhashchange' in window) { 1882 89/<- %edx 4/r32/esp 1883 (flush _test-output-buffered-file) 1884 (flush _test-error-buffered-file) - 1885 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 1885 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1891 # check output 1892 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-incorrect-output-type: output should be empty") 1893 (check-next-stream-line-equal _test-error-stream "fn f: call g: type for output 'x' is not right" "F - test-convert-function-call-with-incorrect-output-type: error message") @@ -1839,7 +1839,7 @@ if ('onhashchange' in window) { 1927 89/<- %edx 4/r32/esp 1928 (flush _test-output-buffered-file) 1929 (flush _test-error-buffered-file) - 1930 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 1930 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1936 # check output 1937 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-too-few-outputs: output should be empty") 1938 (check-next-stream-line-equal _test-error-stream "fn f: call g: too few outputs" "F - test-convert-function-call-with-too-few-outputs: error message") @@ -1879,7 +1879,7 @@ if ('onhashchange' in window) { 1972 89/<- %edx 4/r32/esp 1973 (flush _test-output-buffered-file) 1974 (flush _test-error-buffered-file) - 1975 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 1975 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1981 # check output 1982 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-too-many-outputs: output should be empty") 1983 (check-next-stream-line-equal _test-error-stream "fn f: call g: too many outputs" "F - test-convert-function-call-with-too-many-outputs: error message") @@ -1919,7 +1919,7 @@ if ('onhashchange' in window) { 2017 89/<- %edx 4/r32/esp 2018 (flush _test-output-buffered-file) 2019 (flush _test-error-buffered-file) - 2020 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 2020 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 2026 # check output 2027 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-incorrect-output-register: output should be empty") 2028 (check-next-stream-line-equal _test-error-stream "fn f: call g: register for output 'x' is not right" "F - test-convert-function-call-with-incorrect-output-register: error message") @@ -1947,7 +1947,7 @@ if ('onhashchange' in window) { 2050 # convert 2051 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 2052 (flush _test-output-buffered-file) - 2053 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2053 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 2059 # check output 2060 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-dereferenced/0") 2061 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-dereferenced/1") @@ -1992,7 +1992,7 @@ if ('onhashchange' in window) { 2100 # convert 2101 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 2102 (flush _test-output-buffered-file) - 2103 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2103 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 2109 # check output 2110 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-byte-operations/0") 2111 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-byte-operations/1") @@ -2041,7 +2041,7 @@ if ('onhashchange' in window) { 2154 # convert 2155 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 2156 (flush _test-output-buffered-file) - 2157 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2157 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 2163 # check output 2164 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-copy-byte-from-fn-arg/0") 2165 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-copy-byte-from-fn-arg/1") @@ -2081,7 +2081,7 @@ if ('onhashchange' in window) { 2199 # convert 2200 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 2201 (flush _test-output-buffered-file) - 2202 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2202 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 2208 # check output 2209 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-compare-register-with-literal/0") 2210 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-compare-register-with-literal/1") @@ -2131,7 +2131,7 @@ if ('onhashchange' in window) { 2254 89/<- %edx 4/r32/esp 2255 (flush _test-output-buffered-file) 2256 (flush _test-error-buffered-file) - 2257 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 2257 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 2263 # check output 2264 (check-stream-equal _test-output-stream "" "F - test-unknown-variable: output should be empty") 2265 (check-next-stream-line-equal _test-error-stream "fn foo: unknown variable 'x'" "F - test-unknown-variable: error message") @@ -2162,7 +2162,7 @@ if ('onhashchange' in window) { 2290 # convert 2291 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 2292 (flush _test-output-buffered-file) - 2293 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2293 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 2299 # check output 2300 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-in-block/0") 2301 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-in-block/1") @@ -2207,7 +2207,7 @@ if ('onhashchange' in window) { 2340 # convert 2341 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 2342 (flush _test-output-buffered-file) - 2343 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2343 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 2349 # check output 2350 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-in-named-block/0") 2351 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-in-named-block/1") @@ -2262,7 +2262,7 @@ if ('onhashchange' in window) { 2400 89/<- %edx 4/r32/esp 2401 (flush _test-output-buffered-file) 2402 (flush _test-error-buffered-file) - 2403 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 2403 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 2409 # check output 2410 (check-stream-equal _test-output-stream "" "F - test-unknown-variable-in-named-block: output should be empty") 2411 (check-next-stream-line-equal _test-error-stream "fn foo: unknown variable 'x'" "F - test-unknown-variable-in-named-block: error message") @@ -2290,7 +2290,7 @@ if ('onhashchange' in window) { 2433 # convert 2434 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 2435 (flush _test-output-buffered-file) - 2436 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2436 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 2442 # check output 2443 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-always-shadow-outermost-reg-vars-in-function/0") 2444 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-always-shadow-outermost-reg-vars-in-function/1") @@ -2331,7 +2331,7 @@ if ('onhashchange' in window) { 2479 # convert 2480 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 2481 (flush _test-output-buffered-file) - 2482 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2482 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 2488 # check output 2489 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-clobber-dead-local/0") 2490 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-clobber-dead-local/1") @@ -2378,7 +2378,7 @@ if ('onhashchange' in window) { 2531 # convert 2532 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 2533 (flush _test-output-buffered-file) - 2534 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2534 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 2540 # check output 2541 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-shadow-live-local/0") 2542 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-shadow-live-local/1") @@ -2428,7 +2428,7 @@ if ('onhashchange' in window) { 2586 # convert 2587 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 2588 (flush _test-output-buffered-file) - 2589 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2589 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 2595 # check output 2596 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-shadow-name/0") 2597 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-shadow-name/1") @@ -2479,7 +2479,7 @@ if ('onhashchange' in window) { 2642 # convert 2643 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 2644 (flush _test-output-buffered-file) - 2645 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2645 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 2651 # check output 2652 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-shadow-name-2/0") 2653 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-shadow-name-2/1") @@ -2530,7 +2530,7 @@ if ('onhashchange' in window) { 2698 # convert 2699 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 2700 (flush _test-output-buffered-file) - 2701 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2701 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 2707 # check output 2708 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-do-not-spill-same-register-in-block/0") 2709 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-do-not-spill-same-register-in-block/1") @@ -2572,7 +2572,7 @@ if ('onhashchange' in window) { 2745 # convert 2746 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 2747 (flush _test-output-buffered-file) - 2748 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2748 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 2754 # check output 2755 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-spill-different-register-in-block/0") 2756 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-spill-different-register-in-block/1") @@ -2618,7 +2618,7 @@ if ('onhashchange' in window) { 2796 # convert 2797 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 2798 (flush _test-output-buffered-file) - 2799 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2799 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 2805 # check output 2806 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-shadow-live-output/0") 2807 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-shadow-live-output/1") @@ -2674,7 +2674,7 @@ if ('onhashchange' in window) { 2857 89/<- %edx 4/r32/esp 2858 (flush _test-output-buffered-file) 2859 (flush _test-error-buffered-file) - 2860 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 2860 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 2866 # no error; we looked up 'y' correctly before pushing the binding for 'x' 2867 (check-stream-equal _test-error-stream "" "F - test-stmt-defines-output-in-same-register-as-inout: error stream should be empty") 2868 # don't bother checking the generated code; that's in the test 'test-local-clobbered-by-fn-output' below @@ -2701,7 +2701,7 @@ if ('onhashchange' in window) { 2889 # convert 2890 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 2891 (flush _test-output-buffered-file) - 2892 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2892 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 2898 # check output 2899 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-local-clobbered-by-fn-output/0") 2900 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-local-clobbered-by-fn-output/1") @@ -2739,7 +2739,7 @@ if ('onhashchange' in window) { 2932 # convert 2933 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 2934 (flush _test-output-buffered-file) - 2935 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2935 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 2941 # check output 2942 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-read-output/0") 2943 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-read-output/1") @@ -2781,7 +2781,7 @@ if ('onhashchange' in window) { 2979 # convert 2980 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 2981 (flush _test-output-buffered-file) - 2982 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2982 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 2988 # no error; defining 'out' didn't interfere with the reclamation of 'b' 2989 # check output 2990 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-fn-output-written-in-inner-block/0") @@ -2834,7 +2834,7 @@ if ('onhashchange' in window) { 3037 # convert 3038 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 3039 (flush _test-output-buffered-file) - 3040 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 3040 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 3046 # check output 3047 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-branches-in-block/0") 3048 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-branches-in-block/1") @@ -2888,7 +2888,7 @@ if ('onhashchange' in window) { 3096 # convert 3097 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 3098 (flush _test-output-buffered-file) - 3099 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 3099 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 3105 # check output 3106 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-branches-in-named-block/0") 3107 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-branches-in-named-block/1") @@ -2942,7 +2942,7 @@ if ('onhashchange' in window) { 3155 # convert 3156 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 3157 (flush _test-output-buffered-file) - 3158 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 3158 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 3164 # check output 3165 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-var-in-nested-block/0") 3166 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-var-in-nested-block/1") @@ -2994,7 +2994,7 @@ if ('onhashchange' in window) { 3212 # convert 3213 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 3214 (flush _test-output-buffered-file) - 3215 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 3215 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 3221 # check output 3222 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-multiple-vars-in-nested-blocks/0") 3223 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-multiple-vars-in-nested-blocks/1") @@ -3050,7 +3050,7 @@ if ('onhashchange' in window) { 3273 # convert 3274 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 3275 (flush _test-output-buffered-file) - 3276 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 3276 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 3282 # check output 3283 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-branches-and-local-vars/0") 3284 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-branches-and-local-vars/1") @@ -3104,7 +3104,7 @@ if ('onhashchange' in window) { 3332 # convert 3333 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 3334 (flush _test-output-buffered-file) - 3335 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 3335 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 3341 # check output 3342 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-conditional-loops-and-local-vars/0") 3343 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-conditional-loops-and-local-vars/1") @@ -3158,7 +3158,7 @@ if ('onhashchange' in window) { 3391 # convert 3392 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 3393 (flush _test-output-buffered-file) - 3394 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 3394 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 3400 # check output 3401 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-unconditional-loops-and-local-vars/0") 3402 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-unconditional-loops-and-local-vars/1") @@ -3206,7 +3206,7 @@ if ('onhashchange' in window) { 3444 # convert 3445 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 3446 (flush _test-output-buffered-file) - 3447 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 3447 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 3453 # check output 3454 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-branches-and-loops-and-local-vars/0") 3455 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-branches-and-loops-and-local-vars/1") @@ -3262,7 +3262,7 @@ if ('onhashchange' in window) { 3505 # convert 3506 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 3507 (flush _test-output-buffered-file) - 3508 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 3508 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 3514 # check output 3515 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/0") 3516 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/1") @@ -3323,7 +3323,7 @@ if ('onhashchange' in window) { 3571 # convert 3572 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 3573 (flush _test-output-buffered-file) - 3574 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 3574 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 3580 # check output 3581 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/0") 3582 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/1") @@ -3379,7 +3379,7 @@ if ('onhashchange' in window) { 3632 # convert 3633 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 3634 (flush _test-output-buffered-file) - 3635 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 3635 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 3641 # check output 3642 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/0") 3643 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/1") @@ -3431,7 +3431,7 @@ if ('onhashchange' in window) { 3689 # convert 3690 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 3691 (flush _test-output-buffered-file) - 3692 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 3692 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 3698 # check output 3699 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/0") 3700 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/1") @@ -3486,7 +3486,7 @@ if ('onhashchange' in window) { 3749 # convert 3750 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 3751 (flush _test-output-buffered-file) - 3752 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 3752 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 3758 # check output 3759 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/0") 3760 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/1") @@ -3542,7 +3542,7 @@ if ('onhashchange' in window) { 3810 # convert 3811 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 3812 (flush _test-output-buffered-file) - 3813 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 3813 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 3819 # check output 3820 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-unconditional-break-and-local-vars/0") 3821 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-unconditional-break-and-local-vars/1") @@ -3596,7 +3596,7 @@ if ('onhashchange' in window) { 3869 # convert 3870 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 3871 (flush _test-output-buffered-file) - 3872 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 3872 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 3878 # check output 3879 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/0") 3880 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/1") @@ -3645,7 +3645,7 @@ if ('onhashchange' in window) { 3923 # convert 3924 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 3925 (flush _test-output-buffered-file) - 3926 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 3926 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 3932 # check output 3933 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-array-var-in-mem/0") 3934 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-array-var-in-mem/1") @@ -3697,7 +3697,7 @@ if ('onhashchange' in window) { 3980 89/<- %edx 4/r32/esp 3981 (flush _test-output-buffered-file) 3982 (flush _test-error-buffered-file) - 3983 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 3983 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 3989 # check output 3990 (check-stream-equal _test-output-stream "" "F - test-array-size-in-hex: output should be empty") 3991 (check-next-stream-line-equal _test-error-stream "literal integers are always hex in Mu; either start '10' with a '0x' to be unambiguous, or convert it to decimal." "F - test-array-size-in-hex: error message") @@ -3726,7 +3726,7 @@ if ('onhashchange' in window) { 4014 # convert 4015 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 4016 (flush _test-output-buffered-file) - 4017 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 4017 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 4023 # check output 4024 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-populate/0") 4025 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-populate/1") @@ -3766,7 +3766,7 @@ if ('onhashchange' in window) { 4059 # convert 4060 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 4061 (flush _test-output-buffered-file) - 4062 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 4062 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 4068 # check output 4069 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-array-of-bytes-in-mem/0") 4070 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-array-of-bytes-in-mem/1") @@ -3808,7 +3808,7 @@ if ('onhashchange' in window) { 4106 # convert 4107 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 4108 (flush _test-output-buffered-file) - 4109 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 4109 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 4115 # check output 4116 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-address/0") 4117 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-address/1") @@ -3849,7 +3849,7 @@ if ('onhashchange' in window) { 4152 # convert 4153 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 4154 (flush _test-output-buffered-file) - 4155 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 4155 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 4161 # check output 4162 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array/0") 4163 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array/1") @@ -3891,7 +3891,7 @@ if ('onhashchange' in window) { 4199 # convert 4200 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 4201 (flush _test-output-buffered-file) - 4202 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 4202 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 4208 # check output 4209 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array-of-bytes/0") 4210 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array-of-bytes/1") @@ -3931,7 +3931,7 @@ if ('onhashchange' in window) { 4244 # convert 4245 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 4246 (flush _test-output-buffered-file) - 4247 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 4247 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 4253 # check output 4254 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array-on-stack/0") 4255 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array-on-stack/1") @@ -3987,8 +3987,8 @@ if ('onhashchange' in window) { 4305 89/<- %edx 4/r32/esp 4306 (flush _test-output-buffered-file) 4307 (flush _test-error-buffered-file) - 4308 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 4314 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 4308 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 4314 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 4320 (check-stream-equal _test-error-stream "" "F - test-reg-var-def-with-read-of-same-register: error stream should be empty") 4321 # check output 4322 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-reg-var-def-with-read-of-same-register/0") @@ -4034,7 +4034,7 @@ if ('onhashchange' in window) { 4362 # convert 4363 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 4364 (flush _test-output-buffered-file) - 4365 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 4365 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 4371 # check output 4372 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array/0") 4373 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array/1") @@ -4078,7 +4078,7 @@ if ('onhashchange' in window) { 4411 # convert 4412 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 4413 (flush _test-output-buffered-file) - 4414 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 4414 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 4420 # check output 4421 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-of-bytes/0") 4422 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-of-bytes/1") @@ -4121,7 +4121,7 @@ if ('onhashchange' in window) { 4459 # convert 4460 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 4461 (flush _test-output-buffered-file) - 4462 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 4462 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 4468 # check output 4469 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-with-literal/0") 4470 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-with-literal/1") @@ -4162,7 +4162,7 @@ if ('onhashchange' in window) { 4505 # convert 4506 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 4507 (flush _test-output-buffered-file) - 4508 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 4508 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 4514 # check output 4515 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-of-bytes-with-literal/0") 4516 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-of-bytes-with-literal/1") @@ -4204,7 +4204,7 @@ if ('onhashchange' in window) { 4552 # convert 4553 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 4554 (flush _test-output-buffered-file) - 4555 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 4555 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 4561 # check output 4562 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-on-stack/0") 4563 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-on-stack/1") @@ -4253,7 +4253,7 @@ if ('onhashchange' in window) { 4606 # convert 4607 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 4608 (flush _test-output-buffered-file) - 4609 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 4609 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 4615 # check output 4616 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-on-stack-with-literal/0") 4617 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-on-stack-with-literal/1") @@ -4301,7 +4301,7 @@ if ('onhashchange' in window) { 4659 # convert 4660 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 4661 (flush _test-output-buffered-file) - 4662 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 4662 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 4668 # check output 4669 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/0") 4670 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/1") @@ -4351,7 +4351,7 @@ if ('onhashchange' in window) { 4714 # convert 4715 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 4716 (flush _test-output-buffered-file) - 4717 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 4717 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 4723 # check output 4724 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-using-offset/0") 4725 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-using-offset/1") @@ -4397,7 +4397,7 @@ if ('onhashchange' in window) { 4765 # convert 4766 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 4767 (flush _test-output-buffered-file) - 4768 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 4768 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 4774 # check output 4775 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-of-bytes-using-offset/0") 4776 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-of-bytes-using-offset/1") @@ -4443,7 +4443,7 @@ if ('onhashchange' in window) { 4816 # convert 4817 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 4818 (flush _test-output-buffered-file) - 4819 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 4819 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 4825 # check output 4826 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-using-offset-on-stack/0") 4827 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-using-offset-on-stack/1") @@ -4490,7 +4490,7 @@ if ('onhashchange' in window) { 4868 # convert 4869 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 4870 (flush _test-output-buffered-file) - 4871 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 4871 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 4877 # check output 4878 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/0") 4879 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/1") @@ -4540,7 +4540,7 @@ if ('onhashchange' in window) { 4923 # convert 4924 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 4925 (flush _test-output-buffered-file) - 4926 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 4926 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 4932 # check output 4933 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-and-type-definition/0") 4934 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-and-type-definition/1") @@ -4593,7 +4593,7 @@ if ('onhashchange' in window) { 4981 89/<- %edx 4/r32/esp 4982 (flush _test-output-buffered-file) 4983 (flush _test-error-buffered-file) - 4984 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 4984 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 4990 # check output 4991 (check-stream-equal _test-output-stream "" "F - test-type-definition-with-array: output should be empty") 4992 (check-next-stream-line-equal _test-error-stream "type t: 'array' elements not allowed for now" "F - test-type-definition-with-array: error message") @@ -4632,7 +4632,7 @@ if ('onhashchange' in window) { 5025 89/<- %edx 4/r32/esp 5026 (flush _test-output-buffered-file) 5027 (flush _test-error-buffered-file) - 5028 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 5028 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 5034 # check output 5035 (check-stream-equal _test-output-stream "" "F - test-type-definition-with-addr: output should be empty") 5036 (check-next-stream-line-equal _test-error-stream "type t: 'addr' elements not allowed" "F - test-type-definition-with-addr: error message") @@ -4664,7 +4664,7 @@ if ('onhashchange' in window) { 5062 # convert 5063 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 5064 (flush _test-output-buffered-file) - 5065 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 5065 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 5071 # check output 5072 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-with-user-defined-type/0") 5073 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-with-user-defined-type/1") @@ -4708,7 +4708,7 @@ if ('onhashchange' in window) { 5111 # convert 5112 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 5113 (flush _test-output-buffered-file) - 5114 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 5114 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 5120 # check output 5121 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/0") 5122 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/1") @@ -4752,7 +4752,7 @@ if ('onhashchange' in window) { 5160 # convert 5161 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 5162 (flush _test-output-buffered-file) - 5163 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 5163 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 5169 # check output 5170 (check-next-stream-line-equal _test-output-stream "f:" "F - test-convert-function-call-with-arg-of-user-defined-type/0") 5171 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-arg-of-user-defined-type/1") @@ -4809,7 +4809,7 @@ if ('onhashchange' in window) { 5222 # convert 5223 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 5224 (flush _test-output-buffered-file) - 5225 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 5225 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 5231 # check output 5232 (check-next-stream-line-equal _test-output-stream "f:" "F - test-convert-function-call-with-arg-of-user-defined-type/0") 5233 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-arg-of-user-defined-type/1") @@ -4871,7 +4871,7 @@ if ('onhashchange' in window) { 5289 # convert 5290 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 5291 (flush _test-output-buffered-file) - 5292 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 5292 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 5298 # check output 5299 (check-next-stream-line-equal _test-output-stream "f:" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/0") 5300 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/1") @@ -4938,7 +4938,7 @@ if ('onhashchange' in window) { 5361 # convert 5362 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 5363 (flush _test-output-buffered-file) - 5364 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 5364 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 5370 # check output 5371 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-get-on-local-variable/0") 5372 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-get-on-local-variable/1") @@ -4988,7 +4988,7 @@ if ('onhashchange' in window) { 5416 # convert 5417 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 5418 (flush _test-output-buffered-file) - 5419 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 5419 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 5425 # check output 5426 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-get-on-function-argument/0") 5427 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-get-on-function-argument/1") @@ -5033,7 +5033,7 @@ if ('onhashchange' in window) { 5466 # convert 5467 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 5468 (flush _test-output-buffered-file) - 5469 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 5469 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 5475 # check output 5476 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-get-on-function-argument-with-known-type/0") 5477 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-get-on-function-argument-with-known-type/1") @@ -5086,7 +5086,7 @@ if ('onhashchange' in window) { 5524 89/<- %edx 4/r32/esp 5525 (flush _test-output-buffered-file) 5526 (flush _test-error-buffered-file) - 5527 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 5527 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 5533 # check output 5534 (check-stream-equal _test-output-stream "" "F - test-add-with-too-many-inouts: output should be empty") 5535 (check-next-stream-line-equal _test-error-stream "fn foo: stmt add: too many inouts; most primitives support at most two arguments, across inouts and outputs" "F - test-add-with-too-many-inouts: error message") @@ -5126,7 +5126,7 @@ if ('onhashchange' in window) { 5569 89/<- %edx 4/r32/esp 5570 (flush _test-output-buffered-file) 5571 (flush _test-error-buffered-file) - 5572 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 5572 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 5578 # check output 5579 (check-stream-equal _test-output-stream "" "F - test-add-with-too-many-inouts-2: output should be empty") 5580 (check-next-stream-line-equal _test-error-stream "fn foo: stmt add-to: too many inouts; most primitives support at most two arguments, across inouts and outputs" "F - test-add-with-too-many-inouts-2: error message") @@ -5168,7 +5168,7 @@ if ('onhashchange' in window) { 5616 89/<- %edx 4/r32/esp 5617 (flush _test-output-buffered-file) 5618 (flush _test-error-buffered-file) - 5619 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 5619 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 5625 # check output 5626 (check-stream-equal _test-output-stream "" "F - test-add-with-too-many-outputs: output should be empty") 5627 (check-next-stream-line-equal _test-error-stream "fn foo: stmt add: too many outputs; most primitives support at most one output" "F - test-add-with-too-many-outputs: error message") @@ -5208,7 +5208,7 @@ if ('onhashchange' in window) { 5661 89/<- %edx 4/r32/esp 5662 (flush _test-output-buffered-file) 5663 (flush _test-error-buffered-file) - 5664 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 5664 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 5670 # check output 5671 (check-stream-equal _test-output-stream "" "F - test-add-with-non-number: output should be empty") 5672 (check-next-stream-line-equal _test-error-stream "fn foo: stmt add: only non-addr scalar args permitted" "F - test-add-with-non-number: error message") @@ -5274,7 +5274,7 @@ if ('onhashchange' in window) { 5732 89/<- %edx 4/r32/esp 5733 (flush _test-output-buffered-file) 5734 (flush _test-error-buffered-file) - 5735 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 5735 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 5741 # check output 5742 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-field: output should be empty") 5743 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: type 't' has no member called 'y'" "F - test-get-with-wrong-field: error message") @@ -5314,7 +5314,7 @@ if ('onhashchange' in window) { 5777 89/<- %edx 4/r32/esp 5778 (flush _test-output-buffered-file) 5779 (flush _test-error-buffered-file) - 5780 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 5780 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 5786 # check output 5787 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-base-type: output should be empty") 5788 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: var 'a' must have a 'type' definition" "F - test-get-with-wrong-base-type: error message") @@ -5357,7 +5357,7 @@ if ('onhashchange' in window) { 5825 89/<- %edx 4/r32/esp 5826 (flush _test-output-buffered-file) 5827 (flush _test-error-buffered-file) - 5828 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 5828 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 5834 # check output 5835 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-base-type-2: output should be empty") 5836 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: var 'a' is an 'addr' type, and so must live in a register" "F - test-get-with-wrong-base-type-2: error message") @@ -5401,7 +5401,7 @@ if ('onhashchange' in window) { 5874 89/<- %edx 4/r32/esp 5875 (flush _test-output-buffered-file) 5876 (flush _test-error-buffered-file) - 5877 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 5877 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 5883 # check output 5884 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-offset-type: output should be empty") 5885 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: type 't' has no member called 'b'" "F - test-get-with-wrong-offset-type: error message") @@ -5445,7 +5445,7 @@ if ('onhashchange' in window) { 5923 89/<- %edx 4/r32/esp 5924 (flush _test-output-buffered-file) 5925 (flush _test-error-buffered-file) - 5926 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 5926 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 5932 # check output 5933 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-output-type: output should be empty") 5934 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: output 'c' is not in a register" "F - test-get-with-wrong-output-type: error message") @@ -5488,7 +5488,7 @@ if ('onhashchange' in window) { 5971 89/<- %edx 4/r32/esp 5972 (flush _test-output-buffered-file) 5973 (flush _test-error-buffered-file) - 5974 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 5974 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 5980 # check output 5981 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-output-type-2: output should be empty") 5982 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: output must be an address" "F - test-get-with-wrong-output-type-2: error message") @@ -5531,7 +5531,7 @@ if ('onhashchange' in window) { 6019 89/<- %edx 4/r32/esp 6020 (flush _test-output-buffered-file) 6021 (flush _test-error-buffered-file) - 6022 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 6022 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 6028 # check output 6029 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-output-type-3: output should be empty") 6030 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: output must be an address" "F - test-get-with-wrong-output-type-3: error message") @@ -5574,7 +5574,7 @@ if ('onhashchange' in window) { 6067 89/<- %edx 4/r32/esp 6068 (flush _test-output-buffered-file) 6069 (flush _test-error-buffered-file) - 6070 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 6070 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 6076 # check output 6077 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-output-type-4: output should be empty") 6078 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: wrong output type for member 'x' of type 't'" "F - test-get-with-wrong-output-type-4: error message") @@ -5643,7 +5643,7 @@ if ('onhashchange' in window) { 6141 89/<- %edx 4/r32/esp 6142 (flush _test-output-buffered-file) 6143 (flush _test-error-buffered-file) - 6144 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 6144 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 6150 # check output 6151 (check-stream-equal _test-output-stream "" "F - test-get-with-too-few-inouts: output should be empty") 6152 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: too few inouts (2 required)" "F - test-get-with-too-few-inouts: error message") @@ -5686,7 +5686,7 @@ if ('onhashchange' in window) { 6189 89/<- %edx 4/r32/esp 6190 (flush _test-output-buffered-file) 6191 (flush _test-error-buffered-file) - 6192 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 6192 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 6198 # check output 6199 (check-stream-equal _test-output-stream "" "F - test-get-with-too-many-inouts: output should be empty") 6200 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: too many inouts (2 required)" "F - test-get-with-too-many-inouts: error message") @@ -5729,7 +5729,7 @@ if ('onhashchange' in window) { 6237 89/<- %edx 4/r32/esp 6238 (flush _test-output-buffered-file) 6239 (flush _test-error-buffered-file) - 6240 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 6240 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 6246 # check output 6247 (check-stream-equal _test-output-stream "" "F - test-get-with-no-output: output should be empty") 6248 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: must have an output" "F - test-get-with-no-output: error message") @@ -5774,7 +5774,7 @@ if ('onhashchange' in window) { 6287 89/<- %edx 4/r32/esp 6288 (flush _test-output-buffered-file) 6289 (flush _test-error-buffered-file) - 6290 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 6290 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 6296 # check output 6297 (check-stream-equal _test-output-stream "" "F - test-get-with-too-many-outputs: output should be empty") 6298 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: too many outputs (1 required)" "F - test-get-with-too-many-outputs: error message") @@ -5808,7 +5808,7 @@ if ('onhashchange' in window) { 6326 # convert 6327 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 6328 (flush _test-output-buffered-file) - 6329 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 6329 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 6335 # check output 6336 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-array-of-user-defined-types/0") 6337 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-array-of-user-defined-types/1") @@ -5856,7 +5856,7 @@ if ('onhashchange' in window) { 6379 # convert 6380 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 6381 (flush _test-output-buffered-file) - 6382 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 6382 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 6388 # check output 6389 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array-of-user-defined-types-to-eax/0") 6390 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array-of-user-defined-types-to-eax/1") @@ -5912,7 +5912,7 @@ if ('onhashchange' in window) { 6440 # convert 6441 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 6442 (flush _test-output-buffered-file) - 6443 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 6443 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 6449 # check output 6450 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/0") 6451 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/1") @@ -5973,7 +5973,7 @@ if ('onhashchange' in window) { 6506 # convert 6507 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 6508 (flush _test-output-buffered-file) - 6509 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 6509 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 6515 # check output 6516 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array-of-user-defined-types-to-edx/0") 6517 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array-of-user-defined-types-to-edx/1") @@ -6034,7 +6034,7 @@ if ('onhashchange' in window) { 6572 # convert 6573 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 6574 (flush _test-output-buffered-file) - 6575 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 6575 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 6581 # check output 6582 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array-of-user-defined-types/0") 6583 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array-of-user-defined-types/1") @@ -6097,7 +6097,7 @@ if ('onhashchange' in window) { 6640 89/<- %edx 4/r32/esp 6641 (flush _test-output-buffered-file) 6642 (flush _test-error-buffered-file) - 6643 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 6643 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 6649 # check output 6650 (check-stream-equal _test-output-stream "" "F - test-index-with-non-array-atom-base-type: output should be empty") 6651 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: var 'a' is not an array" "F - test-index-with-non-array-atom-base-type: error message") @@ -6137,7 +6137,7 @@ if ('onhashchange' in window) { 6685 89/<- %edx 4/r32/esp 6686 (flush _test-output-buffered-file) 6687 (flush _test-error-buffered-file) - 6688 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 6688 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 6694 # check output 6695 (check-stream-equal _test-output-stream "" "F - test-index-with-non-array-compound-base-type: output should be empty") 6696 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: var 'a' is not an array" "F - test-index-with-non-array-compound-base-type: error message") @@ -6177,7 +6177,7 @@ if ('onhashchange' in window) { 6730 89/<- %edx 4/r32/esp 6731 (flush _test-output-buffered-file) 6732 (flush _test-error-buffered-file) - 6733 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 6733 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 6739 # check output 6740 (check-stream-equal _test-output-stream "" "F - test-index-with-non-array-compound-base-type-2: output should be empty") 6741 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: var 'a' is not an array" "F - test-index-with-non-array-compound-base-type-2: error message") @@ -6217,7 +6217,7 @@ if ('onhashchange' in window) { 6775 89/<- %edx 4/r32/esp 6776 (flush _test-output-buffered-file) 6777 (flush _test-error-buffered-file) - 6778 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 6778 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 6784 # check output 6785 (check-stream-equal _test-output-stream "" "F - test-index-with-array-atom-base-type: output should be empty") 6786 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: array 'a' must specify the type of its elements" "F - test-index-with-array-atom-base-type: error message") @@ -6257,7 +6257,7 @@ if ('onhashchange' in window) { 6820 89/<- %edx 4/r32/esp 6821 (flush _test-output-buffered-file) 6822 (flush _test-error-buffered-file) - 6823 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 6823 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 6829 # check output 6830 (check-stream-equal _test-output-stream "" "F - test-index-with-addr-base-on-stack: output should be empty") 6831 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: var 'a' is an addr to an array, and so must live in a register" "F - test-index-with-addr-base-on-stack: error message") @@ -6297,7 +6297,7 @@ if ('onhashchange' in window) { 6865 89/<- %edx 4/r32/esp 6866 (flush _test-output-buffered-file) 6867 (flush _test-error-buffered-file) - 6868 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 6868 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 6874 # check output 6875 (check-stream-equal _test-output-stream "" "F - test-index-with-array-base-in-register: output should be empty") 6876 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: var 'a' is an array, and so must live on the stack" "F - test-index-with-array-base-in-register: error message") @@ -6338,7 +6338,7 @@ if ('onhashchange' in window) { 6911 89/<- %edx 4/r32/esp 6912 (flush _test-output-buffered-file) 6913 (flush _test-error-buffered-file) - 6914 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 6914 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 6920 # check output 6921 (check-stream-equal _test-output-stream "" "F - test-index-with-wrong-index-type: output should be empty") 6922 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: second argument 'b' must be an int or offset" "F - test-index-with-wrong-index-type: error message") @@ -6379,7 +6379,7 @@ if ('onhashchange' in window) { 6957 89/<- %edx 4/r32/esp 6958 (flush _test-output-buffered-file) 6959 (flush _test-error-buffered-file) - 6960 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 6960 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 6966 # check output 6967 (check-stream-equal _test-output-stream "" "F - test-index-with-offset-atom-index-type: output should be empty") 6968 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: offset 'b' must specify the type of array elements" "F - test-index-with-offset-atom-index-type: error message") @@ -6420,7 +6420,7 @@ if ('onhashchange' in window) { 7003 89/<- %edx 4/r32/esp 7004 (flush _test-output-buffered-file) 7005 (flush _test-error-buffered-file) - 7006 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 7006 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 7012 # check output 7013 (check-stream-equal _test-output-stream "" "F - test-index-with-offset-on-stack: output should be empty") 7014 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: second argument 'b' must be in a register" "F - test-index-with-offset-on-stack: error message") @@ -6466,7 +6466,7 @@ if ('onhashchange' in window) { 7054 89/<- %edx 4/r32/esp 7055 (flush _test-output-buffered-file) 7056 (flush _test-error-buffered-file) - 7057 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 7057 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 7063 # check output 7064 (check-stream-equal _test-output-stream "" "F - test-index-needs-offset-type: output should be empty") 7065 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: cannot take an int for array 'a'; create an offset instead. See mu.md for details." "F - test-index-needs-offset-type: error message") @@ -6506,7 +6506,7 @@ if ('onhashchange' in window) { 7099 89/<- %edx 4/r32/esp 7100 (flush _test-output-buffered-file) 7101 (flush _test-error-buffered-file) - 7102 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 7102 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 7108 # check output 7109 (check-stream-equal _test-output-stream "" "F - test-index-with-output-not-address: output should be empty") 7110 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: output 'o' must be an address" "F - test-index-with-output-not-address: error message") @@ -6546,7 +6546,7 @@ if ('onhashchange' in window) { 7144 89/<- %edx 4/r32/esp 7145 (flush _test-output-buffered-file) 7146 (flush _test-error-buffered-file) - 7147 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 7147 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 7153 # check output 7154 (check-stream-equal _test-output-stream "" "F - test-index-with-output-not-address-2: output should be empty") 7155 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: output 'o' must be an address" "F - test-index-with-output-not-address-2: error message") @@ -6586,7 +6586,7 @@ if ('onhashchange' in window) { 7189 89/<- %edx 4/r32/esp 7190 (flush _test-output-buffered-file) 7191 (flush _test-error-buffered-file) - 7192 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 7192 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 7198 # check output 7199 (check-stream-equal _test-output-stream "" "F - test-index-with-wrong-output-type: output should be empty") 7200 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: output 'o' does not have the right type" "F - test-index-with-wrong-output-type: error message") @@ -6626,7 +6626,7 @@ if ('onhashchange' in window) { 7234 89/<- %edx 4/r32/esp 7235 (flush _test-output-buffered-file) 7236 (flush _test-error-buffered-file) - 7237 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 7237 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 7243 # check output 7244 (check-stream-equal _test-output-stream "" "F - test-index-with-wrong-output-compound-type: output should be empty") 7245 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: output 'o' does not have the right type" "F - test-index-with-wrong-output-compound-type: error message") @@ -6665,7 +6665,7 @@ if ('onhashchange' in window) { 7278 89/<- %edx 4/r32/esp 7279 (flush _test-output-buffered-file) 7280 (flush _test-error-buffered-file) - 7281 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 7281 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 7287 # check output 7288 (check-stream-equal _test-output-stream "" "F - test-index-with-no-inouts: output should be empty") 7289 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: too few inouts (2 required)" "F - test-index-with-no-inouts: error message") @@ -6705,7 +6705,7 @@ if ('onhashchange' in window) { 7323 89/<- %edx 4/r32/esp 7324 (flush _test-output-buffered-file) 7325 (flush _test-error-buffered-file) - 7326 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 7326 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 7332 # check output 7333 (check-stream-equal _test-output-stream "" "F - test-index-with-too-few-inouts: output should be empty") 7334 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: too few inouts (2 required)" "F - test-index-with-too-few-inouts: error message") @@ -6745,7 +6745,7 @@ if ('onhashchange' in window) { 7368 89/<- %edx 4/r32/esp 7369 (flush _test-output-buffered-file) 7370 (flush _test-error-buffered-file) - 7371 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 7371 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 7377 # check output 7378 (check-stream-equal _test-output-stream "" "F - test-index-with-too-many-inouts: output should be empty") 7379 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: too many inouts (2 required)" "F - test-index-with-too-many-inouts: error message") @@ -6785,7 +6785,7 @@ if ('onhashchange' in window) { 7413 89/<- %edx 4/r32/esp 7414 (flush _test-output-buffered-file) 7415 (flush _test-error-buffered-file) - 7416 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 7416 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 7422 # check output 7423 (check-stream-equal _test-output-stream "" "F - test-index-with-no-output: output should be empty") 7424 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: must have an output" "F - test-index-with-no-output: error message") @@ -6827,7 +6827,7 @@ if ('onhashchange' in window) { 7460 89/<- %edx 4/r32/esp 7461 (flush _test-output-buffered-file) 7462 (flush _test-error-buffered-file) - 7463 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 7463 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 7469 # check output 7470 (check-stream-equal _test-output-stream "" "F - test-index-with-too-many-outputs: output should be empty") 7471 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: too many outputs (1 required)" "F - test-index-with-too-many-outputs: error message") @@ -6928,7 +6928,7 @@ if ('onhashchange' in window) { 7566 # if (line->write == 0) break 7567 81 7/subop/compare *ecx 0/imm32 7568 0f 84/jump-if-= break/disp32 - 7569 +-- 6 lines: #? # dump line ------------------------------------------------------------------------------------------------------------------------------------------------------ + 7569 +-- 6 lines: #? # dump line --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 7575 (next-mu-token %ecx %edx) 7576 # if slice-empty?(word-slice) continue 7577 (slice-empty? %edx) # => eax @@ -11104,7 +11104,7 @@ if ('onhashchange' in window) { 11747 # if (line->write == 0) abort 11748 81 7/subop/compare *ecx 0/imm32 11749 0f 84/jump-if-= $populate-mu-type:error1/disp32 -11750 +-- 6 lines: #? # dump line ------------------------------------------------------------------------------------------------------------------------------------------------------ +11750 +-- 6 lines: #? # dump line --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 11756 (next-mu-token %ecx %edx) 11757 # if slice-empty?(word-slice) continue 11758 (slice-empty? %edx) # => eax @@ -11846,7 +11846,7 @@ if ('onhashchange' in window) { 12494 # if (curr == null) break 12495 3d/compare-eax-and 0/imm32 12496 0f 84/jump-if-= break/disp32 -12497 +-- 8 lines: #? # dump curr->name ------------------------------------------------------------------------------------------------------------------------------------------------ +12497 +-- 8 lines: #? # dump curr->name --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 12505 (check-mu-function %eax *(ebp+8) *(ebp+0xc)) 12506 # curr = lookup(curr->next) 12507 (lookup *(eax+0x20) *(eax+0x24)) # Function-next Function-next => eax @@ -14190,10 +14190,10 @@ if ('onhashchange' in window) { 14845 3d/compare-eax-and 0/imm32/false 14846 0f 84/jump-if-= break/disp32 14847 $emit-subx-stmt-list:branch-stmt: -14848 +-- 27 lines: # unconditional loops ----------------------------------------------------------------------------------------------------------------------------------------------------- -14875 +-- 16 lines: # unconditional breaks ---------------------------------------------------------------------------------------------------------------------------------------------------- -14891 +-- 38 lines: # simple conditional branches without a target ---------------------------------------------------------------------------------------------------------------------------- -14929 +-- 19 lines: # conditional branches with an explicit target ---------------------------------------------------------------------------------------------------------------------------- +14848 +-- 27 lines: # unconditional loops -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +14875 +-- 16 lines: # unconditional breaks ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +14891 +-- 38 lines: # simple conditional branches without a target ------------------------------------------------------------------------------------------------------------------------------------------------------- +14929 +-- 19 lines: # conditional branches with an explicit target ------------------------------------------------------------------------------------------------------------------------------------------------------- 14948 } 14949 $emit-subx-stmt-list:1-to-1: 14950 (emit-subx-stmt *(ebp+8) %ecx Primitives *(ebp+0x18) *(ebp+0x1c)) @@ -20889,7 +20889,7 @@ if ('onhashchange' in window) { 21640 c7 0/subop/copy *Curr-block-depth 0/imm32 21641 (emit-subx-stmt _test-output-buffered-file %esi %ebx Stderr 0) 21642 (flush _test-output-buffered-file) -21643 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- +21643 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 21649 # check output 21650 (check-next-stream-line-equal _test-output-stream "ff 0/subop/increment *(ebp+0xfffffff8)" "F - test-emit-subx-stmt-primitive") 21651 # . epilogue @@ -21029,7 +21029,7 @@ if ('onhashchange' in window) { 21785 c7 0/subop/copy *Curr-block-depth 0/imm32 21786 (emit-subx-stmt _test-output-buffered-file %esi %ebx Stderr 0) 21787 (flush _test-output-buffered-file) -21788 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- +21788 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 21794 # check output 21795 (check-next-stream-line-equal _test-output-stream "ff 0/subop/increment %eax" "F - test-emit-subx-stmt-primitive-register") 21796 # . epilogue @@ -21200,7 +21200,7 @@ if ('onhashchange' in window) { 21961 c7 0/subop/copy *Curr-block-depth 0/imm32 21962 (emit-subx-stmt _test-output-buffered-file %esi %ebx Stderr 0) 21963 (flush _test-output-buffered-file) -21964 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- +21964 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 21970 # check output 21971 (check-next-stream-line-equal _test-output-stream "ff 0/subop/increment %eax" "F - test-emit-subx-stmt-select-primitive") 21972 # . epilogue @@ -21371,7 +21371,7 @@ if ('onhashchange' in window) { 22137 c7 0/subop/copy *Curr-block-depth 0/imm32 22138 (emit-subx-stmt _test-output-buffered-file %esi %ebx Stderr 0) 22139 (flush _test-output-buffered-file) -22140 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- +22140 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 22146 # check output 22147 (check-next-stream-line-equal _test-output-stream "ff 0/subop/increment %eax" "F - test-emit-subx-stmt-select-primitive-2") 22148 # . epilogue @@ -21454,7 +21454,7 @@ if ('onhashchange' in window) { 22225 c7 0/subop/copy *Curr-block-depth 0/imm32 22226 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) 22227 (flush _test-output-buffered-file) -22228 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- +22228 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 22234 # check output 22235 (check-next-stream-line-equal _test-output-stream "40/increment-eax" "F - test-increment-register") 22236 # . epilogue @@ -21560,7 +21560,7 @@ if ('onhashchange' in window) { 22336 c7 0/subop/copy *Curr-block-depth 0/imm32 22337 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) 22338 (flush _test-output-buffered-file) -22339 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- +22339 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 22345 # check output 22346 (check-next-stream-line-equal _test-output-stream "01/add-to %eax 0x00000001/r32" "F - test-add-reg-to-reg") 22347 # . epilogue @@ -21661,7 +21661,7 @@ if ('onhashchange' in window) { 22442 c7 0/subop/copy *Curr-block-depth 0/imm32 22443 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) 22444 (flush _test-output-buffered-file) -22445 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- +22445 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 22451 # check output 22452 (check-next-stream-line-equal _test-output-stream "01/add-to *(ebp+0x00000008) 0x00000001/r32" "F - test-add-reg-to-mem") 22453 # . epilogue @@ -21763,7 +21763,7 @@ if ('onhashchange' in window) { 22549 c7 0/subop/copy *Curr-block-depth 0/imm32 22550 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) 22551 (flush _test-output-buffered-file) -22552 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- +22552 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 22558 # check output 22559 (check-next-stream-line-equal _test-output-stream "03/add *(ebp+0x00000008) 0x00000000/r32" "F - test-add-mem-to-reg") 22560 # . epilogue @@ -21874,7 +21874,7 @@ if ('onhashchange' in window) { 22665 c7 0/subop/copy *Curr-block-depth 0/imm32 22666 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) 22667 (flush _test-output-buffered-file) -22668 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- +22668 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 22674 # check output 22675 (check-next-stream-line-equal _test-output-stream "05/add-to-eax 0x34/imm32" "F - test-add-literal-to-eax") 22676 # . epilogue @@ -21985,7 +21985,7 @@ if ('onhashchange' in window) { 22781 c7 0/subop/copy *Curr-block-depth 0/imm32 22782 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) 22783 (flush _test-output-buffered-file) -22784 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- +22784 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 22790 # check output 22791 (check-next-stream-line-equal _test-output-stream "81 0/subop/add %ecx 0x34/imm32" "F - test-add-literal-to-reg") 22792 # . epilogue @@ -22091,7 +22091,7 @@ if ('onhashchange' in window) { 22892 c7 0/subop/copy *Curr-block-depth 0/imm32 22893 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) 22894 (flush _test-output-buffered-file) -22895 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- +22895 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 22901 # check output 22902 (check-next-stream-line-equal _test-output-stream "81 0/subop/add *(ebp+0x00000008) 0x34/imm32" "F - test-add-literal-to-mem") 22903 # . epilogue @@ -22202,7 +22202,7 @@ if ('onhashchange' in window) { 23008 c7 0/subop/copy *Curr-block-depth 0/imm32 23009 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) 23010 (flush _test-output-buffered-file) -23011 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- +23011 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 23017 # check output 23018 (check-next-stream-line-equal _test-output-stream "c1/shift 4/subop/left %ecx 2/imm8" "F - test-shift-reg-by-literal") 23019 # . epilogue @@ -22308,7 +22308,7 @@ if ('onhashchange' in window) { 23119 c7 0/subop/copy *Curr-block-depth 0/imm32 23120 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) 23121 (flush _test-output-buffered-file) -23122 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- +23122 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 23128 # check output 23129 (check-next-stream-line-equal _test-output-stream "c1/shift 4/subop/left *(ebp+0x00000008) 3/imm8" "F - test-shift-mem-by-literal") 23130 # . epilogue @@ -22413,7 +22413,7 @@ if ('onhashchange' in window) { 23229 c7 0/subop/copy *Curr-block-depth 0/imm32 23230 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) 23231 (flush _test-output-buffered-file) -23232 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- +23232 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 23238 # check output 23239 (check-next-stream-line-equal _test-output-stream "39/compare-> %ecx 0x00000000/r32" "F - test-compare-reg-with-reg") 23240 # . epilogue @@ -22514,7 +22514,7 @@ if ('onhashchange' in window) { 23335 c7 0/subop/copy *Curr-block-depth 0/imm32 23336 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) 23337 (flush _test-output-buffered-file) -23338 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- +23338 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 23344 # check output 23345 (check-next-stream-line-equal _test-output-stream "39/compare-> *(ebp+0x00000008) 0x00000000/r32" "F - test-compare-mem-with-reg") 23346 # . epilogue @@ -22615,7 +22615,7 @@ if ('onhashchange' in window) { 23441 c7 0/subop/copy *Curr-block-depth 0/imm32 23442 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) 23443 (flush _test-output-buffered-file) -23444 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- +23444 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 23450 # check output 23451 (check-next-stream-line-equal _test-output-stream "3b/compare<- *(ebp+0x00000008) 0x00000000/r32" "F - test-compare-reg-with-mem") 23452 # . epilogue @@ -22721,7 +22721,7 @@ if ('onhashchange' in window) { 23552 c7 0/subop/copy *Curr-block-depth 0/imm32 23553 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) 23554 (flush _test-output-buffered-file) -23555 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- +23555 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 23561 # check output 23562 (check-next-stream-line-equal _test-output-stream "81 7/subop/compare *(ebp+0x00000008) 0x34/imm32" "F - test-compare-mem-with-literal") 23563 # . epilogue @@ -22831,7 +22831,7 @@ if ('onhashchange' in window) { 23667 c7 0/subop/copy *Curr-block-depth 0/imm32 23668 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) 23669 (flush _test-output-buffered-file) -23670 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- +23670 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 23676 # check output 23677 (check-next-stream-line-equal _test-output-stream "3d/compare-eax-with 0x34/imm32" "F - test-compare-eax-with-literal") 23678 # . epilogue @@ -22941,7 +22941,7 @@ if ('onhashchange' in window) { 23782 c7 0/subop/copy *Curr-block-depth 0/imm32 23783 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) 23784 (flush _test-output-buffered-file) -23785 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- +23785 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 23791 # check output 23792 (check-next-stream-line-equal _test-output-stream "81 7/subop/compare %ecx 0x34/imm32" "F - test-compare-reg-with-literal") 23793 # . epilogue @@ -23024,7 +23024,7 @@ if ('onhashchange' in window) { 23870 c7 0/subop/copy *Curr-block-depth 0/imm32 23871 (emit-subx-stmt _test-output-buffered-file %esi 0 Stderr 0) 23872 (flush _test-output-buffered-file) -23873 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- +23873 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 23879 # check output 23880 (check-next-stream-line-equal _test-output-stream "(f *(ebp+0xfffffff8))" "F - test-emit-subx-stmt-function-call") 23881 # . epilogue @@ -23096,7 +23096,7 @@ if ('onhashchange' in window) { 23947 c7 0/subop/copy *Curr-block-depth 0/imm32 23948 (emit-subx-stmt _test-output-buffered-file %esi 0 %ebx Stderr 0) 23949 (flush _test-output-buffered-file) -23950 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- +23950 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 23956 # check output 23957 (check-next-stream-line-equal _test-output-stream "(f 0x34)" "F - test-emit-subx-stmt-function-call-with-literal-arg") 23958 # . epilogue -- cgit 1.4.1-2-gfad0