├── .gitignore ├── LICENSE ├── README.md ├── asm └── assembleur.py ├── code_rs ├── .gitignore ├── build.sh ├── make.sh └── test │ ├── .cargo │ └── config.toml │ ├── Cargo.lock │ ├── Cargo.toml │ ├── a.out │ ├── asm.bin │ ├── asm.hex │ ├── basic │ ├── fib.bas │ └── load.sh │ ├── bin │ ├── .gitignore │ ├── asm.hex │ ├── ball.bin │ ├── ball.raw │ ├── ball.s │ ├── basic.bin │ ├── basic.raw │ ├── basic.s │ ├── calckeyb.bin │ ├── calckeyb.log │ ├── calckeyb.raw │ ├── calckeyb.s │ ├── calckeyb2.s │ ├── calckeyb_ok.s │ ├── calculator.bin │ ├── calculator.s │ ├── digital_out.raw │ ├── lisp.bin │ ├── lisp.raw │ ├── lisp.s │ ├── midi.bin │ ├── midi.raw │ ├── midi.s │ ├── parmweb.bin │ ├── parmweb.raw │ ├── parmweb.s │ ├── plotter.bin │ ├── plotter.raw │ ├── plotter.s │ ├── simpletelnet.bin │ ├── simpletelnet.raw │ ├── simpletelnet.s │ ├── telnet_video.bin │ ├── telnet_video.raw │ ├── telnet_video.s │ ├── test.bin │ ├── test.s │ ├── testdyn.bin │ ├── testdyn.raw │ ├── testdyn.s │ ├── testdyn22.s │ ├── testfp.bin │ ├── testfp.s │ ├── testrgb.bin │ ├── testrgb.s │ └── trampo.s │ ├── link.x │ ├── midi │ ├── elise.mid │ ├── fifth.mid │ ├── load.sh │ ├── lune.mid │ ├── ob_la_di.mid │ ├── rain.mid │ └── zelda.mid │ ├── rust-toolchain.toml │ ├── scheme │ ├── accum.rkt │ ├── case.ss │ ├── compose.rkt │ ├── depth_flat.rkt │ ├── env.ss │ ├── eval.ss │ ├── fibstream.rkt │ ├── fold.rkt │ ├── gallesio.ss │ ├── hanoi.rkt │ ├── infer.rkt │ ├── load.sh │ ├── macro_case.rkt │ ├── macro_def_func.rkt │ ├── macro_for.rkt │ ├── macro_lambda_star.rkt │ ├── macro_named_let.rkt │ ├── macro_oop.rkt │ ├── macro_record.rkt │ ├── macro_stack.rkt │ ├── macro_trace.rkt │ ├── macro_while.rkt │ ├── named_let.rkt │ ├── prog1.rkt │ ├── quasiquote.ss │ ├── tco.rkt │ ├── test_cond.rkt │ ├── test_dot.ss │ └── trees.rkt │ ├── src │ ├── ball.rs │ ├── basic.rs │ ├── basic.rs.bak │ ├── basic.rs.old │ ├── calckeyb.rs │ ├── calculator.rs │ ├── lisp │ │ ├── env.rs │ │ ├── eval.rs │ │ ├── eval │ │ │ ├── builtins.rs │ │ │ ├── builtins │ │ │ │ ├── booleans.rs │ │ │ │ ├── boxes.rs │ │ │ │ ├── debugging.rs │ │ │ │ ├── equality.rs │ │ │ │ ├── exceptions.rs │ │ │ │ ├── hash_tables.rs │ │ │ │ ├── io.rs │ │ │ │ ├── numbers.rs │ │ │ │ ├── pairs_lists.rs │ │ │ │ ├── procedures.rs │ │ │ │ ├── promises.rs │ │ │ │ ├── strings.rs │ │ │ │ ├── symbols.rs │ │ │ │ ├── syntax.rs │ │ │ │ └── void.rs │ │ │ ├── call.rs │ │ │ ├── conditionals.rs │ │ │ ├── forms.rs │ │ │ ├── lambda.rs │ │ │ ├── let.rs │ │ │ └── quote.rs │ │ ├── mod.rs │ │ ├── parse.rs │ │ └── val.rs │ ├── lisprepl.rs │ ├── main.rs │ ├── midi.rs │ ├── parm │ │ ├── control.rs │ │ ├── float.rs │ │ ├── heap.rs │ │ ├── heap.rs.old │ │ ├── heap │ │ │ ├── budmap.rs │ │ │ ├── string.rs │ │ │ └── vec.rs │ │ ├── keyb.rs │ │ ├── math.rs │ │ ├── midi.rs │ │ ├── mmio.rs │ │ ├── mod.rs │ │ ├── rand.rs │ │ ├── screen.rs │ │ ├── screen │ │ │ └── tty.rs │ │ ├── telnet.rs │ │ ├── tty.rs │ │ ├── util.rs │ │ └── util │ │ │ └── fxhash.rs │ ├── parmweb.rs │ ├── plotter.rs │ ├── simpletelnet.rs │ ├── telnet_video.rs │ ├── testdyn.rs │ ├── testdyn.rs.old │ ├── testfp.rs │ ├── testrgb.rs │ └── vendor │ │ ├── midly │ │ ├── LICENSE │ │ ├── error.rs │ │ ├── event.rs │ │ ├── io.rs │ │ ├── live.rs │ │ ├── mod.rs │ │ ├── primitive.rs │ │ ├── riff.rs │ │ ├── smf.rs │ │ └── stream.rs │ │ └── mod.rs │ ├── telnetrunner.sh │ ├── telnetrunner_video.sh │ ├── test.bin │ ├── test.s │ └── testfp.out ├── digital_project ├── ALU.dig ├── BCD.dig ├── BancDeRegistres.dig ├── Conditional.dig ├── Flags_APSR.dig ├── LoToHi.dig ├── Load_Address.dig ├── http.dig ├── machine.dig ├── machine.svg ├── machine_old.dig ├── midi.dig ├── sub.svg ├── terminal.dig └── vgatest.dig ├── lca_expanded.bin ├── lca_expanded.raw ├── lca_expanded.s ├── lca_programme.bin ├── lca_programme.o └── lca_project ├── README.md ├── build_linux.sh ├── build_parm.sh ├── lca_expanded.bin ├── lca_expanded.raw ├── lca_expanded.s ├── lca_lib.S ├── lca_lib_linux.S ├── lca_lib_parm.S └── lca_programme.S /.gitignore: -------------------------------------------------------------------------------- 1 | **.swp 2 | code_c/draft 3 | /logisim_project/logisim-evolution.jar 4 | .idea 5 | out/ 6 | *.gz 7 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2017 Nassim Bounouas & Pierre-Emmanuel Novac 4 | Copyright (c) 2021 Tom Niget, Thomas Prévost, Emmeline Vouriot 5 | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy 7 | of this software and associated documentation files (the "Software"), to deal 8 | in the Software without restriction, including without limitation the rights 9 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 10 | copies of the Software, and to permit persons to whom the Software is 11 | furnished to do so, subject to the following conditions: 12 | 13 | The above copyright notice and this permission notice shall be included in all 14 | copies or substantial portions of the Software. 15 | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 19 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 21 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 22 | SOFTWARE. 23 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # ARM CPU with things 2 | 3 | ## Quick setup 4 | 5 | *note:* this assumes you're running a Linux-like OS. On Windows, WSL (1 or 2) works perfectly. 6 | 7 | 1. Download Digital from the [GitHub repo](https://github.com/hneemann/Digital/releases) 8 | 2. [Optional] Download the patched .jar with enhanced Telnet support from [here](https://domino.zdimension.fr/poubelle/digital.jar) and place it in the Digital folder 9 | 3. If you don't have Rust, install Rust (using [rustup](https://rustup.rs/)) and install the nightly toolchain (`rustup toolchain install nightly`) 10 | 4. Run Digital 11 | 5. Open the circuit digital_project/machine.dig 12 | 6. Open a shell in the code_rs/test directory 13 | 7. Build one of the example programs by doing `../make.sh NAME -q` where `NAME` is a file in the code_rs/test/src directory (e.g. `basic`, `plotter`, ...) 14 | 8. Run the circuit in Digital by enabling the clock (Ctrl+K) 15 | -------------------------------------------------------------------------------- /code_rs/.gitignore: -------------------------------------------------------------------------------- 1 | */target/* 2 | -------------------------------------------------------------------------------- /code_rs/build.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | PROJ_NAME=$1 4 | 5 | if [ -z "$PROJ_NAME" ]; then 6 | echo "Usage: ./build.sh " 7 | exit 1 8 | fi 9 | 10 | if ! pushd "$PROJ_NAME"; then 11 | echo "Project directory not found" 12 | exit 1 13 | fi 14 | 15 | if ! cargo rustc --release -- --emit asm; then 16 | echo "Cargo rustc failed" 17 | exit 1 18 | fi 19 | 20 | sed '/debug_abbrev/q' target/thumbv6m-none-eabi/release/deps/*.s > asm.s 21 | 22 | ../../asm/assembleur.py asm.s 23 | -------------------------------------------------------------------------------- /code_rs/make.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | NAME=$1 4 | 5 | if [[ "$*" == *"--disasm"* ]]; then 6 | if [ -z $NAME ]; then 7 | cargo build --release 8 | NAME=$(basename $(pwd)) 9 | else 10 | cargo build --release --bin $NAME 11 | fi 12 | if [ $? -ne 0 ]; then 13 | echo "Cargo build failed" 14 | exit 1 15 | fi 16 | BIN=target/thumbv6m-none-eabi/release/$NAME 17 | arm-none-eabi-objdump -d $BIN 18 | mkdir -p bin 19 | #echo "run:" > bin/$NAME.s 20 | arm-none-eabi-objdump -d $BIN | grep '[0-9a-f]:' | grep -v "file format" | cut -f1,3- | sed 's/<.*//' >bin/$NAME.s 21 | pushd bin 22 | ../../../asm/assembleur.py $NAME.s 23 | arm-none-eabi-objcopy -O binary --only-section=.data ../$BIN >(od -An -x >>$NAME.bin) 24 | else 25 | RUSTC_ARGS="--emit asm -C relocation-model=static -v" 26 | if [ -z $NAME ]; then 27 | cargo rustc --release -- $RUSTC_ARGS 28 | NAME=$(basename $(pwd)) 29 | else 30 | cargo rustc --bin $NAME --release -- $RUSTC_ARGS 31 | fi 32 | 33 | if [ $? -ne 0 ]; then 34 | echo "Cargo build failed" 35 | exit 1 36 | fi 37 | 38 | ASM=(target/thumbv6m-none-eabi/release/deps/"$NAME"*.s) 39 | 40 | cat $ASM >bin/$NAME.s 41 | 42 | pushd bin 43 | ../../../asm/assembleur.py $NAME.s $2 $3 $4 44 | cp $NAME.raw digital_out.raw 45 | fi 46 | -------------------------------------------------------------------------------- /code_rs/test/.cargo/config.toml: -------------------------------------------------------------------------------- 1 | [build] 2 | target = "thumbv6m-none-eabi" 3 | 4 | [target.thumbv6m-none-eabi] 5 | rustflags = [ 6 | "-C", "link-arg=-Tlink.x", 7 | ] -------------------------------------------------------------------------------- /code_rs/test/Cargo.lock: -------------------------------------------------------------------------------- 1 | # This file is automatically @generated by Cargo. 2 | # It is not intended for manual editing. 3 | version = 3 4 | 5 | [[package]] 6 | name = "convert_case" 7 | version = "0.4.0" 8 | source = "registry+https://github.com/rust-lang/crates.io-index" 9 | checksum = "6245d59a3e82a7fc217c5828a6692dbc6dfb63a0c8c90495621f7b9d79704a0e" 10 | 11 | [[package]] 12 | name = "derive_more" 13 | version = "0.99.17" 14 | source = "registry+https://github.com/rust-lang/crates.io-index" 15 | checksum = "4fb810d30a7c1953f91334de7244731fc3f3c10d7fe163338a35b9f640960321" 16 | dependencies = [ 17 | "convert_case", 18 | "proc-macro2", 19 | "quote", 20 | "rustc_version", 21 | "syn", 22 | ] 23 | 24 | [[package]] 25 | name = "indoc" 26 | version = "1.0.6" 27 | source = "registry+https://github.com/rust-lang/crates.io-index" 28 | checksum = "05a0bd019339e5d968b37855180087b7b9d512c5046fbd244cf8c95687927d6e" 29 | 30 | [[package]] 31 | name = "paste" 32 | version = "1.0.9" 33 | source = "registry+https://github.com/rust-lang/crates.io-index" 34 | checksum = "b1de2e551fb905ac83f73f7aedf2f0cb4a0da7e35efa24a202a936269f1f18e1" 35 | 36 | [[package]] 37 | name = "proc-macro2" 38 | version = "1.0.43" 39 | source = "registry+https://github.com/rust-lang/crates.io-index" 40 | checksum = "0a2ca2c61bc9f3d74d2886294ab7b9853abd9c1ad903a3ac7815c58989bb7bab" 41 | dependencies = [ 42 | "unicode-ident", 43 | ] 44 | 45 | [[package]] 46 | name = "quote" 47 | version = "1.0.21" 48 | source = "registry+https://github.com/rust-lang/crates.io-index" 49 | checksum = "bbe448f377a7d6961e30f5955f9b8d106c3f5e449d493ee1b125c1d43c2b5179" 50 | dependencies = [ 51 | "proc-macro2", 52 | ] 53 | 54 | [[package]] 55 | name = "rustc_version" 56 | version = "0.4.0" 57 | source = "registry+https://github.com/rust-lang/crates.io-index" 58 | checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366" 59 | dependencies = [ 60 | "semver", 61 | ] 62 | 63 | [[package]] 64 | name = "semver" 65 | version = "1.0.13" 66 | source = "registry+https://github.com/rust-lang/crates.io-index" 67 | checksum = "93f6841e709003d68bb2deee8c343572bf446003ec20a583e76f7b15cebf3711" 68 | 69 | [[package]] 70 | name = "syn" 71 | version = "1.0.99" 72 | source = "registry+https://github.com/rust-lang/crates.io-index" 73 | checksum = "58dbef6ec655055e20b86b15a8cc6d439cca19b667537ac6a1369572d151ab13" 74 | dependencies = [ 75 | "proc-macro2", 76 | "quote", 77 | "unicode-ident", 78 | ] 79 | 80 | [[package]] 81 | name = "test" 82 | version = "0.1.0" 83 | dependencies = [ 84 | "derive_more", 85 | "indoc", 86 | "paste", 87 | ] 88 | 89 | [[package]] 90 | name = "unicode-ident" 91 | version = "1.0.3" 92 | source = "registry+https://github.com/rust-lang/crates.io-index" 93 | checksum = "c4f5b37a154999a8f3f98cc23a628d850e154479cd94decf3414696e12e31aaf" 94 | -------------------------------------------------------------------------------- /code_rs/test/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "test" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | [dependencies] 7 | derive_more = "0.99.17" 8 | indoc = "1.0.6" 9 | paste = "1.0.9" 10 | #approx = { version = "0.5.1", default-features = false } 11 | #nalgebra = { version = "0.31.0", default-features = false, features = ["macros", "nalgebra-macros"] } 12 | #num-traits = { version = "0.2.15", default-features = false } 13 | #simba = { version = "0.7.1", default-features = false } 14 | 15 | [[bin]] 16 | name = "calculator" 17 | path = "src/calculator.rs" 18 | 19 | [[bin]] 20 | name = "calckeyb" 21 | path = "src/calckeyb.rs" 22 | 23 | [[bin]] 24 | name = "testfp" 25 | path = "src/testfp.rs" 26 | 27 | [[bin]] 28 | name = "testrgb" 29 | path = "src/testrgb.rs" 30 | 31 | [[bin]] 32 | name = "testdyn" 33 | path = "src/testdyn.rs" 34 | 35 | [[bin]] 36 | name = "basic" 37 | path = "src/basic.rs" 38 | 39 | [[bin]] 40 | name = "plotter" 41 | path = "src/plotter.rs" 42 | 43 | [[bin]] 44 | name = "parmweb" 45 | path = "src/parmweb.rs" 46 | 47 | [[bin]] 48 | name = "telnet_video" 49 | path = "src/telnet_video.rs" 50 | 51 | [[bin]] 52 | name = "simpletelnet" 53 | path = "src/simpletelnet.rs" 54 | 55 | [[bin]] 56 | name = "lisp" 57 | path = "src/lisprepl.rs" 58 | 59 | [[bin]] 60 | name = "ball" 61 | path = "src/ball.rs" 62 | 63 | [[bin]] 64 | name = "midi" 65 | path = "src/midi.rs" 66 | 67 | [profile.dev] 68 | panic = "abort" 69 | 70 | [profile.release] 71 | panic = "abort" 72 | opt-level = "z" 73 | 74 | -------------------------------------------------------------------------------- /code_rs/test/a.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zdimension/parm_extended/f3247976c2265619fe43b25d2262b79ad25e7cf4/code_rs/test/a.out -------------------------------------------------------------------------------- /code_rs/test/asm.bin: -------------------------------------------------------------------------------- 1 | ABCDEFG -------------------------------------------------------------------------------- /code_rs/test/asm.hex: -------------------------------------------------------------------------------- 1 | 4241 4443 4645 0047 2 | -------------------------------------------------------------------------------- /code_rs/test/basic/fib.bas: -------------------------------------------------------------------------------- 1 | 1 let a=0 2 | 2 let b=1 3 | 3 print b 4 | 4 let x=a+b 5 | 5 let a=b 6 | 6 let b=x 7 | 7 goto 3 8 | 9 | -------------------------------------------------------------------------------- /code_rs/test/basic/load.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | cat $1 <(echo) | dos2unix | iconv -f utf8 -t ascii//TRANSLIT | nc -N ::1 4567 -------------------------------------------------------------------------------- /code_rs/test/bin/.gitignore: -------------------------------------------------------------------------------- 1 | *.log -------------------------------------------------------------------------------- /code_rs/test/bin/asm.hex: -------------------------------------------------------------------------------- 1 | v2.0 raw 2 | -------------------------------------------------------------------------------- /code_rs/test/bin/ball.bin: -------------------------------------------------------------------------------- 1 | v2.0 raw 2 | 00 f0 0c fa 82 b0 00 94 bc 46 77 46 01 97 67 46 51 43 43 43 c9 18 03 0c 14 0c 63 43 c9 18 03 0c 80 b2 92 b2 53 43 44 43 50 43 00 22 1b 19 52 41 12 04 89 18 1a 04 1b 0c 80 18 59 41 00 9c bc 46 01 9f be 46 67 46 02 b0 70 47 02 b0 00 46 00 46 82 b0 00 97 bc 46 77 46 01 97 67 46 00 af 02 48 0d 21 00 f0 85 fa fe de 7c 06 00 00 84 b0 00 94 01 95 02 97 bc 46 77 46 03 97 67 46 02 af 03 23 14 46 9c 43 00 23 a3 42 06 d2 cd 58 c5 50 1b 1d f9 e7 cc 5c c4 54 5b 1c 93 42 fa d3 00 9c 01 9d 02 9f bc 46 03 9f be 46 67 46 04 b0 70 47 04 b0 82 b0 00 97 bc 46 77 46 01 97 67 46 00 af ff f7 d5 ff 00 9f bc 46 01 9f be 46 67 46 02 b0 70 47 02 b0 84 b0 00 94 01 96 02 97 bc 46 77 46 03 97 67 46 02 af 03 22 0b 46 93 43 00 22 9a 42 06 d2 00 24 84 50 12 1d f9 e7 00 23 83 54 52 1c 8a 42 fa d3 00 9c 01 9e 02 9f bc 46 03 9f be 46 67 46 04 b0 70 47 04 b0 82 b0 00 97 bc 46 77 46 01 97 67 46 00 af ff f7 d5 ff 00 9f bc 46 01 9f be 46 67 46 02 b0 70 47 02 b0 82 b0 00 97 bc 46 77 46 01 97 67 46 00 af ff f7 c4 ff 00 9f bc 46 01 9f be 46 67 46 02 b0 70 47 02 b0 82 b0 00 97 bc 46 77 46 01 97 67 46 00 af 00 f0 08 f8 00 9f bc 46 01 9f be 46 67 46 02 b0 70 47 02 b0 86 b0 00 93 01 94 02 95 03 96 04 97 bc 46 77 46 05 97 67 46 04 af 03 24 16 46 a6 43 81 42 08 d2 0c 1f 05 1f 00 96 00 2e 1b d0 a3 59 ab 51 36 1f f9 e7 00 24 b4 42 06 d2 0b 59 03 51 24 1d f9 e7 0b 5d 03 55 64 1c 94 42 fa d3 00 9b 01 9c 02 9d 03 9e 04 9f bc 46 05 9f be 46 67 46 06 b0 70 47 06 b0 00 9b d3 1a 51 18 49 1e 10 18 40 1e 00 2b eb d0 0a 78 02 70 5b 1e 49 1e f7 e7 84 b0 00 94 01 96 02 97 bc 46 77 46 03 97 67 46 02 af 03 23 14 46 9c 43 cb b2 0b 49 59 43 00 23 a3 42 04 d2 c1 50 1b 1d fa e7 c1 54 5b 1c 93 42 fb d3 00 9c 01 9e 02 9f bc 46 03 9f be 46 67 46 04 b0 70 47 04 b0 00 46 01 01 01 01 82 b0 00 97 bc 46 77 46 01 97 67 46 00 af 00 f0 08 f8 00 9f bc 46 01 9f be 46 67 46 02 b0 70 47 02 b0 85 b0 00 94 01 95 02 96 03 97 bc 46 77 46 04 97 67 46 03 af 85 b0 03 23 16 46 9e 43 00 24 01 ab 18 60 04 33 19 60 04 33 1a 60 04 33 00 96 b4 42 25 d2 63 58 25 58 9d 42 1a d0 22 1d 94 42 25 46 00 d8 15 46 06 19 0b 19 04 95 2c 1b 00 2c 09 d0 64 1e 71 1c 58 1c 1a 78 35 78 95 42 0e 46 03 46 f4 d0 10 e0 01 ac 20 68 61 68 a2 68 e4 68 00 9e 24 1d dc e7 0b 5d 05 5d 64 1c 9d 42 10 d1 94 42 f8 d3 00 20 00 e0 a8 1a 05 b0 00 9c 01 9d 02 9e 03 9f bc 46 04 9f be 46 67 46 05 b0 70 47 05 b0 e8 1a f1 e7 84 b0 00 94 01 96 02 97 bc 46 77 46 03 97 67 46 02 af cf 22 d4 43 02 46 0b 46 20 68 00 9c 01 9e 02 9f bc 46 03 9f be 46 67 46 04 b0 70 47 04 b0 84 b0 00 94 01 96 02 97 bc 46 77 46 03 97 67 46 02 af cf 22 d4 43 02 46 0b 46 20 68 00 9c 01 9e 02 9f bc 46 03 9f be 46 67 46 04 b0 70 47 04 b0 84 b0 00 94 01 95 02 97 bc 46 77 46 03 97 67 46 02 af cf 22 d4 43 cb 22 d5 43 02 46 0b 46 20 68 29 68 00 9c 01 9d 02 9f bc 46 03 9f be 46 67 46 04 b0 70 47 04 b0 84 b0 00 94 01 95 02 97 bc 46 77 46 03 97 67 46 02 af cf 22 d4 43 cb 22 d5 43 02 46 0b 46 20 68 29 68 00 9c 01 9d 02 9f bc 46 03 9f be 46 67 46 04 b0 70 47 04 b0 02 0c 01 d0 10 21 00 e0 20 21 00 2a 00 d0 10 46 02 0a 00 d0 08 39 00 2a 00 d0 10 46 10 28 00 d3 09 1f 10 28 00 d3 00 09 04 28 00 d3 89 1e 04 28 00 d3 80 08 02 28 02 d3 01 20 c0 43 00 e0 40 42 40 18 70 47 00 46 82 b0 00 97 bc 46 77 46 01 97 67 46 00 af 8a b0 01 20 00 05 85 46 00 20 05 20 03 04 01 20 01 02 07 91 00 06 01 90 00 20 05 46 04 46 ef 21 09 04 8d 42 02 d1 00 28 00 d1 85 e0 19 12 19 22 51 43 0c 19 43 49 46 18 31 12 51 43 4d 19 00 2c 08 d4 3d 49 8c 42 5f d9 03 96 06 95 0f 20 80 05 04 1b 02 e0 03 96 06 95 64 42 5b 42 04 93 d9 20 02 90 20 14 05 94 21 04 c9 0f 0a 18 93 00 01 9d eb 18 09 93 06 9c 23 14 24 04 e4 0f e6 18 07 9b e0 33 73 43 c0 18 40 18 80 00 2b 18 b4 1c 90 1c 08 90 08 98 82 42 2e da 07 98 df 30 82 42 05 d9 52 1c 09 98 00 1d 09 90 1b 1d f2 e7 00 2e 17 d4 30 46 ed 2e 19 46 0a dd 00 21 30 46 ef 28 ef dc 02 25 5d 50 0f 25 ed 01 49 19 40 1c f6 e7 a0 42 e6 da 02 25 0d 60 0f 25 ed 01 49 19 40 1c f6 e7 00 21 09 98 a1 42 db da 02 25 05 60 0f 25 ed 01 40 19 49 1c f6 e7 03 98 00 12 02 99 48 43 04 ad 2b 68 6c 68 ad 68 8a e7 00 2d 04 93 0a d4 29 0d 0e 29 0d d9 0a 49 08 1a 03 90 07 48 40 1b 40 1c 06 90 9c e7 06 49 08 1a 03 90 6d 42 06 95 96 e7 03 96 06 95 07 98 93 e7 fe e7 ff ff df 01 c9 0a ff ff 37 f5 00 00 ff 22 d2 43 00 23 09 4c 06 2b 07 d0 e5 5c 15 60 5b 1c f9 e7 03 78 13 60 49 1e 40 1c 00 29 f9 d1 0a 20 10 60 01 20 d0 63 fe e7 00 46 8a 06 00 00 82 b0 00 97 bc 46 77 46 01 97 67 46 00 af ff f7 df ff fe de 82 b0 00 97 bc 46 77 46 01 97 67 46 00 af 02 48 0d 21 ff f7 d3 ff fe de 90 06 00 00 82 b0 00 97 bc 46 77 46 01 97 67 46 00 af 02 48 13 21 ff f7 c5 ff fe de 9e 06 00 00 82 b0 00 97 bc 46 77 46 01 97 67 46 00 af 02 48 09 21 ff f7 b7 ff fe de b2 06 00 00 82 b0 00 97 bc 46 77 46 01 97 67 46 00 af 02 48 10 21 ff f7 a9 ff fe de bc 06 00 00 82 b0 00 97 bc 46 77 46 01 97 67 46 00 af 02 48 19 21 ff f7 9b ff fe de cc 06 00 00 82 b0 00 97 bc 46 77 46 01 97 67 46 00 af 02 48 24 21 ff f7 8d ff fe de e6 06 00 00 ff 20 c0 43 00 21 05 4a 07 29 03 d0 53 5c 03 60 49 1c f9 e7 0a 21 01 60 fe e7 00 46 0a 07 00 00 75 6e 6b 6e 6f 77 6e 20 70 61 6e 69 63 00 50 41 4e 49 43 3a 75 6e 77 72 61 70 5f 66 61 69 6c 65 64 00 69 6e 64 65 78 20 6f 75 74 20 6f 66 20 62 6f 75 6e 64 73 00 70 61 6e 69 63 5f 66 6d 74 00 62 6f 72 72 6f 77 5f 6d 75 74 20 65 72 72 6f 72 73 6c 69 63 65 20 69 6e 64 65 78 20 6f 75 74 20 6f 66 20 62 6f 75 6e 64 73 00 73 6c 69 63 65 20 69 6e 64 65 78 20 73 74 61 72 74 20 69 73 20 6c 61 72 67 65 72 20 74 68 61 6e 20 65 6e 64 68 61 6e 64 6c 65 72 00 3 | -------------------------------------------------------------------------------- /code_rs/test/bin/ball.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zdimension/parm_extended/f3247976c2265619fe43b25d2262b79ad25e7cf4/code_rs/test/bin/ball.raw -------------------------------------------------------------------------------- /code_rs/test/bin/basic.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zdimension/parm_extended/f3247976c2265619fe43b25d2262b79ad25e7cf4/code_rs/test/bin/basic.raw -------------------------------------------------------------------------------- /code_rs/test/bin/calckeyb.bin: -------------------------------------------------------------------------------- 1 | v2.0 raw 2 | 00 f0 30 fa 82 b0 00 94 bc 46 77 46 01 97 67 46 51 43 43 43 c9 18 03 0c 14 0c 63 43 c9 18 03 0c 80 b2 92 b2 53 43 44 43 50 43 00 22 1b 19 52 41 12 04 89 18 1a 04 1b 0c 80 18 59 41 00 9c bc 46 01 9f be 46 67 46 02 b0 70 47 02 b0 00 46 00 46 82 b0 00 97 bc 46 77 46 01 97 67 46 00 af 02 48 0d 21 00 f0 93 fa fe de d0 06 00 00 84 b0 00 94 01 95 02 97 bc 46 77 46 03 97 67 46 02 af 03 23 14 46 9c 43 00 23 a3 42 06 d2 cd 58 c5 50 1b 1d f9 e7 cc 5c c4 54 5b 1c 93 42 fa d3 00 9c 01 9d 02 9f bc 46 03 9f be 46 67 46 04 b0 70 47 04 b0 82 b0 00 97 bc 46 77 46 01 97 67 46 00 af ff f7 d5 ff 00 9f bc 46 01 9f be 46 67 46 02 b0 70 47 02 b0 84 b0 00 94 01 96 02 97 bc 46 77 46 03 97 67 46 02 af 03 22 0b 46 93 43 00 22 9a 42 06 d2 00 24 84 50 12 1d f9 e7 00 23 83 54 52 1c 8a 42 fa d3 00 9c 01 9e 02 9f bc 46 03 9f be 46 67 46 04 b0 70 47 04 b0 82 b0 00 97 bc 46 77 46 01 97 67 46 00 af ff f7 d5 ff 00 9f bc 46 01 9f be 46 67 46 02 b0 70 47 02 b0 82 b0 00 97 bc 46 77 46 01 97 67 46 00 af ff f7 c4 ff 00 9f bc 46 01 9f be 46 67 46 02 b0 70 47 02 b0 82 b0 00 97 bc 46 77 46 01 97 67 46 00 af 00 f0 08 f8 00 9f bc 46 01 9f be 46 67 46 02 b0 70 47 02 b0 86 b0 00 93 01 94 02 95 03 96 04 97 bc 46 77 46 05 97 67 46 04 af 03 24 13 46 a3 43 81 42 09 d2 0c 1f 05 1f 00 93 1e 46 00 2e 1b d0 a3 59 ab 51 36 1f f9 e7 00 24 9c 42 06 d2 0d 59 05 51 24 1d f9 e7 0b 5d 03 55 64 1c 94 42 fa d3 00 9b 01 9c 02 9d 03 9e 04 9f bc 46 05 9f be 46 67 46 06 b0 70 47 06 b0 00 9b d3 1a 51 18 49 1e 10 18 40 1e 00 2b eb d0 0a 78 02 70 5b 1e 49 1e f7 e7 00 46 84 b0 00 94 01 96 02 97 bc 46 77 46 03 97 67 46 02 af 03 23 14 46 9c 43 cb b2 0b 49 59 43 00 23 a3 42 04 d2 c1 50 1b 1d fa e7 c1 54 5b 1c 93 42 fb d3 00 9c 01 9e 02 9f bc 46 03 9f be 46 67 46 04 b0 70 47 04 b0 00 46 01 01 01 01 82 b0 00 97 bc 46 77 46 01 97 67 46 00 af 00 f0 08 f8 00 9f bc 46 01 9f be 46 67 46 02 b0 70 47 02 b0 89 b0 00 90 01 91 02 92 03 93 04 94 05 95 06 96 07 97 bc 46 77 46 08 97 67 46 07 af 03 23 00 92 15 46 9d 43 00 23 03 91 02 90 01 95 ab 42 21 d2 5c 58 1a 58 a2 42 0e d0 c5 18 ce 18 1b 1d 00 24 04 2c 05 d0 32 5d 29 5d 64 1c 91 42 f8 d0 04 e0 03 99 02 98 01 9d 1b 1d e8 e7 88 1a 04 b0 00 9c 01 9d 02 9e 03 9f bc 46 04 9f be 46 67 46 05 b0 70 47 05 b0 00 9d ab 42 06 d2 ca 5c c4 5c 5b 1c 94 42 f8 d0 a0 1a e9 e7 00 20 e7 e7 84 b0 00 94 01 96 02 97 bc 46 77 46 03 97 67 46 02 af cf 22 d4 43 02 46 0b 46 20 68 00 9c 01 9e 02 9f bc 46 03 9f be 46 67 46 04 b0 70 47 04 b0 84 b0 00 94 01 96 02 97 bc 46 77 46 03 97 67 46 02 af cf 22 d4 43 02 46 0b 46 20 68 00 9c 01 9e 02 9f bc 46 03 9f be 46 67 46 04 b0 70 47 04 b0 84 b0 00 94 01 95 02 97 bc 46 77 46 03 97 67 46 02 af cf 22 d4 43 cb 22 d5 43 02 46 0b 46 20 68 29 68 00 9c 01 9d 02 9f bc 46 03 9f be 46 67 46 04 b0 70 47 04 b0 84 b0 00 94 01 95 02 97 bc 46 77 46 03 97 67 46 02 af cf 22 d4 43 cb 22 d5 43 02 46 0b 46 20 68 29 68 00 9c 01 9d 02 9f bc 46 03 9f be 46 67 46 04 b0 70 47 04 b0 02 0c 01 d0 10 21 00 e0 20 21 00 2a 00 d0 10 46 02 0a 00 d0 08 39 00 2a 00 d0 10 46 10 28 00 d3 09 1f 10 28 00 d3 00 09 04 28 00 d3 89 1e 04 28 00 d3 80 08 02 28 02 d3 01 20 c0 43 00 e0 40 42 40 18 70 47 84 b0 00 94 01 96 02 97 bc 46 77 46 03 97 67 46 02 af ff 20 c4 43 00 20 a1 69 00 29 fc d0 e1 69 08 29 0a d0 0a 29 0e d0 0a 46 30 3a 0a 2a f3 d2 21 60 0a 21 41 43 50 18 ee e7 08 21 21 60 0a 21 ff f7 56 ff e8 e7 0a 21 21 60 00 9c 01 9e 02 9f bc 46 03 9f be 46 67 46 04 b0 70 47 04 b0 88 b0 00 91 01 92 02 93 03 94 04 95 05 96 06 97 bc 46 77 46 07 97 67 46 06 af 01 20 00 05 85 46 00 20 ff 20 c6 43 3b 4a 3c 4d 10 46 11 1d 88 42 03 d0 01 78 31 60 40 1c f8 e7 00 24 ff f7 b1 ff 04 90 35 49 04 2c 03 d0 08 5d 30 60 64 1c f9 e7 00 24 ff f7 a6 ff 01 46 08 2c 03 d0 28 5d 30 60 64 1c f9 e7 0a 20 30 60 04 98 0c 18 42 1a 03 92 02 46 4a 43 02 92 0a 46 02 40 01 92 0a 46 02 43 05 92 48 40 00 90 b0 69 00 28 fc d0 f0 69 c2 b2 10 46 26 38 09 28 1c d8 80 00 02 a2 12 58 20 46 97 46 00 46 33 05 00 00 31 05 00 00 31 05 00 00 31 05 00 00 47 05 00 00 61 05 00 00 31 05 00 00 4b 05 00 00 31 05 00 00 4f 05 00 00 db e7 01 98 14 e0 5e 2a 11 d0 7c 2a 05 98 0f d0 0a 2a d2 d1 0e e0 02 98 0a e0 03 98 08 e0 00 29 0c d0 04 98 0d 46 ff f7 ce fe 29 46 00 e0 00 98 70 60 c2 e7 04 4a 10 46 05 4d 91 e7 05 48 19 21 05 4a 00 f0 0b f8 fe de 8e 07 00 00 92 07 00 00 96 07 00 00 c0 07 00 00 b0 07 00 00 ff 22 d2 43 00 23 09 4c 06 2b 07 d0 e5 5c 15 60 5b 1c f9 e7 03 78 13 60 49 1e 40 1c 00 29 f9 d1 0a 20 10 60 01 20 d0 63 fe e7 00 46 de 06 00 00 82 b0 00 97 bc 46 77 46 01 97 67 46 00 af ff f7 df ff fe de 82 b0 00 97 bc 46 77 46 01 97 67 46 00 af 02 48 0d 21 ff f7 d3 ff fe de e4 06 00 00 82 b0 00 97 bc 46 77 46 01 97 67 46 00 af 02 48 13 21 ff f7 c5 ff fe de f2 06 00 00 82 b0 00 97 bc 46 77 46 01 97 67 46 00 af 02 48 09 21 ff f7 b7 ff fe de 06 07 00 00 82 b0 00 97 bc 46 77 46 01 97 67 46 00 af 02 48 16 21 ff f7 a9 ff fe de 10 07 00 00 82 b0 00 97 bc 46 77 46 01 97 67 46 00 af 02 48 10 21 ff f7 9b ff fe de 26 07 00 00 82 b0 00 97 bc 46 77 46 01 97 67 46 00 af 02 48 11 21 ff f7 8d ff fe de 36 07 00 00 82 b0 00 97 bc 46 77 46 01 97 67 46 00 af 02 48 19 21 ff f7 7f ff fe de 48 07 00 00 82 b0 00 97 bc 46 77 46 01 97 67 46 00 af 02 48 24 21 ff f7 71 ff fe de 62 07 00 00 ff 20 c0 43 00 21 05 4a 07 29 03 d0 53 5c 03 60 49 1c f9 e7 0a 21 01 60 fe e7 00 46 86 07 00 00 75 6e 6b 6e 6f 77 6e 20 70 61 6e 69 63 00 50 41 4e 49 43 3a 75 6e 77 72 61 70 5f 66 61 69 6c 65 64 00 69 6e 64 65 78 20 6f 75 74 20 6f 66 20 62 6f 75 6e 64 73 00 70 61 6e 69 63 5f 66 6d 74 00 70 61 6e 69 63 5f 61 6c 72 65 61 64 79 5f 62 6f 72 72 6f 77 65 64 62 6f 72 72 6f 77 5f 6d 75 74 20 65 72 72 6f 72 63 6f 6e 73 74 20 64 69 76 20 62 79 20 7a 65 72 6f 00 73 6c 69 63 65 20 69 6e 64 65 78 20 6f 75 74 20 6f 66 20 62 6f 75 6e 64 73 00 73 6c 69 63 65 20 69 6e 64 65 78 20 73 74 61 72 74 20 69 73 20 6c 61 72 67 65 72 20 74 68 61 6e 20 65 6e 64 68 61 6e 64 6c 65 72 00 41 20 3d 20 42 20 3d 20 2b 2d 2a 2f 25 26 7c 5e 73 72 63 2f 63 61 6c 63 6b 65 79 62 2e 72 73 00 00 00 9e 07 00 00 0f 00 00 00 1d 00 00 00 19 00 00 00 61 74 74 65 6d 70 74 20 74 6f 20 64 69 76 69 64 65 20 62 79 20 7a 65 72 6f 00 3 | -------------------------------------------------------------------------------- /code_rs/test/bin/calckeyb.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zdimension/parm_extended/f3247976c2265619fe43b25d2262b79ad25e7cf4/code_rs/test/bin/calckeyb.raw -------------------------------------------------------------------------------- /code_rs/test/bin/calckeyb2.s: -------------------------------------------------------------------------------- 1 | run: 2 | 0: push {r7, lr} 3 | 2: add r7, sp, #0 4 | 4: sub sp, #508 ; 0x1fc 5 | 6: sub sp, #508 ; 0x1fc 6 | 8: sub sp, #8 7 | a: bl 58 8 | e: udf #254 ; 0xfe 9 | 10: push {r4, r5, r7, lr} 10 | 12: add r7, sp, #8 11 | 14: movs r2, #15 12 | 16: mvns r1, r2 13 | 18: movs r3, #4 14 | 1a: mvns r4, r3 15 | 1c: ldr r3, [r4, #0] 16 | 1e: cmp r3, #0 17 | 20: beq.n 52 18 | 22: cmp r0, #0 19 | 24: beq.n 36 20 | 26: movs r0, #14 21 | 28: mvns r0, r0 22 | 2a: ldr r3, [r0, #0] 23 | 2c: movs r5, #45 ; 0x2d 24 | 2e: str r5, [r1, #0] 25 | 30: negs r3, r3 26 | 32: str r3, [r0, #0] 27 | 34: ldr r3, [r4, #0] 28 | 36: mov r0, r3 29 | 38: lsls r4, r3, #28 30 | 3a: lsrs r3, r3, #4 31 | 3c: cmp r4, #0 32 | 3e: beq.n 36 33 | 40: b.n 4c 34 | 42: lsrs r3, r0, #4 35 | 44: ands r0, r2 36 | 46: adds r0, #48 ; 0x30 37 | 48: str r0, [r1, #0] 38 | 4a: mov r0, r3 39 | 4c: cmp r0, #0 40 | 4e: bne.n 42 41 | 50: pop {r4, r5, r7, pc} 42 | 52: movs r0, #48 ; 0x30 43 | 54: str r0, [r1, #0] 44 | 56: pop {r4, r5, r7, pc} 45 | 58: push {r7, lr} 46 | 5a: add r7, sp, #0 47 | 5c: sub sp, #32 48 | 5e: movs r0, #15 49 | 60: mvns r1, r0 50 | 62: movs r0, #65 ; 0x41 51 | 64: str r0, [r1, #0] 52 | 66: movs r0, #61 ; 0x3d 53 | 68: str r1, [sp, #20] 54 | 6a: str r0, [sp, #12] 55 | 6c: str r0, [r1, #0] 56 | 6e: movs r0, #9 57 | 70: mvns r6, r0 58 | 72: movs r0, #8 59 | 74: mvns r0, r0 60 | 76: str r0, [sp, #28] 61 | 78: movs r4, #0 62 | 7a: ldr r0, [r6, #0] 63 | 7c: cmp r0, #0 64 | 7e: beq.n 7a 65 | 80: ldr r0, [sp, #28] 66 | 82: ldr r0, [r0, #0] 67 | 84: uxtb r1, r0 68 | 86: cmp r1, #10 69 | 88: beq.n a2 70 | 8a: mov r2, r1 71 | 8c: subs r2, #48 ; 0x30 72 | 8e: cmp r2, #9 73 | 90: bhi.n 7a 74 | 92: ldr r2, [sp, #20] 75 | 94: str r1, [r2, #0] 76 | 96: movs r1, #10 77 | 98: muls r1, r4 78 | 9a: adds r0, #208 ; 0xd0 79 | 9c: uxtb r0, r0 80 | 9e: adds r4, r0, r1 81 | a0: b.n 7a 82 | a2: movs r0, #10 83 | a4: ldr r1, [sp, #20] 84 | a6: str r0, [sp, #16] 85 | a8: str r0, [r1, #0] 86 | aa: movs r0, #66 ; 0x42 87 | ac: str r0, [r1, #0] 88 | ae: ldr r0, [sp, #12] 89 | b0: str r0, [r1, #0] 90 | b2: movs r5, #0 91 | b4: ldr r0, [r6, #0] 92 | b6: cmp r0, #0 93 | b8: beq.n b4 94 | ba: ldr r0, [sp, #28] 95 | bc: ldr r0, [r0, #0] 96 | be: uxtb r1, r0 97 | c0: cmp r1, #10 98 | c2: beq.n dc 99 | c4: mov r2, r1 100 | c6: subs r2, #48 ; 0x30 101 | c8: cmp r2, #9 102 | ca: bhi.n b4 103 | cc: ldr r2, [sp, #20] 104 | ce: str r1, [r2, #0] 105 | d0: ldr r1, [sp, #16] 106 | d2: muls r5, r1 107 | d4: adds r0, #208 ; 0xd0 108 | d6: uxtb r0, r0 109 | d8: adds r5, r0, r5 110 | da: b.n b4 111 | dc: ldr r1, [sp, #20] 112 | de: ldr r0, [sp, #16] 113 | e0: str r0, [r1, #0] 114 | e2: movs r0, #43 ; 0x2b 115 | e4: str r0, [r1, #0] 116 | e6: movs r0, #45 ; 0x2d 117 | e8: str r0, [r1, #0] 118 | ea: movs r0, #42 ; 0x2a 119 | ec: str r0, [r1, #0] 120 | ee: adds r0, r5, r4 121 | f0: str r0, [sp, #24] 122 | f2: subs r0, r4, r5 123 | f4: str r0, [sp, #8] 124 | f6: mov r0, r4 125 | f8: muls r0, r5 126 | fa: str r0, [sp, #4] 127 | fc: ldr r0, [r6, #0] 128 | fe: cmp r0, #0 129 | 100: beq.n fc 130 | 102: ldr r0, [sp, #28] 131 | 104: ldr r0, [r0, #0] 132 | 106: uxtb r0, r0 133 | 108: subs r0, #42 ; 0x2a 134 | 10a: cmp r0, #5 135 | 10c: bhi.n fc 136 | 10e: lsls r0, r0, #2 137 | 110: add r1, pc, #4 ; (adr r1, 118 138 | 112: ldr r1, [r1, r0] 139 | 114: ldr r0, [sp, #24] 140 | 116: mov pc, r1 141 | 118: .word 0x00000133 142 | 11c: .word 0x00000143 143 | 120: .word 0x00000131 144 | 124: .word 0x00000137 145 | 128: .word 0x00000131 146 | 12c: .word 0x0000013b 147 | 130: b.n fc 148 | 132: ldr r0, [sp, #4] 149 | 134: b.n 142 150 | 136: ldr r0, [sp, #8] 151 | 138: b.n 142 152 | 13a: movs r6, r4 153 | 13c: movs r0, #3 154 | 13e: mvns r0, r0 155 | 140: ldr r0, [r0, #0] 156 | 142: movs r1, #14 157 | 144: mvns r1, r1 158 | 146: str r0, [r1, #0] 159 | 148: ldr r1, [sp, #20] 160 | 14a: ldr r0, [sp, #16] 161 | 14c: str r0, [r1, #0] 162 | 14e: movs r0, #82 ; 0x52 163 | 150: str r0, [r1, #0] 164 | 152: ldr r0, [sp, #12] 165 | 154: str r0, [r1, #0] 166 | 156: movs r0, #0 167 | 158: bl 10 168 | 15c: ldr r0, [r6, #0] 169 | 15e: cmp r0, #0 170 | 160: beq.n 15c 171 | 162: movs r0, #11 172 | 164: mvns r0, r0 173 | 166: movs r1, #1 174 | 168: str r1, [r0, #0] 175 | 16a: b.n fc 176 | -------------------------------------------------------------------------------- /code_rs/test/bin/calckeyb_ok.s: -------------------------------------------------------------------------------- 1 | .text 2 | .syntax unified 3 | .eabi_attribute 67, "2.09" 4 | .eabi_attribute 6, 12 5 | .eabi_attribute 7, 77 6 | .eabi_attribute 8, 0 7 | .eabi_attribute 9, 1 8 | .eabi_attribute 34, 0 9 | .eabi_attribute 17, 1 10 | .eabi_attribute 20, 1 11 | .eabi_attribute 21, 0 12 | .eabi_attribute 23, 3 13 | .eabi_attribute 24, 1 14 | .eabi_attribute 25, 1 15 | .eabi_attribute 38, 1 16 | .eabi_attribute 14, 0 17 | .file "calckeyb.ecc8c934-cgu.0" 18 | .section .start,"ax",%progbits 19 | .globl run 20 | .p2align 2 21 | .type run,%function 22 | .code 16 23 | .thumb_func 24 | run: 25 | .fnstart 26 | .save {r7, lr} 27 | .pad #24 28 | push {r1, r2, r3, r4, r5, r6, r7, lr} 29 | .setfp r7, sp, #24 30 | add r7, sp, #24 31 | @APP 32 | 33 | sub sp, #508 34 | sub sp, #508 35 | sub sp, #8 36 | 37 | @NO_APP 38 | movs r0, #15 39 | mvns r0, r0 40 | movs r1, #0 41 | ldr r2, .LCPI0_0 42 | .LBB0_1: 43 | cmp r1, #4 44 | beq .LBB0_3 45 | ldrb r3, [r2, r1] 46 | str r3, [r0] 47 | adds r1, r1, #1 48 | b .LBB0_1 49 | .LBB0_3: 50 | movs r1, #9 51 | mvns r1, r1 52 | movs r2, #8 53 | mvns r2, r2 54 | movs r6, #0 55 | .LBB0_4: 56 | ldr r3, [r1] 57 | cmp r3, #0 58 | beq .LBB0_4 59 | ldr r3, [r2] 60 | uxtb r4, r3 61 | cmp r4, #10 62 | beq .LBB0_8 63 | mov r5, r4 64 | subs r5, #48 65 | cmp r5, #9 66 | bhi .LBB0_4 67 | str r4, [r0] 68 | movs r4, #10 69 | muls r4, r6, r4 70 | adds r3, #208 71 | uxtb r3, r3 72 | adds r6, r3, r4 73 | b .LBB0_4 74 | .LBB0_8: 75 | movs r5, #10 76 | movs r3, #0 77 | ldr r4, .LCPI0_1 78 | .LBB0_9: 79 | str r5, [r0] 80 | cmp r3, #4 81 | beq .LBB0_11 82 | ldrb r5, [r4, r3] 83 | adds r3, r3, #1 84 | b .LBB0_9 85 | .LBB0_11: 86 | movs r3, #0 87 | .LBB0_12: 88 | str r3, [sp, #20] 89 | .LBB0_13: 90 | ldr r3, [r1] 91 | cmp r3, #0 92 | beq .LBB0_13 93 | ldr r3, [r2] 94 | uxtb r4, r3 95 | cmp r4, #10 96 | beq .LBB0_17 97 | mov r5, r4 98 | subs r5, #48 99 | cmp r5, #9 100 | bhi .LBB0_13 101 | str r4, [r0] 102 | movs r4, #10 103 | ldr r5, [sp, #20] 104 | muls r4, r5, r4 105 | adds r3, #208 106 | uxtb r3, r3 107 | adds r3, r3, r4 108 | b .LBB0_12 109 | .LBB0_17: 110 | movs r5, #10 111 | movs r3, #0 112 | ldr r4, .LCPI0_2 113 | .LBB0_18: 114 | str r5, [r0] 115 | cmp r3, #8 116 | beq .LBB0_20 117 | ldrb r5, [r4, r3] 118 | adds r3, r3, #1 119 | b .LBB0_18 120 | .LBB0_20: 121 | movs r5, #10 122 | str r5, [r0] 123 | ldr r3, [sp, #20] 124 | adds r3, r3, r6 125 | str r6, [sp] 126 | ldr r4, [sp] 127 | ldr r6, [sp, #20] 128 | subs r6, r4, r6 129 | str r6, [sp, #16] 130 | ldr r6, [sp] 131 | ldr r4, [sp, #20] 132 | muls r6, r4, r6 133 | str r6, [sp, #12] 134 | mov r6, r4 135 | ldr r4, [sp] 136 | ands r6, r4 137 | str r6, [sp, #8] 138 | ldr r6, [sp, #20] 139 | ldr r4, [sp] 140 | orrs r6, r4 141 | str r6, [sp, #4] 142 | ldr r6, [sp] 143 | ldr r4, [sp, #20] 144 | eors r4, r6 145 | str r4, [sp, #20] 146 | .LBB0_21: 147 | ldr r6, [r1] 148 | cmp r6, #0 149 | beq .LBB0_21 150 | ldr r6, [r2] 151 | uxtb r6, r6 152 | subs r6, #48 153 | cmp r6, #5 154 | bhi .LBB0_21 155 | lsls r6, r6, #2 156 | adr r4, .LJTI0_0 157 | ldr r4, [r4, r6] 158 | mov r6, r3 159 | mov pc, r4 160 | .p2align 2 161 | .LJTI0_0: 162 | .long .LBB0_30+1 163 | .long .LBB0_25+1 164 | .long .LBB0_26+1 165 | .long .LBB0_27+1 166 | .long .LBB0_28+1 167 | .long .LBB0_29+1 168 | .LBB0_25: 169 | ldr r6, [sp, #16] 170 | b .LBB0_30 171 | .LBB0_26: 172 | ldr r6, [sp, #12] 173 | b .LBB0_30 174 | .LBB0_27: 175 | ldr r6, [sp, #8] 176 | b .LBB0_30 177 | .LBB0_28: 178 | ldr r6, [sp, #4] 179 | b .LBB0_30 180 | .LBB0_29: 181 | ldr r6, [sp, #20] 182 | .LBB0_30: 183 | str r5, [r0] 184 | movs r4, #14 185 | mvns r4, r4 186 | str r6, [r4] 187 | .LBB0_31: 188 | ldr r4, [r1] 189 | cmp r4, #0 190 | beq .LBB0_31 191 | movs r4, #11 192 | mvns r4, r4 193 | movs r6, #1 194 | str r6, [r4] 195 | b .LBB0_21 196 | .p2align 2 197 | .LCPI0_0: 198 | .long .L__unnamed_1 199 | .LCPI0_1: 200 | .long .L__unnamed_2 201 | .LCPI0_2: 202 | .long .L__unnamed_3 203 | .Lfunc_end0: 204 | .size run, .Lfunc_end0-run 205 | .cantunwind 206 | .fnend 207 | 208 | .section .text.rust_begin_unwind,"ax",%progbits 209 | .hidden rust_begin_unwind 210 | .globl rust_begin_unwind 211 | .p2align 1 212 | .type rust_begin_unwind,%function 213 | .code 16 214 | .thumb_func 215 | rust_begin_unwind: 216 | .fnstart 217 | .LBB1_1: 218 | b .LBB1_1 219 | .Lfunc_end1: 220 | .size rust_begin_unwind, .Lfunc_end1-rust_begin_unwind 221 | .cantunwind 222 | .fnend 223 | 224 | .type .L__unnamed_1,%object 225 | .section .rodata.cst4,"aM",%progbits,4 226 | .L__unnamed_1: 227 | .ascii "A = " 228 | .size .L__unnamed_1, 4 229 | 230 | .type .L__unnamed_2,%object 231 | .L__unnamed_2: 232 | .ascii "B = " 233 | .size .L__unnamed_2, 4 234 | 235 | .type .L__unnamed_3,%object 236 | .section .rodata.cst8,"aM",%progbits,8 237 | .L__unnamed_3: 238 | .ascii "+-*/%&|^" 239 | .size .L__unnamed_3, 8 240 | 241 | .section ".note.GNU-stack","",%progbits 242 | .eabi_attribute 30, 4 243 | -------------------------------------------------------------------------------- /code_rs/test/bin/calculator.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zdimension/parm_extended/f3247976c2265619fe43b25d2262b79ad25e7cf4/code_rs/test/bin/calculator.bin -------------------------------------------------------------------------------- /code_rs/test/bin/calculator.s: -------------------------------------------------------------------------------- 1 | run: 2 | 0: movs r0, #12 3 | 2: mvns r0, r0 4 | 4: ldr r0, [r0, #0] 5 | 6: movs r1, #11 6 | 8: mvns r1, r1 7 | a: ldr r1, [r1, #0] 8 | c: movs r2, #10 9 | e: mvns r2, r2 10 | 10: ldr r2, [r2, #0] 11 | 12: cmp r2, #3 12 | 14: bhi.n 3e 13 | 16: nop ; (mov r8, r8) 14 | 18: add r2, pc 15 | 1a: ldrb r2, [r2, #4] 16 | 1c: lsls r2, r2, #1 17 | 1e: add pc, r2 18 | 20: .word 0x07050301 19 | 24: adds r0, r1, r0 20 | 26: b.n 36 21 | 28: subs r0, r0, r1 22 | 2a: b.n 36 23 | 2c: muls r0, r1 24 | 2e: b.n 36 25 | 30: movs r2, #31 26 | 32: ands r1, r2 27 | 34: lsls r0, r1 28 | 36: movs r1, #14 29 | 38: mvns r1, r1 30 | 3a: str r0, [r1, #0] 31 | 3c: b.n 0 32 | 3e: b.n 3e 33 | -------------------------------------------------------------------------------- /code_rs/test/bin/digital_out.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zdimension/parm_extended/f3247976c2265619fe43b25d2262b79ad25e7cf4/code_rs/test/bin/digital_out.raw -------------------------------------------------------------------------------- /code_rs/test/bin/lisp.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zdimension/parm_extended/f3247976c2265619fe43b25d2262b79ad25e7cf4/code_rs/test/bin/lisp.raw -------------------------------------------------------------------------------- /code_rs/test/bin/midi.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zdimension/parm_extended/f3247976c2265619fe43b25d2262b79ad25e7cf4/code_rs/test/bin/midi.raw -------------------------------------------------------------------------------- /code_rs/test/bin/parmweb.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zdimension/parm_extended/f3247976c2265619fe43b25d2262b79ad25e7cf4/code_rs/test/bin/parmweb.raw -------------------------------------------------------------------------------- /code_rs/test/bin/plotter.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zdimension/parm_extended/f3247976c2265619fe43b25d2262b79ad25e7cf4/code_rs/test/bin/plotter.raw -------------------------------------------------------------------------------- /code_rs/test/bin/simpletelnet.bin: -------------------------------------------------------------------------------- 1 | v2.0 raw 2 | 00 f0 0b fa 82 b0 00 94 bc 46 77 46 01 97 67 46 51 43 43 43 c9 18 03 0c 14 0c 63 43 c9 18 03 0c 80 b2 92 b2 53 43 44 43 50 43 00 22 1b 19 52 41 12 04 89 18 1a 04 1b 0c 80 18 59 41 00 9c bc 46 01 9f be 46 67 46 02 b0 70 47 02 b0 00 46 00 46 82 b0 00 97 bc 46 77 46 01 97 67 46 00 af 02 48 0d 21 00 f0 f5 f9 fe de 58 05 00 00 84 b0 00 94 01 95 02 97 bc 46 77 46 03 97 67 46 02 af 03 23 14 46 9c 43 00 23 a3 42 06 d2 cd 58 c5 50 1b 1d f9 e7 cc 5c c4 54 5b 1c 93 42 fa d3 00 9c 01 9d 02 9f bc 46 03 9f be 46 67 46 04 b0 70 47 04 b0 82 b0 00 97 bc 46 77 46 01 97 67 46 00 af ff f7 d5 ff 00 9f bc 46 01 9f be 46 67 46 02 b0 70 47 02 b0 84 b0 00 94 01 96 02 97 bc 46 77 46 03 97 67 46 02 af 03 22 0b 46 93 43 00 22 9a 42 06 d2 00 24 84 50 12 1d f9 e7 00 23 83 54 52 1c 8a 42 fa d3 00 9c 01 9e 02 9f bc 46 03 9f be 46 67 46 04 b0 70 47 04 b0 82 b0 00 97 bc 46 77 46 01 97 67 46 00 af ff f7 d5 ff 00 9f bc 46 01 9f be 46 67 46 02 b0 70 47 02 b0 82 b0 00 97 bc 46 77 46 01 97 67 46 00 af ff f7 c4 ff 00 9f bc 46 01 9f be 46 67 46 02 b0 70 47 02 b0 82 b0 00 97 bc 46 77 46 01 97 67 46 00 af 00 f0 08 f8 00 9f bc 46 01 9f be 46 67 46 02 b0 70 47 02 b0 86 b0 00 93 01 94 02 95 03 96 04 97 bc 46 77 46 05 97 67 46 04 af 03 24 16 46 a6 43 81 42 08 d2 0c 1f 05 1f 00 96 00 2e 1b d0 a3 59 ab 51 36 1f f9 e7 00 24 b4 42 06 d2 0b 59 03 51 24 1d f9 e7 0b 5d 03 55 64 1c 94 42 fa d3 00 9b 01 9c 02 9d 03 9e 04 9f bc 46 05 9f be 46 67 46 06 b0 70 47 06 b0 00 9b d3 1a 51 18 49 1e 10 18 40 1e 00 2b eb d0 0a 78 02 70 5b 1e 49 1e f7 e7 84 b0 00 94 01 96 02 97 bc 46 77 46 03 97 67 46 02 af 03 23 14 46 9c 43 cb b2 0b 49 59 43 00 23 a3 42 04 d2 c1 50 1b 1d fa e7 c1 54 5b 1c 93 42 fb d3 00 9c 01 9e 02 9f bc 46 03 9f be 46 67 46 04 b0 70 47 04 b0 00 46 01 01 01 01 82 b0 00 97 bc 46 77 46 01 97 67 46 00 af 00 f0 08 f8 00 9f bc 46 01 9f be 46 67 46 02 b0 70 47 02 b0 85 b0 00 94 01 95 02 96 03 97 bc 46 77 46 04 97 67 46 03 af 85 b0 03 23 16 46 9e 43 00 24 01 ab 18 60 04 33 19 60 04 33 1a 60 04 33 00 96 b4 42 25 d2 63 58 25 58 9d 42 1a d0 22 1d 94 42 25 46 00 d8 15 46 06 19 0b 19 04 95 2c 1b 00 2c 09 d0 64 1e 71 1c 58 1c 1a 78 35 78 95 42 0e 46 03 46 f4 d0 10 e0 01 ac 20 68 61 68 a2 68 e4 68 00 9e 24 1d dc e7 0b 5d 05 5d 64 1c 9d 42 10 d1 94 42 f8 d3 00 20 00 e0 a8 1a 05 b0 00 9c 01 9d 02 9e 03 9f bc 46 04 9f be 46 67 46 05 b0 70 47 05 b0 e8 1a f1 e7 84 b0 00 94 01 96 02 97 bc 46 77 46 03 97 67 46 02 af cf 22 d4 43 02 46 0b 46 20 68 00 9c 01 9e 02 9f bc 46 03 9f be 46 67 46 04 b0 70 47 04 b0 84 b0 00 94 01 96 02 97 bc 46 77 46 03 97 67 46 02 af cf 22 d4 43 02 46 0b 46 20 68 00 9c 01 9e 02 9f bc 46 03 9f be 46 67 46 04 b0 70 47 04 b0 84 b0 00 94 01 95 02 97 bc 46 77 46 03 97 67 46 02 af cf 22 d4 43 cb 22 d5 43 02 46 0b 46 20 68 29 68 00 9c 01 9d 02 9f bc 46 03 9f be 46 67 46 04 b0 70 47 04 b0 84 b0 00 94 01 95 02 97 bc 46 77 46 03 97 67 46 02 af cf 22 d4 43 cb 22 d5 43 02 46 0b 46 20 68 29 68 00 9c 01 9d 02 9f bc 46 03 9f be 46 67 46 04 b0 70 47 04 b0 02 0c 01 d0 10 21 00 e0 20 21 00 2a 00 d0 10 46 02 0a 00 d0 08 39 00 2a 00 d0 10 46 10 28 00 d3 09 1f 10 28 00 d3 00 09 04 28 00 d3 89 1e 04 28 00 d3 80 08 02 28 02 d3 01 20 c0 43 00 e0 40 42 40 18 70 47 82 b0 00 97 bc 46 77 46 01 97 67 46 00 af 01 20 00 05 85 46 00 20 ff 20 c0 43 c1 68 00 29 02 d0 81 68 c9 b2 01 60 81 69 00 29 f6 d0 c1 69 c9 b2 81 60 f2 e7 00 46 ff 22 d2 43 00 23 08 4c 06 2b 07 d0 e5 5c 15 60 5b 1c f9 e7 03 78 13 60 49 1e 40 1c 00 29 f9 d1 0a 20 10 60 fe e7 00 46 66 05 00 00 82 b0 00 97 bc 46 77 46 01 97 67 46 00 af ff f7 e1 ff fe de 82 b0 00 97 bc 46 77 46 01 97 67 46 00 af 02 48 0d 21 ff f7 d5 ff fe de 6c 05 00 00 82 b0 00 97 bc 46 77 46 01 97 67 46 00 af 02 48 13 21 ff f7 c7 ff fe de 7a 05 00 00 82 b0 00 97 bc 46 77 46 01 97 67 46 00 af 02 48 09 21 ff f7 b9 ff fe de 8e 05 00 00 82 b0 00 97 bc 46 77 46 01 97 67 46 00 af 02 48 10 21 ff f7 ab ff fe de 98 05 00 00 82 b0 00 97 bc 46 77 46 01 97 67 46 00 af 02 48 19 21 ff f7 9d ff fe de a8 05 00 00 82 b0 00 97 bc 46 77 46 01 97 67 46 00 af 02 48 24 21 ff f7 8f ff fe de c2 05 00 00 ff 20 c0 43 00 21 05 4a 07 29 03 d0 53 5c 03 60 49 1c f9 e7 0a 21 01 60 fe e7 00 46 e6 05 00 00 75 6e 6b 6e 6f 77 6e 20 70 61 6e 69 63 00 50 41 4e 49 43 3a 75 6e 77 72 61 70 5f 66 61 69 6c 65 64 00 69 6e 64 65 78 20 6f 75 74 20 6f 66 20 62 6f 75 6e 64 73 00 70 61 6e 69 63 5f 66 6d 74 00 62 6f 72 72 6f 77 5f 6d 75 74 20 65 72 72 6f 72 73 6c 69 63 65 20 69 6e 64 65 78 20 6f 75 74 20 6f 66 20 62 6f 75 6e 64 73 00 73 6c 69 63 65 20 69 6e 64 65 78 20 73 74 61 72 74 20 69 73 20 6c 61 72 67 65 72 20 74 68 61 6e 20 65 6e 64 68 61 6e 64 6c 65 72 00 3 | -------------------------------------------------------------------------------- /code_rs/test/bin/simpletelnet.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zdimension/parm_extended/f3247976c2265619fe43b25d2262b79ad25e7cf4/code_rs/test/bin/simpletelnet.raw -------------------------------------------------------------------------------- /code_rs/test/bin/telnet_video.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zdimension/parm_extended/f3247976c2265619fe43b25d2262b79ad25e7cf4/code_rs/test/bin/telnet_video.raw -------------------------------------------------------------------------------- /code_rs/test/bin/test.bin: -------------------------------------------------------------------------------- 1 | v2.0 raw 2 | e7fe 200d 43c0 6801 2280 430a 6002 2101 0389 6802 438a 6002 e7fd 3 | -------------------------------------------------------------------------------- /code_rs/test/bin/test.s: -------------------------------------------------------------------------------- 1 | run: 2 | 0: movs r0, #13 3 | 2: mvns r0, r0 4 | 4: ldr r1, [r0, #0] 5 | 6: movs r2, #128 ; 0x80 6 | 8: orrs r2, r1 7 | a: str r2, [r0, #0] 8 | c: movs r1, #1 9 | e: lsls r1, r1, #14 10 | 10: ldr r2, [r0, #0] 11 | 12: bics r2, r1 12 | 14: str r2, [r0, #0] 13 | 16: b.n 16 14 | -------------------------------------------------------------------------------- /code_rs/test/bin/testdyn.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zdimension/parm_extended/f3247976c2265619fe43b25d2262b79ad25e7cf4/code_rs/test/bin/testdyn.bin -------------------------------------------------------------------------------- /code_rs/test/bin/testdyn.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zdimension/parm_extended/f3247976c2265619fe43b25d2262b79ad25e7cf4/code_rs/test/bin/testdyn.raw -------------------------------------------------------------------------------- /code_rs/test/bin/testfp.bin: -------------------------------------------------------------------------------- 1 | v2.0 raw 2 | 70 e0 db e2 e2 e2 e9 e2 80 b5 00 af 01 48 06 21 bc f2 fe de ee 05 00 00 80 b5 00 af 01 48 0d 21 b4 f2 fe de f4 05 00 00 00 2a 05 d0 0b 78 03 70 52 1e 49 1c 40 1c f7 e7 70 47 00 29 04 d0 00 22 02 70 49 1e 40 1c f8 e7 70 47 80 b5 00 af 0f 22 d3 43 1a 68 10 46 80 bd f0 b5 03 af 85 b0 0b 46 0b 21 cc 43 1d 49 00 90 22 68 1d 48 82 42 00 db 8a 1a 01 20 01 90 01 04 02 2b 14 46 00 d0 0c 46 10 12 40 43 00 12 02 90 00 20 c5 43 1e 04 03 91 04 94 03 98 30 18 00 12 09 12 32 12 4a 43 11 12 41 43 24 12 02 98 44 43 20 02 0f 22 d2 43 13 68 6b 43 18 02 07 d0 04 9a 82 18 04 92 01 98 40 04 36 18 6d 42 e5 e7 00 98 04 49 88 42 01 dc 04 98 01 e0 04 98 40 42 05 b0 f0 bd 00 46 3f 24 03 00 20 92 01 00 fe b5 06 af ff b0 ff b0 82 b0 3f 20 c6 43 03 20 70 60 f1 6a 00 29 0f d0 32 46 38 32 0b 07 08 d1 52 1c 09 09 fa e7 0f 23 0b 40 30 33 33 60 52 1c 09 09 00 2a f7 d1 01 e0 30 21 31 60 2e 25 35 60 fb 49 71 60 f2 6a 12 0c 00 2a 05 d0 0f 23 13 40 30 33 33 60 12 09 f7 e7 20 24 00 22 f5 4b 34 60 01 2a 02 d0 9c 5c 52 1c f9 e7 05 95 20 22 32 60 07 23 73 60 f3 6a 00 2b 0f d0 34 46 38 34 1d 07 08 d1 64 1c 1b 09 fa e7 0f 25 1d 40 30 35 35 60 64 1c 1b 09 00 2c f7 d1 01 e0 30 23 33 60 05 9d 35 60 71 60 f1 6a 09 0c 00 29 05 d0 0f 23 0b 40 30 33 33 60 09 09 f7 e7 00 21 f0 4b 32 60 03 29 02 d0 5a 5c 49 1c f9 e7 20 24 34 60 1a 21 71 60 f1 6a 00 29 0f d0 32 46 38 32 0b 07 08 d1 52 1c 09 09 fa e7 0f 23 0b 40 30 33 33 60 52 1c 09 09 00 2a f7 d1 01 e0 30 21 31 60 35 60 e0 49 71 60 f1 6a 09 0c 00 29 05 d0 0f 22 0a 40 30 32 32 60 09 09 f7 e7 0a 23 00 21 da 4a 33 60 06 29 02 d0 53 5c 49 1c f9 e7 34 60 05 21 71 60 f1 6a 00 29 0f d0 32 46 38 32 0b 07 08 d1 52 1c 09 09 fa e7 0f 23 0b 40 30 33 33 60 52 1c 09 09 00 2a f7 d1 01 e0 30 21 31 60 35 60 cb 49 71 60 f1 6a 09 0c 00 29 05 d0 0f 22 0a 40 30 32 32 60 09 09 f7 e7 0a 21 02 91 31 60 40 03 02 21 01 90 fa f6 00 21 04 90 03 90 c1 4a 04 29 03 d0 53 5c 33 60 49 1c f9 e7 34 60 00 21 71 60 f2 6a 00 2a 0f d0 33 46 38 33 10 07 08 d1 5b 1c 12 09 fa e7 0f 20 10 40 30 30 30 60 5b 1c 12 09 00 2b f7 d1 01 e0 30 22 32 60 35 60 b2 48 70 60 f0 6a 02 0c 00 2a 05 d0 0f 20 10 40 30 30 30 60 12 09 f7 e7 ad 48 34 60 03 29 02 d0 44 5c 49 1c f9 e7 20 24 34 60 04 98 00 28 04 d5 2d 20 30 60 04 98 40 42 03 90 03 98 00 14 70 60 f1 6a 00 29 0f d0 32 46 38 32 08 07 08 d1 52 1c 09 09 fa e7 0f 20 08 40 30 30 30 60 52 1c 09 09 00 2a f7 d1 01 e0 30 20 30 60 35 60 03 98 80 b2 98 49 00 28 0c d0 48 43 00 0c 70 60 f0 6a 00 0c 00 28 07 d0 0f 21 01 40 30 31 31 60 00 09 f7 e7 30 20 30 60 02 98 30 60 01 21 01 98 88 f6 00 21 8d 4a 04 29 03 d0 53 5c 33 60 49 1c f9 e7 34 60 00 21 71 60 f2 6a 00 2a 0f d0 33 46 38 33 15 07 08 d1 5b 1c 12 09 fa e7 0f 25 15 40 30 35 35 60 5b 1c 12 09 00 2b f7 d1 01 e0 30 22 32 60 05 9a 32 60 7a 4a 72 60 f2 6a 12 0c 00 2a 05 d0 0f 23 13 40 30 33 33 60 12 09 f7 e7 75 4a 34 60 03 29 02 d0 54 5c 49 1c f9 e7 20 21 31 60 00 28 02 46 02 d5 2d 22 32 60 42 42 13 14 73 60 f3 6a 00 2b 0f d0 34 46 38 34 1d 07 08 d1 64 1c 1b 09 fa e7 0f 25 1d 40 30 35 35 60 64 1c 1b 09 00 2c f7 d1 01 e0 30 23 33 60 05 9b 33 60 92 b2 00 2a 0e d0 60 4b 5a 43 12 0c 72 60 f2 6a 12 0c 02 9c 00 2a 08 d0 0f 23 13 40 30 33 33 60 12 09 f7 e7 30 22 32 60 02 9c 00 22 59 4b 34 60 06 2a 02 d0 9c 5c 52 1c f9 e7 31 60 00 22 72 60 f3 6a 00 2b 0f d0 34 46 38 34 1d 07 08 d1 64 1c 1b 09 fa e7 0f 25 1d 40 30 35 35 60 64 1c 1b 09 00 2c f7 d1 01 e0 30 23 33 60 05 9b 33 60 44 4b 73 60 f3 6a 1b 0c 00 2b 05 d0 0f 24 1c 40 30 34 34 60 1b 09 f7 e7 43 4b 31 60 0a 2a 02 d0 99 5c 52 1c f9 e7 20 22 32 60 00 21 71 60 f3 6a 00 2b 0f d0 34 46 38 34 1d 07 08 d1 64 1c 1b 09 fa e7 0f 25 1d 40 30 35 35 60 64 1c 1b 09 00 2c f7 d1 01 e0 30 23 33 60 05 9d 35 60 2d 4b 73 60 f3 6a 1b 0c 00 2b 05 d0 0f 24 1c 40 30 34 34 60 1b 09 f7 e7 28 4b 32 60 03 29 02 d0 5a 5c 49 1c f9 e7 20 21 31 60 04 99 09 12 49 43 00 12 40 43 40 18 02 d5 2d 21 31 60 40 42 01 14 71 60 f1 6a 00 29 14 d0 32 46 38 32 0b 07 0d d1 52 1c 09 09 fa e7 00 46 88 13 00 00 34 06 00 00 0f 23 0b 40 30 33 33 60 52 1c 09 09 00 2a f7 d1 01 e0 30 21 31 60 35 60 80 b2 00 28 0d d0 10 49 41 43 08 0c 70 60 f0 6a 00 0c 00 28 07 d0 0f 21 01 40 30 31 31 60 00 09 f7 e7 30 20 30 60 0a 20 30 60 fe e7 36 06 00 00 c4 09 00 00 3a 06 00 00 d2 04 00 00 40 06 00 00 a6 0e 00 00 44 06 00 00 10 27 00 00 48 06 00 00 4c 06 00 00 52 06 00 00 3f 22 d2 43 00 23 09 4c 06 2b 03 d0 e5 5c 15 60 5b 1c f9 e7 20 23 13 60 00 29 04 d0 03 78 13 60 49 1e 40 1c f8 e7 0a 20 10 60 fe e7 02 06 00 00 80 b5 00 af 01 48 0d 21 e2 f7 fe de 08 06 00 00 80 b5 00 af 01 48 13 21 da f7 fe de 16 06 00 00 80 b5 00 af 01 48 09 21 d2 f7 fe de 2a 06 00 00 fe e7 75 6e 77 69 6e 64 75 6e 6b 6e 6f 77 6e 20 70 61 6e 69 63 00 50 41 4e 49 43 3a 75 6e 77 72 61 70 5f 66 61 69 6c 65 64 00 69 6e 64 65 78 20 6f 75 74 20 6f 66 20 62 6f 75 6e 64 73 00 70 61 6e 69 63 5f 66 6d 74 00 2a 00 20 3d 0a 00 73 71 72 74 20 3d 73 69 6e 28 29 20 3d 00 63 6f 73 28 73 69 6e 5e 32 28 29 20 2b 20 63 6f 73 5e 32 28 3 | -------------------------------------------------------------------------------- /code_rs/test/bin/testrgb.bin: -------------------------------------------------------------------------------- 1 | v2.0 raw 2 | 3c e0 ab e0 b4 e0 bd e0 81 b0 81 b0 00 97 00 af 01 48 06 21 8a f0 fe de 9a 01 00 00 81 b0 81 b0 00 97 00 af 01 48 0d 21 80 f0 fe de a0 01 00 00 00 2a 05 d0 0b 78 03 70 52 1e 49 1c 40 1c f7 e7 70 47 00 29 04 d0 00 22 02 70 49 1e 40 1c f8 e7 70 47 81 b0 81 b0 00 94 81 b0 00 95 81 b0 00 97 02 af 0f 22 d2 43 04 46 0d 46 10 68 00 9f 01 b0 00 9d 01 b0 00 9c 01 b0 01 b0 70 47 81 b0 81 b0 00 95 81 b0 00 96 81 b0 00 97 02 af ff b0 ff b0 82 b0 1e 48 41 1c 00 24 1d 4e 25 46 01 94 cb 22 52 00 82 18 91 42 2f d0 0a 78 23 2a 33 46 1a d0 2b 2a 0d d0 2d 2a 0d d0 2e 2a 0d d0 42 2a 0d d0 4f 2a 0d d0 57 2a 0d d0 62 2a 12 d1 13 4b 0a e0 11 4b 08 e0 0f 4b 06 e0 13 4b 04 e0 00 23 02 e0 0f 4b 00 e0 0f 4b 49 1c 27 22 d2 43 13 60 64 1c d5 e7 0a 2a 06 d0 7c 2a 03 d1 49 1c 6d 1c 01 9c cd e7 64 1c 49 1c ca e7 fe e7 00 46 e0 01 00 00 2f 75 11 00 b9 aa f5 00 fa cf 5b 00 42 6a a0 00 00 95 e5 00 ff ff ff 00 6f da 6e 00 3f 22 d2 43 00 23 09 4c 06 2b 03 d0 e5 5c 15 60 5b 1c f9 e7 20 23 13 60 00 29 04 d0 03 78 13 60 49 1e 40 1c f8 e7 0a 20 10 60 fe e7 ae 01 00 00 81 b0 81 b0 00 97 00 af 01 48 0d 21 e0 f7 fe de b4 01 00 00 81 b0 81 b0 00 97 00 af 01 48 13 21 d6 f7 fe de c2 01 00 00 81 b0 81 b0 00 97 00 af 01 48 09 21 cc f7 fe de d6 01 00 00 fe e7 75 6e 77 69 6e 64 75 6e 6b 6e 6f 77 6e 20 70 61 6e 69 63 00 50 41 4e 49 43 3a 75 6e 77 72 61 70 5f 66 61 69 6c 65 64 00 69 6e 64 65 78 20 6f 75 74 20 6f 66 20 62 6f 75 6e 64 73 00 70 61 6e 69 63 5f 66 6d 74 00 0a 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 7c 0a 2b 2b 2b 2b 2b 2b 2b 2b 2b 4f 2b 4f 2b 4f 2b 4f 2b 2b 2b 2b 2b 2b 2b 2b 2b 7c 0a 2b 2b 2b 2b 2b 2b 2b 4f 2b 2b 4f 4f 4f 4f 4f 2b 2b 4f 2b 2b 2b 2b 2b 2b 2b 7c 0a 2d 2d 2d 2d 2d 2d 2d 2d 4f 4f 4f 4f 4f 4f 4f 4f 4f 2d 2d 2d 2d 2d 2d 2d 2d 7c 0a 2d 4f 2d 4f 2d 4f 2d 4f 4f 4f 4f 4f 4f 4f 4f 4f 4f 4f 2d 4f 2d 4f 2d 4f 2d 7c 0a 2d 2d 4f 4f 2d 2d 4f 4f 4f 4f 4f 4f 4f 4f 4f 4f 4f 4f 4f 2d 2d 4f 4f 2d 2d 7c 0a 57 57 57 4f 57 57 4f 4f 4f 4f 57 42 4f 57 42 4f 4f 4f 4f 57 57 4f 57 57 57 7c 0a 57 57 57 57 4f 4f 4f 4f 4f 4f 42 42 4f 42 42 4f 4f 4f 4f 4f 4f 57 57 57 57 7c 0a 57 57 57 57 57 4f 62 4f 4f 4f 4f 4f 4f 4f 4f 4f 4f 4f 62 4f 57 57 57 57 57 7c 0a 2d 2d 2d 2d 62 4f 2d 62 62 62 62 62 62 62 62 62 62 62 2d 4f 62 2d 2d 2d 2d 7c 0a 2d 2d 2d 2d 2d 62 4f 2d 62 2d 2d 2d 2d 2d 2d 2d 62 2d 4f 62 2d 2d 2d 2d 2d 7c 0a 2d 2d 2d 2d 2d 2d 62 2d 2d 2d 2d 2d 2d 2d 2d 2d 2d 2d 62 2d 2d 2d 2d 2d 2d 7c 0a 2b 2b 2b 2b 2b 2b 2b 62 2b 2b 2b 2b 2b 2b 2b 2b 2b 62 2b 2b 2b 2b 2b 2b 2b 7c 0a 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 7c 0a 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 7c 0a 3 | -------------------------------------------------------------------------------- /code_rs/test/link.x: -------------------------------------------------------------------------------- 1 | MEMORY 2 | { 3 | /* NOTE 1 K = 1 KiBi = 1024 bytes */ 4 | /* TODO Adjust these memory regions to match your device memory layout */ 5 | /* These values correspond to the LM3S6965, one of the few devices QEMU can emulate */ 6 | FLASH : ORIGIN = 0x00000000, LENGTH = 64K 7 | RAM : ORIGIN = 0x00010000, LENGTH = 64K 8 | } 9 | 10 | ENTRY(run) 11 | 12 | SECTIONS 13 | { 14 | .text : 15 | { 16 | *(.start); 17 | *(.text .text.*); 18 | } > FLASH 19 | 20 | .data : 21 | { 22 | *(.rodata .rodata.*); 23 | *(.data .data.*); 24 | } > FLASH 25 | } -------------------------------------------------------------------------------- /code_rs/test/midi/elise.mid: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zdimension/parm_extended/f3247976c2265619fe43b25d2262b79ad25e7cf4/code_rs/test/midi/elise.mid -------------------------------------------------------------------------------- /code_rs/test/midi/fifth.mid: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zdimension/parm_extended/f3247976c2265619fe43b25d2262b79ad25e7cf4/code_rs/test/midi/fifth.mid -------------------------------------------------------------------------------- /code_rs/test/midi/load.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | len=$(wc -c < $1) 4 | cat <(perl -e "print pack('v', $len)") $1 | nc -N ::1 4567 -------------------------------------------------------------------------------- /code_rs/test/midi/lune.mid: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zdimension/parm_extended/f3247976c2265619fe43b25d2262b79ad25e7cf4/code_rs/test/midi/lune.mid -------------------------------------------------------------------------------- /code_rs/test/midi/ob_la_di.mid: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zdimension/parm_extended/f3247976c2265619fe43b25d2262b79ad25e7cf4/code_rs/test/midi/ob_la_di.mid -------------------------------------------------------------------------------- /code_rs/test/midi/rain.mid: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zdimension/parm_extended/f3247976c2265619fe43b25d2262b79ad25e7cf4/code_rs/test/midi/rain.mid -------------------------------------------------------------------------------- /code_rs/test/midi/zelda.mid: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zdimension/parm_extended/f3247976c2265619fe43b25d2262b79ad25e7cf4/code_rs/test/midi/zelda.mid -------------------------------------------------------------------------------- /code_rs/test/rust-toolchain.toml: -------------------------------------------------------------------------------- 1 | [toolchain] 2 | channel = "nightly" -------------------------------------------------------------------------------- /code_rs/test/scheme/accum.rkt: -------------------------------------------------------------------------------- 1 | (define (create-accumulator n) 2 | (let ((val n)) 3 | (lambda (x) (set! val (+ x val)) val))) 4 | 5 | (define a (create-accumulator 100)) 6 | (define b (create-accumulator 0)) 7 | (a 10) 8 | (a 20) 9 | (a 30) 10 | (b 1) 11 | (b 1) -------------------------------------------------------------------------------- /code_rs/test/scheme/case.ss: -------------------------------------------------------------------------------- 1 | (case (+ 7 5) 2 | [(1 2 3) 'small] 3 | [(10 11 12) 'big]) 4 | 5 | (case (- 7 5) 6 | [(1 2 3) 'small] 7 | [(10 11 12) 'big]) -------------------------------------------------------------------------------- /code_rs/test/scheme/compose.rkt: -------------------------------------------------------------------------------- 1 | ((compose - add1) 4) 2 | ; => -5 3 | 4 | ((compose add1 -) 4) 5 | ; => -3 -------------------------------------------------------------------------------- /code_rs/test/scheme/depth_flat.rkt: -------------------------------------------------------------------------------- 1 | (define depth 2 | (lambda (lst) 3 | (if (pair? lst) 4 | (+ 1 (apply max (map depth lst))) 5 | 0))) 6 | 7 | (depth "hello") 8 | (depth '(1 2 3)) 9 | (depth '(1 ((2)) 3)) 10 | 11 | (define flat 12 | (lambda (lst) 13 | (if (list? lst) 14 | (apply append (map flat lst)) 15 | (list lst)))) 16 | 17 | (flat '(a b c)) 18 | (flat '(a (b (c)) ((d e (f))) g)) -------------------------------------------------------------------------------- /code_rs/test/scheme/env.ss: -------------------------------------------------------------------------------- 1 | (define (init-interpreter) 2 | ;; Print banner 3 | (println ";; Mini-Scheme Interpreter (SI4)")) 4 | 5 | 6 | (define (interp) 7 | (init-interpreter) 8 | 9 | (let Loop () 10 | (display "Mini-Scheme> ") 11 | (let ((expr (read))) 12 | (unless (eof-object? expr) 13 | (display "=> ") 14 | (displayln expr) 15 | (Loop)))) 16 | 17 | (display "Bye\n")) 18 | 19 | (interp) -------------------------------------------------------------------------------- /code_rs/test/scheme/eval.ss: -------------------------------------------------------------------------------- 1 | ;;;; -*- coding: utf-8 -*- 2 | ;;;; 3 | ;;;; e v a l . s t k -- A simple Scheme Interpreter 4 | ;;;; 5 | ;;;; 6 | ;;;; Author: Erick Gallesio [eg@unice.fr] 7 | ;;;; Creation date: 2-Apr-2019 16:24 (eg) 8 | ;;;; Last file update: 20-Apr-2020 14:24 (eg) 9 | 10 | (load "environment.ss") 11 | 12 | ;; ====================================================================== 13 | ;; 14 | ;; Closures Management 15 | ;; 16 | ;; A closure is implemented using a list such as 17 | ;; (*closure* args body env) 18 | ;; ====================================================================== 19 | (define (make-closure args body env) 20 | (list '*closure* args body env)) 21 | 22 | (define (closure? obj) 23 | (and (pair? obj) 24 | (eq? (car obj) '*closure*))) 25 | 26 | (define closure-args cadr) 27 | (define closure-body caddr) 28 | (define closure-env cadddr) 29 | 30 | ;;======================================================================== 31 | ;; 32 | ;; Macros Management 33 | ;; 34 | ;; A macro is implemented using a list such as 35 | ;; (*macro* args body env) 36 | ;; ======================================================================== 37 | (define (make-macro args body env) 38 | (list '*macro* args body env)) 39 | 40 | (define (macro? obj) 41 | (and (pair? obj) 42 | (eq? (car obj) '*macro*))) 43 | 44 | (define macro-args cadr) 45 | (define macro-body caddr) 46 | (define macro-env cadddr) 47 | 48 | (define (macro-expand macro args) 49 | (evaluate-compound (macro-body macro) 50 | (extend-env (macro-args macro) 51 | args 52 | (macro-env macro)))) 53 | 54 | ;; ====================================================================== 55 | ; 56 | ; Evaluate 57 | ; 58 | ;; ====================================================================== 59 | (define (evaluate-compound l env) 60 | ;; Evaluate in environment env the expressions of l 61 | (if (null? (cdr l)) 62 | (evaluate (car l) env) 63 | (begin 64 | (evaluate (car l) env) 65 | (evaluate-compound (cdr l) env)))) 66 | 67 | (define (evaluate-list lst env) 68 | (map (λ (x) (evaluate x env)) lst)) 69 | 70 | 71 | (define (funcall func args env) 72 | (if (closure? func) 73 | (evaluate-compound (closure-body func) 74 | (extend-env (closure-args func) 75 | args 76 | (closure-env func))) 77 | ;; primitive call (+, -, car …) 78 | (apply func args))) 79 | 80 | (define (evaluate expr env) 81 | (cond 82 | ((symbol? expr) 83 | (find-binding expr env)) 84 | ((pair? expr) 85 | (case (car expr) 86 | ((quote) (cadr expr)) 87 | ((begin) (evaluate-compound (cdr expr) env)) 88 | ((set!) (set-binding! (cadr expr) 89 | (evaluate (caddr expr) env) env #t)) 90 | ((define) (set-binding! (cadr expr) 91 | (evaluate (caddr expr) env) env #f)) 92 | ((if) (if (evaluate (cadr expr) env) 93 | (evaluate (caddr expr) env) 94 | (evaluate (cadddr expr) env))) 95 | ((lambda) (make-closure (cadr expr) (cddr expr) env)) 96 | ((macro) (make-macro (cadr expr) (cddr expr) env)) 97 | (else (let ((select (evaluate (car expr) env))) 98 | (if (macro? select) 99 | (evaluate (macro-expand select (cdr expr)) 100 | env) 101 | (funcall select 102 | (evaluate-list (cdr expr) env) 103 | env)))))) 104 | (else expr))) 105 | 106 | ;; ====================================================================== 107 | ;; 108 | ;; Interpreter 109 | ;; 110 | ;; ====================================================================== 111 | (define (init-interpreter) 112 | ;; Print banner 113 | (printf ";; Mini-Scheme Interpreter (SI4)\n")) 114 | 115 | 116 | (define (interp) 117 | (init-interpreter) 118 | 119 | (let Loop () 120 | (display "Mini-Scheme> ") 121 | (let ((expr (read))) 122 | (unless (eof-object? expr) 123 | (let ((res (evaluate expr *global-env*))) 124 | (unless (eq? res (void)) 125 | (write res) 126 | (newline))) 127 | (Loop)))) 128 | 129 | (display "Bye\n")) 130 | -------------------------------------------------------------------------------- /code_rs/test/scheme/fibstream.rkt: -------------------------------------------------------------------------------- 1 | ;;;; A small stream library 2 | ;;;; 3 | ;;;; Author: Erick Gallesio [eg@unice.fr] 4 | ;;;; Creation date: 25-Mar-2019 12:28 5 | ;;;; Last file update: 25-Mar-2019 22:57 (eg) 6 | 7 | 8 | ;; ====================================================================== 9 | ;; Streams primitives 10 | ;; ====================================================================== 11 | (define-macro (cons-stream a b) `(cons ,a (delay ,b))) 12 | (define head car) 13 | (define (tail f) (force (cdr f))) 14 | (define stream-null? null?) 15 | (define (stream? stm) (and (pair? stm) (promise? (cdr stm)))) 16 | 17 | ;; ====================================================================== 18 | ;; Streams functions 19 | ;; ====================================================================== 20 | (define (stream-interval low high) ;;; return the stream {low low +1 ... high} 21 | (if (> low high) 22 | '() 23 | (cons-stream low (stream-interval (+ low 1) high)))) 24 | 25 | (define (integers-from n) 26 | (cons-stream n (integers-from (+ n 1)))) 27 | 28 | (define (stream-filter fct stm) 29 | ;; (printf "Stream filter on ~S\n" stm) 30 | (cond 31 | ((stream-null? stm) '()) 32 | ((pair? stm) (if (fct (head stm)) 33 | (cons-stream (head stm) 34 | (stream-filter fct (tail stm))) 35 | (stream-filter fct (tail stm)))) 36 | (else (error "bad stream " stm)))) 37 | 38 | 39 | (define (stream-ref stm k) 40 | (cond 41 | ((null? stm) (error "index too large")) 42 | ((pair? stm) (if (zero? k) 43 | (head stm) 44 | (stream-ref (tail stm) (- k 1)))) 45 | (else (error "bad stream")))) 46 | 47 | 48 | (define (stream-for-each proc stm) 49 | (unless (null? stm) 50 | (proc (head stm)) 51 | (stream-for-each proc (tail stm)))) 52 | 53 | 54 | (define (stream-add stm1 stm2) 55 | (cond 56 | ((stream-null? stm1) '()) 57 | ((stream-null? stm2) '()) 58 | (else (cons-stream (+ (head stm1) (head stm2)) 59 | (stream-add (tail stm1) 60 | (tail stm2)))))) 61 | 62 | (define (stream-mult stm1 stm2) 63 | (cond 64 | ((stream-null? stm1) '()) 65 | ((stream-null? stm2) '()) 66 | (else (cons-stream (* (head stm1) (head stm2)) 67 | (stream-mult (tail stm1) 68 | (tail stm2)))))) 69 | 70 | 71 | (define fib-stream 72 | (letrec ((aux (lambda (a b) (cons-stream b (aux b (+ a b)))))) 73 | (cons-stream 0 (aux 0 1)))) 74 | 75 | (define (stream-firsts n strm) 76 | (if (or (= n 0) (null? strm)) 77 | () 78 | (cons-stream (head strm) (stream-firsts (- n 1) (tail strm))))) 79 | 80 | (define (stream->list strm) 81 | (if (pair? strm) 82 | (cons (head strm) (stream->list (tail strm))) 83 | ())) 84 | 85 | 86 | (stream-ref fib-stream 10) 87 | (stream->list (stream-firsts 10 fib-stream)) ;; les 10 premiers nombres de Fibonacci 88 | ;(0 1 1 2 3 5 8 13 21 34) -------------------------------------------------------------------------------- /code_rs/test/scheme/fold.rkt: -------------------------------------------------------------------------------- 1 | (foldl cons '() '(1 2 3 4)) 2 | ; '(4 3 2 1) 3 | 4 | (foldl + 0 '(1 2 3 4)) 5 | ; 10 6 | 7 | (foldl (lambda (a b result) 8 | (* result (- a b))) 9 | 1 10 | '(1 2 3) 11 | '(4 5 6)) 12 | ; -27 13 | 14 | (foldr cons '() '(1 2 3 4)) 15 | ; '(1 2 3 4) 16 | 17 | (foldr (lambda (v l) (cons (add1 v) l)) '() '(1 2 3 4)) 18 | ; '(2 3 4 5) -------------------------------------------------------------------------------- /code_rs/test/scheme/hanoi.rkt: -------------------------------------------------------------------------------- 1 | (define (show . lst) 2 | (for-each (λ (x) 3 | (display x) 4 | (display " ")) 5 | lst) 6 | (newline)) 7 | 8 | (define depl (lambda (a b) (begin (show "Déplacer un disque de" a "vers" b) 1))) 9 | 10 | (define aux 11 | (lambda (n from to tmp) 12 | (if (= n 1) 13 | (depl from to) 14 | (begin 15 | (let ([p1 (aux (- n 1) from tmp to)] 16 | [p2 (depl from to)] 17 | [p3 (aux (- n 1) tmp to from)]) 18 | (+ p1 p2 p3)))))) 19 | 20 | (define hanoi 21 | (lambda (n) 22 | (if (> n 0) 23 | (aux n 'a 'b 'c)))) 24 | 25 | (hanoi 0) 26 | (hanoi 3) -------------------------------------------------------------------------------- /code_rs/test/scheme/load.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | cat <( \ 4 | sed 's/\xce\xbb/lambda/g' $1 | \ 5 | dos2unix | \ 6 | iconv -f utf8 -t ascii//TRANSLIT \ 7 | ) <(printf "\x4") | \ 8 | nc -N ::1 4567 -------------------------------------------------------------------------------- /code_rs/test/scheme/macro_case.rkt: -------------------------------------------------------------------------------- 1 | (define-macro (case2 clé . clauses) 2 | `(let ((c ,clé)) 3 | (cond 4 | ,@(map (λ (clause) 5 | (if (eq? 'else (car clause)) 6 | clause 7 | `((memv c ',(car clause)) ,@(cdr clause)))) 8 | clauses)))) 9 | 10 | (case2 (+ 2 3) 11 | ((1 2 3 4) 'petit) 12 | ((5 6 7 8) 'moyen) 13 | (else 'grand)) 14 | 15 | (writeln (macro-expand `(case2 (+ 2 3) 16 | ((1 2 3 4) 'petit) 17 | ((5 6 7 8) 'moyen) 18 | (else 'grand)))) -------------------------------------------------------------------------------- /code_rs/test/scheme/macro_def_func.rkt: -------------------------------------------------------------------------------- 1 | (define-macro (define-func params . body) 2 | (let ((fname (car params)) (args (cdr params))) 3 | `(define (,fname ,@(map car args)) 4 | ,@(map (lambda (arg) 5 | (if (pair? (cdr arg)) 6 | `(unless ,(reverse arg) 7 | (error ,(apply format "incorrect type for ~a (expected ~a)" arg))))) 8 | args) 9 | ,@body))) 10 | 11 | (macro-expand '(define-func (puissance (x) (y integer?)) 12 | (expt x y))) 13 | 14 | (define-func (puissance (x) (y integer?)) 15 | (expt x y)) 16 | 17 | (puissance 2 4) 18 | (puissance 'a 2) 19 | (puissance 2 'a) 20 | -------------------------------------------------------------------------------- /code_rs/test/scheme/macro_for.rkt: -------------------------------------------------------------------------------- 1 | (define-macro (for params . instrs) 2 | `(let ( 3 | (départ ,(cadr params)) 4 | (fin ,(caddr params)) 5 | (pas ,(cadddr params)) 6 | ) 7 | (letrec ((cmp (if (< pas 0) > <)) 8 | (loop (lambda (,(car params)) 9 | (if (cmp ,(car params) fin) 10 | (begin 11 | ,@instrs 12 | (loop (+ ,(car params) pas))))))) 13 | (loop départ)))) 14 | 15 | (macro-expand '(for (i (+ 3 2) 0 -1) (display i) (newline))) 16 | 17 | (for (i 5 0 -1) (display i) (newline)) 18 | -------------------------------------------------------------------------------- /code_rs/test/scheme/macro_lambda_star.rkt: -------------------------------------------------------------------------------- 1 | (define-macro (lambda* . overloads) 2 | `(lambda args 3 | (let ((len (length args))) 4 | (case len 5 | ,@(map (lambda (o) `((,(length (car o))) (apply (lambda ,(car o) ,@(cddr o)) args))) overloads) 6 | (else (error "pas de corps pour une liste de longueur " len)))))) 7 | 8 | (define foo 9 | (lambda* 10 | (() => 'zero) 11 | ((x) => (list 'one x)) 12 | ((x y) => (list 'two x y)) 13 | ((x y z w) => (displayln "4e clause") (list 'four x y z w)))) 14 | 15 | (println (foo)) 16 | (println (foo 1)) 17 | (println ( foo 1 2)) 18 | (println (foo 1 2 3 4)) -------------------------------------------------------------------------------- /code_rs/test/scheme/macro_named_let.rkt: -------------------------------------------------------------------------------- 1 | (define-macro (named-let name bindings body) 2 | `(letrec ((,name (lambda ,(map car bindings) ,body))) 3 | (,name ,@(map cadr bindings)))) 4 | 5 | (named-let Loop ((i 0)) 6 | (when (< i 10) 7 | (displayln i) 8 | (Loop (+ i 1)))) -------------------------------------------------------------------------------- /code_rs/test/scheme/macro_oop.rkt: -------------------------------------------------------------------------------- 1 | (define (create-card n) 2 | (let ((val n)) 3 | (lambda (msg) 4 | (case msg 5 | ('decr! (set! val (- val 1))) 6 | ('show-count val) 7 | (else (error "invalid")))))) 8 | 9 | (define C1 (create-card 50)) 10 | (C1 'decr!) 11 | (C1 'show-count) 12 | 13 | (define (create-protected-card n pass) 14 | (let ((super (create-card n)) (logged #f)) 15 | (lambda (msg . args) 16 | (case msg 17 | ('password 18 | (if (equal? (list pass) args) 19 | (set! logged #t) 20 | (error "Bad password"))) 21 | ('remove (set! logged #f)) 22 | ('show-count (super 'show-count)) 23 | (else 24 | (if logged 25 | (apply super msg args) 26 | (error "No password given"))))))) 27 | 28 | (define C2 (create-protected-card 50 1234)) ;; password = "1234" 29 | (C2 'show-count) 30 | (C2 'decr!) 31 | (C2 'password 12) 32 | (C2 'password 1234) 33 | (C2 'decr!) 34 | (C2 'decr!) 35 | (C2 'show-count) 36 | (C2 'remove) 37 | (C2 'decr!)c -------------------------------------------------------------------------------- /code_rs/test/scheme/macro_record.rkt: -------------------------------------------------------------------------------- 1 | 2 | (define-macro (define-record name fields) 3 | `(define (,name) 4 | (let ,(map (lambda (f) (list f #f)) fields) 5 | (lambda (msg . args) 6 | (case msg 7 | ((type) ',name) 8 | ((print) (printf "#<~a" ',name) 9 | ,@(map (lambda (f) `(printf " ~a=~s" ',f ,f)) fields) 10 | (printf ">\n")) 11 | ,@(map (lambda (f) `((,(string->symbol (format "get-~a" f))) ,f)) fields) 12 | ,@(map (lambda (f) `((,(string->symbol (format "set-~a!" f))) (set! ,f (car args)))) fields) 13 | (else (error "Accesseur inconnu" msg))))))) 14 | 15 | (define-macro (make-record name . fields) 16 | (letrec ((proc (lambda (lst) 17 | (if (null? lst) '() 18 | (cons `(rec ',(string->symbol (format "set-~a!" (cadr (car lst)))) ,(cadr lst)) (proc (cddr lst))))))) 19 | `(let ((rec (,name))) 20 | ,@(proc fields) 21 | rec))) 22 | 23 | 24 | 25 | (writeln (macro-expand '(define-record Point (x y)))) 26 | (define-record Point (x y)) 27 | (define p (make-record Point)) 28 | (p 'type) 29 | (p 'set-x! 12) 30 | (p 'print) 31 | (define p2 (make-record Point 'y 20 'x 0)) 32 | (p2 'print) 33 | (define p3 (make-record Point 'y 100)) 34 | (p3 'print) 35 | -------------------------------------------------------------------------------- /code_rs/test/scheme/macro_stack.rkt: -------------------------------------------------------------------------------- 1 | (define-macro (prog1 e1 . en) 2 | `(begin 3 | (define res ,e1) 4 | ,@en 5 | res)) 6 | 7 | (define-macro (push! stack x) 8 | `(set! ,stack (cons ,x ,stack))) 9 | 10 | (define-macro (pop! stack) 11 | `(prog1 (car ,stack) (set! ,stack (cdr ,stack)))) 12 | 13 | (define p '()) 14 | (push! p 1) 15 | (push! p 2) 16 | (pop! p) 17 | (pop! p) 18 | -------------------------------------------------------------------------------- /code_rs/test/scheme/macro_trace.rkt: -------------------------------------------------------------------------------- 1 | (define (simple-trace-function func name) 2 | (lambda args 3 | (printf "Calling ~a\n" (cons name args)) 4 | (let ((res (apply func args))) 5 | (printf "Result: ~a\n" res) 6 | res))) 7 | 8 | (define fib (λ (n) (if (< n 2) n (+ (fib (- n 1)) (fib (- n 2)))))) 9 | (set! fib (simple-trace-function fib 'fib)) 10 | (fib 3) -------------------------------------------------------------------------------- /code_rs/test/scheme/macro_while.rkt: -------------------------------------------------------------------------------- 1 | (define-macro (while expr . corps) 2 | `(letrec 3 | ((loop (lambda () (if ,expr (begin ,@corps (loop)))))) 4 | (loop))) 5 | 6 | (let ((i 0)) 7 | (while (< i 5) 8 | (print i) 9 | (set! i (+ i 1)))) -------------------------------------------------------------------------------- /code_rs/test/scheme/named_let.rkt: -------------------------------------------------------------------------------- 1 | (define L '()) 2 | (let Loop ((i 0)) 3 | (set! L Loop) 4 | (when (< i 5) 5 | (displayln i) 6 | (Loop (+ i 1)))) -------------------------------------------------------------------------------- /code_rs/test/scheme/prog1.rkt: -------------------------------------------------------------------------------- 1 | (define-macro (prog1 e1 . en) 2 | `(begin 3 | (define res ,e1) 4 | ,@en 5 | res)) 6 | 7 | (define l '(a b c)) 8 | (writeln (macro-expand `(prog1 (car l) (set! l (cdr l))))) 9 | (prog1 (car l) (set! l (cdr l))) ;; équivalent à pop 10 | l -------------------------------------------------------------------------------- /code_rs/test/scheme/quasiquote.ss: -------------------------------------------------------------------------------- 1 | (define a 123) 2 | (define b '(4 5 6)) 3 | (define c 789) 4 | `5 5 | `(5) 6 | `a 7 | `b 8 | `,a 9 | `(,a) 10 | `(,a ,@b ,c) 11 | `(,a . ,c) 12 | `(,a . ,b) 13 | `(,a unquote c) 14 | -------------------------------------------------------------------------------- /code_rs/test/scheme/tco.rkt: -------------------------------------------------------------------------------- 1 | (define (tcotest n acc) 2 | (if (= n 0) 3 | acc 4 | (tcotest (- n 1) (+ acc 1)))) 5 | 6 | (displayln "begin") 7 | (displayln (tcotest 20 0)) -------------------------------------------------------------------------------- /code_rs/test/scheme/test_cond.rkt: -------------------------------------------------------------------------------- 1 | (cond) 2 | (cond 3 | [else 5]) 4 | ; sc5 5 | 6 | (cond 7 | [(positive? -5) (error "doesn't get here")] 8 | [(zero? -5) (error "doesn't get here, either")] 9 | [(positive? 5) 'here]) 10 | ; 'here 11 | 12 | (cond 13 | [(member 2 '(1 2 3)) => (lambda (l) (map - l))]) 14 | ; '(-2 -3) 15 | 16 | (cond 17 | [(member 2 '(1 2 3))]) 18 | ; '(2 3) -------------------------------------------------------------------------------- /code_rs/test/scheme/test_dot.ss: -------------------------------------------------------------------------------- 1 | (define-macro (mac . lst) 2 | `(begin 3 | (define y 5) 4 | ,@lst)) 5 | 6 | (mac 7 | (define x 1) 8 | (displayln y)) -------------------------------------------------------------------------------- /code_rs/test/scheme/trees.rkt: -------------------------------------------------------------------------------- 1 | (define (vide) 'vide) 2 | (define (vide? arbre) (equal? (vide) arbre)) 3 | 4 | (define (arbre racine gauche droite) (list racine gauche droite)) 5 | (define (racine arbre) (car arbre)) 6 | (define (gauche arbre) (car (cdr arbre))) 7 | (define (droite arbre) (car (cdr (cdr arbre)))) 8 | 9 | (print (vide? (vide))) 10 | (print (vide? 19)) 11 | 12 | (define A (arbre 10 (vide) (vide))) 13 | (print (racine A)) 14 | (print (vide? (gauche A))) 15 | (print (vide? A)) 16 | 17 | (define A (arbre 10 (vide) (vide))) 18 | (define B (arbre 1 (vide) (vide))) 19 | (define C (arbre 5 B A)) 20 | (print (map racine (list A B C))) 21 | (print (eq? (gauche C) A)) 22 | (print (eq? (droite C) A)) 23 | (print (eq? (gauche C) B)) 24 | (print (eq? (droite C) B)) 25 | 26 | "" 27 | 28 | (define (ajouter val a) 29 | (if (vide? a) 30 | (arbre val (vide) (vide)) 31 | (let ([rac (racine a)]) 32 | (cond 33 | ((< val rac) (arbre rac (ajouter val (gauche a)) (droite a))) 34 | ((> val rac) (arbre rac (gauche a) (ajouter val (droite a)))) 35 | (else a))))) 36 | 37 | (define (appartient? val a) 38 | (if (vide? a) 39 | #f 40 | (let ([rac (racine a)]) 41 | (cond 42 | ((< val rac) (appartient? val (gauche a))) 43 | ((> val rac) (appartient? val (droite a))) 44 | (else #t))))) 45 | 46 | (define A (ajouter 10 (vide))) 47 | (define B (ajouter 1 (ajouter 15 A))) 48 | 49 | (print (racine A)) 50 | (print (racine B)) 51 | 52 | (define A (ajouter 10 (vide))) 53 | (define B (ajouter 1 (ajouter 15 A))) 54 | 55 | (print (racine (gauche B))) 56 | (print (racine (droite B))) 57 | 58 | (define A (ajouter 10 (vide))) 59 | (define B (ajouter 1 (ajouter 15 A))) 60 | 61 | (appartient? 10 A) 62 | (appartient? 7 A) 63 | 64 | (define A (ajouter 10 (vide))) 65 | (define B (ajouter 1 (ajouter 15 A))) 66 | 67 | (print (map (lambda (x) (appartient? x B)) 68 | '(1 5 10 15 20))) 69 | 70 | (define (construire a liste) 71 | (if (null? liste) a 72 | (construire (ajouter (car liste) a) (cdr liste)))) 73 | 74 | (define (parcourir a) 75 | (if (vide? a) 76 | (list) 77 | (append (parcourir (gauche a)) (list (racine a)) (parcourir (droite a))))) 78 | 79 | (define (trier liste) 80 | (parcourir (construire (vide) liste))) 81 | "" 82 | (trier '(10 20 -8 0 9 100 1)) 83 | (trier '(3 2 1)) 84 | (trier '()) 85 | 86 | (define (construire-ajouter fct) 87 | (define aux (lambda (val a) 88 | (if (vide? a) 89 | (arbre val (vide) (vide)) 90 | (let ([rac (racine a)]) 91 | (if 92 | (fct val rac) 93 | (arbre rac (aux val (gauche a)) (droite a)) 94 | (arbre rac (gauche a) (aux val (droite a)))))))) 95 | aux) 96 | 97 | (define ajouter-nombre (construire-ajouter <)) 98 | (define A (ajouter-nombre 10 (vide))) 99 | 100 | (define ajouter-nombre (construire-ajouter <)) 101 | (define A (ajouter-nombre 10 (ajouter-nombre 6 (ajouter-nombre 17 (vide))))) 102 | (define B (ajouter-nombre 6 (ajouter-nombre 17 (ajouter-nombre 10 (vide))))) 103 | -------------------------------------------------------------------------------- /code_rs/test/src/ball.rs: -------------------------------------------------------------------------------- 1 | #![no_main] 2 | #![no_std] 3 | #![feature(min_specialization)] 4 | #![feature(associated_type_defaults)] 5 | #![feature(iter_order_by)] 6 | #![feature(step_trait)] 7 | #![feature(slice_pattern)] 8 | 9 | use crate::parm::math::fp32; 10 | use crate::parm::screen; 11 | 12 | use crate::parm::screen::{ColorSimple}; 13 | 14 | use crate::screen::{rect}; 15 | use derive_more::{Add, AddAssign, Mul}; 16 | 17 | mod parm; 18 | 19 | #[derive(Copy, Clone, Add, AddAssign, Default, Mul)] 20 | struct Vec2(fp32, fp32); 21 | 22 | fn main() { 23 | let mut p = Vec2::default(); 24 | let mut v = Vec2(fp32::from(5), fp32::ZERO); 25 | let a = Vec2(fp32::ZERO, fp32::from(9.81)); 26 | let dt = fp32::from(0.1); 27 | while !(p.1 == fp32::from(screen::HEIGHT - 1) && v.1 == fp32::ZERO) { 28 | let mut v_next = v + a * dt; 29 | let mut p_next = p + v_next * dt; 30 | let mut damping = fp32::from(0.85); 31 | if p_next.0 < fp32::ZERO { 32 | v_next.0 = -v_next.0; 33 | p_next.0 = -p_next.0; 34 | } else if p_next.0 >= fp32::from(screen::WIDTH) { 35 | v_next.0 = -v_next.0; 36 | p_next.0 = fp32::from(2) * fp32::from(screen::WIDTH) - p_next.0; 37 | } else if p_next.1 < fp32::ZERO { 38 | v_next.1 = -v_next.1; 39 | p_next.1 = -p_next.1; 40 | } else if p_next.1 >= fp32::from(screen::HEIGHT) { 41 | v_next.1 = -v_next.1; 42 | p_next.1 = fp32::from(2) * fp32::from(screen::HEIGHT) - p_next.1; 43 | } else { 44 | damping = fp32::from(1); 45 | } 46 | rect( 47 | p_next.0.round() as isize, 48 | p_next.1.round() as isize, 49 | 2, 50 | 2, 51 | ColorSimple::Red, 52 | ); 53 | v = Vec2(v_next.0, v_next.1 * damping); 54 | p = p_next; 55 | } 56 | } 57 | -------------------------------------------------------------------------------- /code_rs/test/src/calckeyb.rs: -------------------------------------------------------------------------------- 1 | #![feature(min_specialization)] 2 | #![feature(step_trait)] 3 | #![no_main] 4 | #![no_std] 5 | 6 | use crate::parm::keyb::read_key; 7 | 8 | use crate::parm::mmio::RES; 9 | use crate::parm::tty::read_int; 10 | 11 | mod parm; 12 | 13 | fn main() { 14 | 'main: 15 | loop { 16 | print!("A = "); 17 | let a = read_int(); 18 | 19 | print!("B = "); 20 | let b = read_int(); 21 | 22 | println!("+-*/%&|^"); 23 | loop { 24 | let choice = read_key(); 25 | let res = match choice as u8 { 26 | b'+' => a + b, 27 | b'-' => a - b, 28 | b'*' => a * b, 29 | b'/' => a / b, 30 | //b'%' => math::r#mod(a, b), 31 | b'&' => a & b, 32 | b'|' => a | b, 33 | b'^' => a ^ b, 34 | b'\n' => continue 'main, 35 | _ => continue, 36 | }; 37 | RES.write(res); 38 | } 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /code_rs/test/src/calculator.rs: -------------------------------------------------------------------------------- 1 | // deprecated program 2 | 3 | 4 | 5 | #![feature(generic_associated_types)] 6 | #![no_main] 7 | #![no_std] 8 | 9 | use crate::parm::mmio::{DIP1, DIP2, DIP3, RES}; 10 | 11 | mod parm; 12 | 13 | fn main() { 14 | loop { 15 | let (a, b) = (DIP1.read(), DIP2.read()); 16 | RES.write(match DIP3.read() { 17 | 0 => a + b, 18 | 1 => a - b, 19 | 2 => a * b, 20 | 3 => a << b, 21 | _ => continue, 22 | }); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /code_rs/test/src/lisp/env.rs: -------------------------------------------------------------------------------- 1 | use crate::parm::heap::budmap::{BudMap, Entry, Iter}; 2 | use crate::parm::heap::string::String; 3 | 4 | use crate::{InsertionState, LispValBox, Prc, print}; 5 | use core::hash::{Hash, Hasher}; 6 | use crate::parm::tty::{Display, DisplayTarget}; 7 | 8 | #[derive(Hash)] 9 | pub(crate) struct SymbolMap(BudMap); 10 | 11 | type SymbolEntry<'map> = Entry<'map, String, LispValBox>; 12 | 13 | impl SymbolMap { 14 | pub(crate) fn new() -> Self { 15 | SymbolMap(BudMap::default()) 16 | } 17 | 18 | pub(crate) fn get(&self, s: &String) -> Option { 19 | self.0.get(s).cloned() 20 | } 21 | 22 | fn entry(&mut self, s: &String) -> Entry<'_, String, LispValBox> { 23 | self.0.entry_ref(s) 24 | } 25 | 26 | fn contains(&self, s: &String) -> bool { 27 | self.0.contains(s) 28 | } 29 | 30 | pub(crate) fn set(&mut self, s: String, v: LispValBox) { 31 | self.0.set(s, v); 32 | } 33 | 34 | pub fn len(&self) -> usize { 35 | self.0.len() 36 | } 37 | } 38 | 39 | impl Display for SymbolMap { 40 | fn write(&self, target: &mut impl DisplayTarget) { 41 | print!('{', => target); 42 | let mut first = true; 43 | for (key, value) in self.0.iter() { 44 | if first { 45 | first = false; 46 | } else { 47 | print!(", ", => target); 48 | } 49 | print!(key, ": ", value, => target); 50 | } 51 | print!('}', => target); 52 | } 53 | } 54 | 55 | pub(crate) struct SchemeEnvData { 56 | pub(crate) map: SymbolMap, 57 | pub(crate) parent: Option, 58 | pub(crate) trace: bool, 59 | } 60 | 61 | impl Hash for SchemeEnvData { 62 | fn hash(&self, state: &mut H) { 63 | self.map.hash(state); 64 | self.parent.as_ref().map(|prc| prc.0.ptr).hash(state); 65 | } 66 | } 67 | 68 | #[derive(Clone)] 69 | pub struct SchemeEnv(pub(crate) Prc); 70 | 71 | impl Hash for SchemeEnv { 72 | fn hash(&self, state: &mut H) { 73 | self.0.ptr.hash(state); 74 | } 75 | } 76 | 77 | impl PartialEq for SchemeEnv { 78 | fn eq(&self, other: &Self) -> bool { 79 | self.0.ptr == other.0.ptr 80 | } 81 | } 82 | 83 | impl Eq for SchemeEnv {} 84 | 85 | impl SchemeEnv { 86 | pub fn iter(&self) -> Iter<'_, String, LispValBox> { 87 | self.0.map.0.iter() 88 | } 89 | 90 | pub fn get(&self, s: &String) -> Option { 91 | if let Some(res) = self.0.map.get(s) { 92 | Some(res) 93 | } else { 94 | self.0.parent.as_ref().and_then(|p| p.get(s)) 95 | } 96 | } 97 | 98 | //#[inline(never)] 99 | pub fn set_new(&mut self, s: String, v: LispValBox) { 100 | self.0.borrow_mut().map.set(s, v); 101 | } 102 | 103 | //#[inline(never)] 104 | fn set_rec(&mut self, s: String, v: LispValBox, root: bool) -> InsertionState { 105 | let mut bo = self.0.borrow_mut(); 106 | let SchemeEnvData { 107 | ref mut map, 108 | ref mut parent, 109 | .. 110 | } = *bo; 111 | let entry = map.entry(&s); 112 | match entry { 113 | Entry::Occupied(e) => { 114 | let _ = e.replace(v); 115 | InsertionState::Inserted 116 | } 117 | Entry::Vacant(e) => match parent { 118 | Some(p) => { 119 | let inserted = p.set_rec(s, v, false); 120 | if let InsertionState::NotFound(v) = inserted { 121 | if root { 122 | e.insert(v); 123 | InsertionState::Inserted 124 | } else { 125 | InsertionState::NotFound(v) 126 | } 127 | } else { 128 | InsertionState::Inserted 129 | } 130 | } 131 | None => { 132 | if root { 133 | e.insert(v); 134 | InsertionState::Inserted 135 | } else { 136 | InsertionState::NotFound(v) 137 | } 138 | } 139 | }, 140 | } 141 | } 142 | 143 | pub fn set(&mut self, s: String, v: LispValBox) { 144 | self.set_rec(s, v, true); 145 | } 146 | 147 | pub(crate) fn make_child(&self) -> SchemeEnv { 148 | SchemeEnv(Prc::new(SchemeEnvData { 149 | map: SymbolMap::new(), 150 | parent: Some(self.clone()), 151 | trace: self.0.trace, 152 | })) 153 | } 154 | } 155 | 156 | impl Default for SchemeEnv { 157 | fn default() -> Self { 158 | Self(Prc::new(SchemeEnvData::default())) 159 | } 160 | } 161 | -------------------------------------------------------------------------------- /code_rs/test/src/lisp/eval.rs: -------------------------------------------------------------------------------- 1 | use crate::{LispValBox, makestr}; 2 | use crate::lisp::env::SchemeEnv; 3 | use crate::lisp::val::{LispList, LispSymbol, LispVal}; 4 | use crate::parm::heap::string::String; 5 | 6 | mod builtins; 7 | mod call; 8 | mod conditionals; 9 | mod forms; 10 | mod lambda; 11 | mod r#let; 12 | mod quote; 13 | 14 | impl SchemeEnv { 15 | pub(crate) fn eval_begin(&mut self, mut instrs: &LispList) -> Result { 16 | while let LispList::Cons(cur, next) = instrs { 17 | if matches!(**next, LispVal::List(LispList::Empty)) { 18 | return self.eval_inner(cur); 19 | } 20 | self.eval(cur)?; 21 | instrs = next.expect_list("begin")?; 22 | } 23 | Ok(CallEvaluation::Normal(LispVal::Void.into())) 24 | } 25 | 26 | pub(crate) fn eval_inner(&mut self, expr: &LispValBox) -> Result { 27 | match &**expr { 28 | LispVal::Symbol(LispSymbol { name, .. }) => return self 29 | .get(name) 30 | .ok_or_else(|| makestr!("unknown symbol: ", name)) 31 | .map(CallEvaluation::Normal), 32 | LispVal::List(items) => { 33 | Ok(CallEvaluation::Tail((self.clone(), items.clone()))) 34 | } 35 | _ => return Ok(CallEvaluation::Normal(expr.clone())), 36 | } 37 | } 38 | 39 | pub(crate) fn eval_tco(&mut self, mut tco: CallEvaluation) -> Result { 40 | loop { 41 | match tco { 42 | CallEvaluation::Normal(val) => return Ok(val), 43 | CallEvaluation::Tail((mut env, items)) => { 44 | if items.is_empty() { 45 | return Ok(LispVal::Void.into()); // empty list 46 | } 47 | 48 | tco = env.eval_form(&items)? 49 | } 50 | } 51 | } 52 | } 53 | 54 | pub fn eval(&mut self, expr: &LispValBox) -> Result { 55 | let f = self.eval_inner(expr)?; 56 | self.eval_tco(f) 57 | } 58 | } 59 | 60 | pub enum CallEvaluation { 61 | Tail((SchemeEnv, LispList)), 62 | Normal(LispValBox), 63 | } 64 | 65 | impl From for CallEvaluation { 66 | fn from(v: LispValBox) -> Self { 67 | CallEvaluation::Normal(v) 68 | } 69 | } 70 | 71 | impl From for CallEvaluation { 72 | fn from(v: LispVal) -> Self { 73 | CallEvaluation::Normal(v.into()) 74 | } 75 | } -------------------------------------------------------------------------------- /code_rs/test/src/lisp/eval/builtins.rs: -------------------------------------------------------------------------------- 1 | use crate::lisp::env::{SchemeEnv, SchemeEnvData, SymbolMap}; 2 | use crate::lisp::val::{LispList, LispProc, LispVal, ProcEvalMode, ProcType}; 3 | 4 | use crate::parm::heap::string::String; 5 | 6 | 7 | use crate::{print, println}; 8 | use crate::lisp::eval::CallEvaluation; 9 | 10 | macro_rules! modules { 11 | ($cb:ident) => { 12 | $cb!(booleans); 13 | $cb!(boxes); 14 | $cb!(debugging); 15 | $cb!(equality); 16 | $cb!(exceptions); 17 | $cb!(hash_tables); 18 | $cb!(io); 19 | $cb!(numbers); 20 | $cb!(pairs_lists); 21 | $cb!(procedures); 22 | $cb!(promises); 23 | $cb!(strings); 24 | $cb!(symbols); 25 | $cb!(syntax); 26 | $cb!(void); 27 | }; 28 | } 29 | 30 | macro_rules! import_module { 31 | ($name:ident) => { 32 | mod $name; 33 | }; 34 | } 35 | 36 | modules!(import_module); 37 | 38 | pub(crate) struct Helper<'a> { 39 | map: &'a mut SymbolMap, 40 | } 41 | 42 | type FnBuiltin = fn(&mut SchemeEnv, &LispList) -> Result; 43 | 44 | struct CreatedBuiltin<'a, 'b> { 45 | f: FnBuiltin, 46 | helper: &'b mut Helper<'a> 47 | } 48 | 49 | impl<'a, 'b> CreatedBuiltin<'a, 'b> { 50 | fn alias(self, name: &str) -> Self { 51 | self.helper.builtin(name, self.f) 52 | } 53 | } 54 | 55 | impl<'a> Helper<'a> { 56 | fn builtin<'s>( 57 | &'s mut self, 58 | name: &str, 59 | f: FnBuiltin, 60 | ) -> CreatedBuiltin<'a, 's> { 61 | self.map.set( 62 | String::from(name), 63 | LispVal::Procedure(LispProc { 64 | fct: ProcType::Builtin(String::from(name), f), 65 | eval_mode: ProcEvalMode::Regular, 66 | }) 67 | .into(), 68 | ); 69 | CreatedBuiltin { f, helper: self } 70 | } 71 | 72 | fn builtin_macro( 73 | &mut self, 74 | name: &str, 75 | eval_out: bool, 76 | f: FnBuiltin, 77 | ) { 78 | self.map.set( 79 | String::from(name), 80 | LispVal::Procedure(LispProc { 81 | fct: ProcType::Builtin(String::from(name), f), 82 | eval_mode: ProcEvalMode::Macro { eval_out }, 83 | }) 84 | .into(), 85 | ); 86 | } 87 | } 88 | 89 | impl Default for SchemeEnvData { 90 | // don't remove this; event with the trampoline hack, there are too many literals 91 | #[inline(never)] 92 | fn default() -> Self { 93 | let mut map = SymbolMap::new(); 94 | 95 | let mut helper = Helper { map: &mut map }; 96 | 97 | macro_rules! load { 98 | ($name:ident) => { 99 | print!("Loading ", stringify!($name), "... "); 100 | $name::init(&mut helper); 101 | println!("OK"); 102 | }; 103 | } 104 | 105 | modules!(load); 106 | 107 | SchemeEnvData { 108 | map, 109 | parent: None, 110 | trace: false, 111 | } 112 | } 113 | } 114 | -------------------------------------------------------------------------------- /code_rs/test/src/lisp/eval/builtins/booleans.rs: -------------------------------------------------------------------------------- 1 | use crate::lisp::eval::builtins::Helper; 2 | use crate::lisp::val::LispVal; 3 | 4 | pub(crate) fn init(h: &mut Helper) { 5 | h.builtin("not", |_, args| { 6 | let [arg] = args.params_n("not")?; 7 | Ok(LispVal::Bool(!arg.is_truthy()).into()) 8 | }); 9 | 10 | h.builtin("boolean?", |_, args| { 11 | let [arg] = args.params_n("boolean?")?; 12 | Ok(LispVal::Bool(matches!(**arg, LispVal::Bool(_))).into()) 13 | }); 14 | } 15 | -------------------------------------------------------------------------------- /code_rs/test/src/lisp/eval/builtins/boxes.rs: -------------------------------------------------------------------------------- 1 | use crate::lisp::eval::builtins::Helper; 2 | use crate::lisp::val::LispVal; 3 | use crate::LispValBox; 4 | 5 | pub(crate) fn init(h: &mut Helper) { 6 | h.builtin("box", |_, args| { 7 | let [arg] = args.params_n("box")?; 8 | Ok(LispVal::Box(arg.clone()).into()) 9 | }); 10 | 11 | h.builtin("set-box!", |_, args| { 12 | let [box_, value] = args.params_n("set-box!")?; 13 | let mut boxref = box_.borrow_mut(); 14 | let box_ = boxref.expect_box_mut("set-box!")?; 15 | *box_ = value.clone(); 16 | Ok(LispVal::Void.into()) 17 | }); 18 | 19 | h.builtin("unbox", |_, args| { 20 | let box_ = args.expect::<(&LispValBox,)>("unbox")?; 21 | Ok(box_.clone().into()) 22 | }); 23 | } 24 | -------------------------------------------------------------------------------- /code_rs/test/src/lisp/eval/builtins/debugging.rs: -------------------------------------------------------------------------------- 1 | use crate::lisp::eval::builtins::Helper; 2 | use crate::lisp::val::{LispHash, LispList, LispProc, LispVal, ProcEvalMode}; 3 | use crate::parm::heap::budmap::BudMap; 4 | 5 | pub(crate) fn init(h: &mut Helper) { 6 | h.builtin("env", |env, _args| { 7 | let mut hash = BudMap::default(); 8 | for item in env.iter() { 9 | hash.insert(LispVal::Str(item.0.clone()).into(), item.1.clone()); 10 | } 11 | Ok(LispVal::Hash(LispHash { 12 | map: hash, 13 | mutable: false, 14 | }) 15 | .into()) 16 | }); 17 | 18 | h.builtin_macro("trace", false, |env, args| { 19 | let mut new_env = env.make_child(); 20 | new_env.0.borrow_mut().trace = true; 21 | new_env.eval_begin(args) 22 | }); 23 | 24 | h.builtin("macro-expand", |env, args| { 25 | let [expr] = args.params_n("macro-expand")?; 26 | if let LispVal::List(LispList::Cons(head, rest)) = &**expr { 27 | let head = env.eval(head)?; 28 | if let LispVal::Procedure(LispProc { 29 | fct, 30 | eval_mode: ProcEvalMode::Macro { eval_out: true } 31 | }) = &*head 32 | { 33 | return env.eval_nonmacro_call_tco(fct, rest.expect_list("macro-expand")?); 34 | } 35 | } 36 | Ok(expr.clone().into()) 37 | }); 38 | } 39 | -------------------------------------------------------------------------------- /code_rs/test/src/lisp/eval/builtins/equality.rs: -------------------------------------------------------------------------------- 1 | use crate::lisp::eval::builtins::Helper; 2 | use crate::lisp::val::LispVal; 3 | 4 | pub(crate) fn init(h: &mut Helper) { 5 | h.builtin("eq?", |_, args| { 6 | let [a, b] = args.params_n("eq?")?; 7 | Ok(LispVal::Bool(a.ref_eq(b)).into()) 8 | }); 9 | 10 | h.builtin("equal?", |_, args| { 11 | let [a, b] = args.params_n("equal?")?; 12 | Ok(LispVal::Bool(a == b).into()) 13 | }).alias("eqv?"); 14 | } 15 | -------------------------------------------------------------------------------- /code_rs/test/src/lisp/eval/builtins/exceptions.rs: -------------------------------------------------------------------------------- 1 | use crate::lisp::eval::builtins::Helper; 2 | use crate::lisp::val::LispVal; 3 | use crate::parm::heap::string::String; 4 | use crate::parm::tty::Display; 5 | 6 | pub(crate) fn init(h: &mut Helper) { 7 | h.builtin("error", |_, args| { 8 | let mut msg = String::new(); 9 | for arg in args.iter() { 10 | if let LispVal::Str(s) = &**arg { 11 | msg.push_str(s); 12 | } else { 13 | arg.write(&mut msg); 14 | } 15 | msg.push(' '); 16 | } 17 | Err(msg) 18 | }); 19 | } 20 | -------------------------------------------------------------------------------- /code_rs/test/src/lisp/eval/builtins/hash_tables.rs: -------------------------------------------------------------------------------- 1 | use core::hash::{Hash, Hasher}; 2 | 3 | use crate::lisp::eval::builtins::Helper; 4 | use crate::lisp::eval::CallEvaluation; 5 | use crate::lisp::val::{LispHash, LispList, LispProc, LispVal, ProcEvalMode}; 6 | use crate::parm::heap::budmap::BudMap; 7 | use crate::parm::heap::string::String; 8 | use crate::parm::util::fxhash::FxHasher; 9 | 10 | 11 | fn make_hash(args: &LispList, mutable: bool, origin: &'static str) -> Result { 12 | let mut hash = BudMap::default(); 13 | let [items] = args.params_n(origin)?; 14 | let items = items.expect_list(origin)?; 15 | for item in items.iter() { 16 | let (key, value) = item.expect_list(origin)?.expect_cons(origin)?; 17 | hash.insert(key.clone(), value.clone()); 18 | } 19 | Ok(LispVal::Hash(LispHash { map: hash, mutable }).into()) 20 | } 21 | 22 | pub(crate) fn init(h: &mut Helper) { 23 | h.builtin("make-hash", |_, args| make_hash(args, true, "make-hash")); 24 | 25 | h.builtin("hash", |_, args| make_hash(args, false, "hash")); 26 | 27 | h.builtin("hash?", |_, args| { 28 | let [arg] = args.params_n("hash?")?; 29 | Ok(LispVal::Bool(matches!(**arg, LispVal::Hash { .. })).into()) 30 | }); 31 | 32 | h.builtin("hash-set!", |_, args| { 33 | let [hash, key, value] = args.params_n("hash-set!")?; 34 | let mut hashref = hash.borrow_mut(); 35 | let hash = hashref.expect_hash_mut("hash-set!")?; 36 | if !hash.mutable { 37 | return Err(String::from("hash-set! on immutable hash")); 38 | } 39 | hash.map.insert(key.clone(), value.clone()); 40 | Ok(LispVal::Void.into()) 41 | }); 42 | 43 | h.builtin("hash-ref", |env, args| { 44 | let ([hash, key], mut iter) = args.get_n_iter().ok_or("hash-ref")?; 45 | let hash = hash.expect_hash("hash-ref")?; 46 | match hash.map.get(key) { 47 | Some(value) => Ok(value.clone().into()), 48 | None => match iter.next() { 49 | Some(failure) => match &**failure { 50 | LispVal::Procedure(LispProc { 51 | fct, 52 | eval_mode: ProcEvalMode::Regular, 53 | }) => env.eval_nonmacro_call_tco(fct, &LispList::Empty), 54 | _ => Ok(failure.clone().into()), 55 | }, 56 | None => Err(String::from("hash-ref: key not found")), 57 | }, 58 | } 59 | }); 60 | 61 | h.builtin("hash-code", |_, args| { 62 | let [arg] = args.params_n("hash-code")?; 63 | let mut hasher = FxHasher::default(); 64 | arg.hash(&mut hasher); 65 | Ok(LispVal::Int(hasher.finish() as i32).into()) 66 | }); 67 | } 68 | -------------------------------------------------------------------------------- /code_rs/test/src/lisp/eval/builtins/io.rs: -------------------------------------------------------------------------------- 1 | 2 | use crate::lisp::eval::builtins::Helper; 3 | use crate::lisp::val::{LispListIter, LispVal}; 4 | use crate::parm::heap::string::Parse; 5 | use crate::parm::heap::string::String; 6 | use crate::parm::tty; 7 | use crate::{makestr, print, println}; 8 | use crate::parm::tty::{DisplayTarget}; 9 | 10 | pub(crate) fn init(h: &mut Helper) { 11 | h.builtin("newline", |_, _| { 12 | println!(); 13 | Ok(LispVal::Void.into()) 14 | }); 15 | 16 | h.builtin("display", |_, args| { 17 | let [x] = args.params_n("display")?; 18 | print!(x); 19 | Ok(LispVal::Void.into()) 20 | }).alias("print"); 21 | 22 | h.builtin("~a", |_, args| { 23 | let [x] = args.params_n("~a")?; 24 | let mut res = String::new(); 25 | print!(x, => &mut res); 26 | Ok(LispVal::Str(res).into()) 27 | }).alias("~v"); // todo: full ~a support 28 | 29 | h.builtin("displayln", |_, args| { 30 | let [x] = args.params_n("displayln")?; 31 | println!(x); 32 | Ok(LispVal::Void.into()) 33 | }).alias("println"); 34 | 35 | h.builtin("write", |_, args| { 36 | let [x] = args.params_n("write")?; 37 | print!(x.debug_display()); 38 | Ok(LispVal::Void.into()) 39 | }); 40 | 41 | h.builtin("~s", |_, args| { 42 | let [x] = args.params_n("~s")?; 43 | let mut res = String::new(); 44 | print!(x.debug_display(), => &mut res); 45 | Ok(LispVal::Str(res).into()) 46 | }); // todo: full ~s support 47 | 48 | h.builtin("writeln", |_, args| { 49 | let [x] = args.params_n("writeln")?; 50 | println!(x.debug_display()); 51 | Ok(LispVal::Void.into()) 52 | }); 53 | 54 | h.builtin("read", |_, _| { 55 | let mut input = String::new(); 56 | tty::read_line(&mut input); 57 | match input.parse::() { 58 | Ok(expr) => Ok(expr.into()), 59 | Err(e) => Err(makestr!("read: ", e)), 60 | } 61 | }); 62 | 63 | h.builtin("eof-object?", |_, args| { 64 | let [x] = args.params_n("eof-object?")?; 65 | Ok(LispVal::Bool(matches!(&**x, LispVal::Eof)).into()) 66 | }); 67 | 68 | h.builtin("format", |_, args| { 69 | let ([format], args) = args.get_n_iter().ok_or("format: expected at least 1 argument")?; 70 | let format = format.expect_string("format: expected string")?; 71 | let mut output = String::new(); 72 | scheme_format(format, args, &mut output)?; 73 | Ok(LispVal::Str(output).into()) 74 | }); 75 | 76 | h.builtin("printf", |_, args| { 77 | let ([format], args) = args.get_n_iter().ok_or("printf: expected at least 1 argument")?; 78 | let format = format.expect_string("printf: expected string")?; 79 | scheme_format(format, args, tty::get_tty())?; 80 | Ok(LispVal::Void.into()) 81 | }); 82 | } 83 | 84 | fn scheme_format(format: &String, mut args: LispListIter, target: &mut impl DisplayTarget) -> Result<(), String> { 85 | let mut format = &format[..]; 86 | 87 | loop { 88 | let next_tilde = format.iter().position(|c| *c == '~'); 89 | match next_tilde { 90 | Some(n) => { 91 | if n >= 1 { 92 | print!(format[..n], => target); 93 | } 94 | let ch_idx = n + 1; 95 | if ch_idx >= format.len() { 96 | return Err(String::from("format: cannot end in `~`")); 97 | } 98 | let ch = format[ch_idx]; 99 | let arg = args.next().ok_or("format: not enough arguments"); 100 | fn fix_int(i: i32, target: &mut impl DisplayTarget) -> u32 { 101 | if i < 0 { 102 | print!('-', => target); 103 | -i as u32 104 | } else { 105 | i as u32 106 | } 107 | } 108 | match ch { 109 | 'n' | '%' => { 110 | print!('\n', => target); 111 | } 112 | 'a' | 'A' | 'v' | 'V' => { 113 | let arg = arg?; 114 | print!(arg, => target); 115 | } 116 | 's' | 'S' => { 117 | let arg = arg?; 118 | print!(arg.debug_display(), => target); 119 | } 120 | 'c' | 'C' => { 121 | let arg = arg?.expect_char("format: expected char")?; 122 | print!(arg, => target); 123 | } 124 | 'b' | 'B' => { 125 | let arg = arg?.expect_int("format: expected int")?; 126 | tty::print_bin_auto(fix_int(arg, target), target); 127 | } 128 | 'o' | 'O' => { 129 | let arg = arg?.expect_int("format: expected int")?; 130 | tty::print_oct_auto(fix_int(arg, target), target); 131 | } 132 | 'x' | 'X' => { 133 | let arg = arg?.expect_int("format: expected int")?; 134 | tty::print_hex_auto(fix_int(arg, target), target); 135 | } 136 | '~' => { 137 | print!('~', => target); 138 | } 139 | _ => { 140 | return Err(makestr!("format: unknown format specifier `~", ch, "`")); 141 | } 142 | }; 143 | format = &format[ch_idx + 1..]; 144 | }, 145 | None => { 146 | print!(format, => target); 147 | return Ok(()); 148 | } 149 | }; 150 | } 151 | } -------------------------------------------------------------------------------- /code_rs/test/src/lisp/eval/builtins/numbers.rs: -------------------------------------------------------------------------------- 1 | use crate::lisp::eval::builtins::Helper; 2 | use crate::lisp::val::LispVal; 3 | 4 | pub(crate) fn init(h: &mut Helper) { 5 | h.builtin("+", |_, args| { 6 | let mut sum = 0; 7 | for arg in args.iter() { 8 | sum += arg.expect_int("+")?; 9 | } 10 | Ok(LispVal::Int(sum).into()) 11 | }); 12 | 13 | h.builtin("-", |_, args| { 14 | let ([first], iter) = args.get_n_iter().ok_or("-")?; 15 | let mut sum = first.expect_int("-")?; 16 | if iter.has_next() { 17 | for arg in iter { 18 | sum -= arg.expect_int("-")?; 19 | } 20 | Ok(LispVal::Int(sum).into()) 21 | } else { 22 | Ok(LispVal::Int(-sum).into()) 23 | } 24 | }); 25 | 26 | h.builtin("*", |_, args| { 27 | let mut sum = 1; 28 | for arg in args.iter() { 29 | sum *= arg.expect_int("*")?; 30 | } 31 | Ok(LispVal::Int(sum).into()) 32 | }); 33 | 34 | h.builtin("/", |_, args| { 35 | let ([first], iter) = args.get_n_iter().ok_or("/")?; 36 | let mut sum = first.expect_int("/")?; 37 | for arg in iter { 38 | sum /= arg.expect_int("/")?; 39 | } 40 | Ok(LispVal::Int(sum).into()) 41 | }); 42 | 43 | h.builtin("=", |_, args| { 44 | let (first, second) = args.expect::<(i32, i32)>("=")?; 45 | Ok(LispVal::Bool(first == second).into()) 46 | }); 47 | 48 | h.builtin(">", |_, args| { 49 | let (first, second) = args.expect::<(i32, i32)>(">")?; 50 | Ok(LispVal::Bool(first > second).into()) 51 | }); 52 | 53 | h.builtin(">=", |_, args| { 54 | let (first, second) = args.expect::<(i32, i32)>(">=")?; 55 | Ok(LispVal::Bool(first >= second).into()) 56 | }); 57 | 58 | h.builtin("<", |_, args| { 59 | let (first, second) = args.expect::<(i32, i32)>("<")?; 60 | Ok(LispVal::Bool(first < second).into()) 61 | }); 62 | 63 | h.builtin("<=", |_, args| { 64 | let (first, second) = args.expect::<(i32, i32)>("<=")?; 65 | Ok(LispVal::Bool(first <= second).into()) 66 | }); 67 | 68 | h.builtin("max", |_, args| { 69 | let ([max], iter) = args.get_n_iter().ok_or("max")?; 70 | let mut max = max.expect_int("max")?; 71 | for arg in iter { 72 | let arg = arg.expect_int("max")?; 73 | if arg > max { 74 | max = arg; 75 | } 76 | } 77 | Ok(LispVal::Int(max).into()) 78 | }); 79 | 80 | h.builtin("zero?", |_, args| { 81 | let first = args.expect::<(i32, )>("zero?")?; 82 | Ok(LispVal::Bool(first == 0).into()) 83 | }); 84 | 85 | h.builtin("positive?", |_, args| { 86 | let first = args.expect::<(i32, )>("positive?")?; 87 | Ok(LispVal::Bool(first > 0).into()) 88 | }); 89 | 90 | h.builtin("negative?", |_, args| { 91 | let first = args.expect::<(i32, )>("negative?")?; 92 | Ok(LispVal::Bool(first < 0).into()) 93 | }); 94 | 95 | h.builtin("integer?", |_, args| { 96 | let [arg] = args.params_n("integer?")?; 97 | Ok(LispVal::Bool(matches!(**arg, LispVal::Int(_))).into()) 98 | }).alias("number?"); 99 | 100 | h.builtin("expt", |_, args| { 101 | let (base, exponent) = args.expect::<(i32, i32)>("expt")?; 102 | let exponent = if exponent < 0 { 103 | return Err("expt: negative exponent unsupported".into()); 104 | } else { 105 | exponent as u32 106 | }; 107 | Ok(LispVal::Int(base.pow(exponent)).into()) 108 | }); 109 | 110 | h.builtin("add1", |_, args| { 111 | let arg = args.expect::<(i32, )>("add1")?; 112 | Ok(LispVal::Int(arg + 1).into()) 113 | }); 114 | 115 | h.builtin("sub1", |_, args| { 116 | let arg = args.expect::<(i32, )>("sub1")?; 117 | Ok(LispVal::Int(arg - 1).into()) 118 | }); 119 | } 120 | -------------------------------------------------------------------------------- /code_rs/test/src/lisp/eval/builtins/pairs_lists.rs: -------------------------------------------------------------------------------- 1 | use crate::lisp::eval::builtins::Helper; 2 | use crate::lisp::eval::CallEvaluation; 3 | use crate::lisp::val::{Any, LispList, LispListBuilder, LispVal, ProcType}; 4 | use crate::parm::heap::string::String; 5 | use crate::{lisplist, LispValBox}; 6 | use crate::parm::heap::vec::Vec; 7 | 8 | pub(crate) fn init(h: &mut Helper) { 9 | h.builtin("car", |_, args| { 10 | let list = args.expect::<(&LispList,)>("car")?; 11 | Ok(list.expect_car("car")?.clone().into()) 12 | }); 13 | 14 | h.builtin("cadr", |_, args| { 15 | let list = args.expect::<(&LispList,)>("cadr")?; 16 | Ok(list.expect_cadr("cadr")?.clone().into()) 17 | }); 18 | 19 | h.builtin("caddr", |_, args| { 20 | let list = args.expect::<(&LispList,)>("caddr")?; 21 | Ok(list 22 | .expect_cdr_list("caddr")? 23 | .expect_cadr("caddr")? 24 | .clone().into()) 25 | }); 26 | 27 | h.builtin("cadddr", |_, args| { 28 | let list = args.expect::<(&LispList,)>("cadddr")?; 29 | Ok(list 30 | .expect_cdr_list("cadddr")? 31 | .expect_cdr_list("cadddr")? 32 | .expect_cadr("cadddr")? 33 | .clone().into()) 34 | }); 35 | 36 | h.builtin("cdr", |_, args| { 37 | let list = args.expect::<(&LispList,)>("cdr")?; 38 | Ok(list.expect_cdr("cdr")?.clone().into()) 39 | }); 40 | 41 | h.builtin("cddr", |_, args| { 42 | let [list] = args.params_n("cddr")?; 43 | let (_first, rest) = list.expect_list("cddr")?.expect_cons("cddr")?; 44 | let (_second, rest) = rest.expect_list("cddr")?.expect_cons("cddr")?; 45 | Ok(rest.clone().into()) 46 | }); 47 | 48 | h.builtin("cons", |_, args| { 49 | let [first, rest] = args.params_n("cons")?; 50 | Ok(LispVal::List(LispList::Cons(first.clone(), rest.clone())).into()) 51 | }); 52 | 53 | h.builtin("pair?", |_, args| { 54 | let [arg] = args.params_n("pair?")?; 55 | Ok(LispVal::Bool(matches!(**arg, LispVal::List(LispList::Cons(_, _)))).into()) 56 | }); 57 | 58 | h.builtin("list?", |_, args| { 59 | let [arg] = args.params_n("list?")?; 60 | Ok(LispVal::Bool(matches!(**arg, LispVal::List(_))).into()) 61 | }); 62 | 63 | h.builtin("null?", |_, args| { 64 | let [arg] = args.params_n("null?")?; 65 | Ok(LispVal::Bool(matches!(**arg, LispVal::List(LispList::Empty))).into()) 66 | }); 67 | 68 | h.builtin("list*", |_, args| list_star(args).map(CallEvaluation::from)); 69 | 70 | h.builtin("member", |_, args| { 71 | let [item, list] = args.params_n("member")?; 72 | let mut list = list; 73 | while let LispList::Cons(list_item, rest) = list.expect_list("member")? { 74 | if item == list_item { 75 | return Ok(list.clone().into()); 76 | } 77 | list = rest; 78 | } 79 | Ok(LispVal::Bool(false).into()) 80 | }).alias("memv"); 81 | 82 | h.builtin("append", |_, args| { 83 | let mut res = LispListBuilder::new(); 84 | 85 | for arg in args { 86 | let arg = arg.expect_list("append")?; 87 | 88 | for item in arg.iter() { 89 | res.push(item.clone()); 90 | } 91 | } 92 | 93 | Ok(res.finish().into()) 94 | }); 95 | 96 | h.builtin("length", |_, args| { 97 | let list = args.expect::<(&LispList,)>("length")?; 98 | Ok(LispVal::Int(list.len() as i32).into()) 99 | }); 100 | 101 | h.builtin("map", |env, args| { 102 | let (fct, list) = args.expect::<(&ProcType, &LispList)>("map")?; 103 | let mut res = LispListBuilder::new(); 104 | for item in list.iter() { 105 | res.push(env.eval_nonmacro_call(fct, &LispList::singleton(item.clone()))?); 106 | } 107 | Ok(res.finish().into()) 108 | }); 109 | 110 | h.builtin("for-each", |env, args| { 111 | let (fct, list) = args.expect::<(&ProcType, &LispList)>("map")?; 112 | for item in list.iter() { 113 | env.eval_nonmacro_call(fct, &LispList::singleton(item.clone()))?; 114 | } 115 | Ok(LispVal::Void.into()) 116 | }); 117 | 118 | h.builtin("reverse", |_, args| { 119 | let list = args.expect::<(&LispList,)>("reverse")?; 120 | let mut result = LispList::Empty; 121 | for item in list { 122 | result = LispList::Cons(item.clone(), LispVal::List(result).into()); 123 | } 124 | Ok(LispVal::List(result).into()) 125 | }); 126 | 127 | // todo: n lists 128 | h.builtin("foldl", |env, args| { 129 | let (fct, init, list) = args.expect::<(&ProcType, Any, &LispList)>("foldl")?; 130 | let mut result = init.clone(); 131 | for item in list.iter() { 132 | result = env.eval_nonmacro_call(fct, &lisplist!(item.clone(), result))?; 133 | } 134 | Ok(result.into()) 135 | }); 136 | 137 | h.builtin("foldr", |env, args| { 138 | let (fct, init, list) = args.expect::<(&ProcType, Any, &LispList)>("foldr")?; 139 | let list = Vec::from_iter(list.iter()); 140 | let mut result = init.clone(); 141 | for item in list.into_iter().rev() { 142 | result = env.eval_nonmacro_call(fct, &lisplist!(item.clone(), result))?; 143 | } 144 | Ok(result.into()) 145 | }); 146 | 147 | h.builtin("assoc", |_, args| { 148 | let (v, lst) = args.expect::<(Any, &LispList)>("assoc")?; 149 | for item in lst.iter() { 150 | let (key, _) = item.expect_list("assoc")?.expect_cons("assoc")?; 151 | if key == v { 152 | return Ok(item.clone().into()); 153 | } 154 | } 155 | Ok(LispVal::Bool(false).into()) 156 | }).alias("assv"); 157 | 158 | h.builtin("filter", |env, args| { 159 | let (fct, list) = args.expect::<(&ProcType, &LispList)>("filter")?; 160 | let mut res = LispListBuilder::new(); 161 | for item in list.iter() { 162 | let pred = env.eval_nonmacro_call(fct, &LispList::singleton(item.clone()))?; 163 | if pred.is_truthy() { 164 | res.push(item.clone()); 165 | } 166 | } 167 | Ok(res.finish().into()) 168 | }); 169 | } 170 | 171 | pub(crate) fn list_star(mut args: &LispList) -> Result { 172 | let mut res = LispListBuilder::new(); 173 | while let LispList::Cons(item, rest) = args { 174 | if let LispVal::List(LispList::Empty) = **rest { 175 | for item in item.expect_list("list*")? { 176 | res.push(item.clone()); 177 | } 178 | break; 179 | } 180 | res.push(item.clone()); 181 | args = rest.expect_list("list*")?; 182 | } 183 | Ok(res.finish()) 184 | } 185 | -------------------------------------------------------------------------------- /code_rs/test/src/lisp/eval/builtins/procedures.rs: -------------------------------------------------------------------------------- 1 | use crate::lisp::eval::builtins::pairs_lists::list_star; 2 | use crate::lisp::eval::builtins::Helper; 3 | use crate::lisp::val::{ClosureArgs, LispProc, LispSymbol, LispVal, ProcEvalMode, ProcType}; 4 | use crate::parm::heap::string::String; 5 | use crate::{lisplist, LispValBox, parmvec}; 6 | 7 | pub(crate) fn init(h: &mut Helper) { 8 | h.builtin("apply", |env, args| { 9 | let (fct, args) = args.expect_cons("apply")?; 10 | let fct = fct.expect_nonmacro("apply")?; 11 | let args = list_star(args.expect_list("list*")?)?; 12 | let args = unsafe { args.expect_list("").unwrap_unchecked() }; 13 | env.eval_nonmacro_call_tco(fct, args) 14 | }); 15 | 16 | h.builtin("identity", |_, args| { 17 | let [arg] = args.params_n("identity")?; 18 | Ok(arg.clone().into()) 19 | }); 20 | 21 | h.builtin("compose", |env, args| { 22 | if args.is_empty() { 23 | return Err("compose: no functions given".into()); 24 | } 25 | 26 | let argname = String::from("arg"); 27 | 28 | let x: LispValBox = LispVal::Void.into(); 29 | 30 | let mut last: LispValBox = x.clone(); 31 | 32 | for func in args { 33 | let newlast: LispValBox = LispVal::Void.into(); 34 | *last.borrow_mut() = LispVal::List(lisplist!(func, newlast.clone())).into(); 35 | last = newlast; 36 | } 37 | 38 | *last.borrow_mut() = LispVal::Symbol(LispSymbol::from(argname.clone())).into(); 39 | 40 | Ok(LispVal::Procedure(LispProc { 41 | fct: ProcType::Closure { 42 | name: None, 43 | args: ClosureArgs::Dispatch(parmvec![argname], None), 44 | body: lisplist!(x), 45 | env: env.make_child(), 46 | }, 47 | eval_mode: ProcEvalMode::Regular 48 | }).into()) 49 | }); 50 | } 51 | -------------------------------------------------------------------------------- /code_rs/test/src/lisp/eval/builtins/promises.rs: -------------------------------------------------------------------------------- 1 | use crate::lisp::eval::builtins::Helper; 2 | use crate::lisp::val::{LispPromise, LispVal}; 3 | 4 | pub(crate) fn init(h: &mut Helper) { 5 | h.builtin_macro("delay", false, |env, args| { 6 | let new_env = env.make_child(); 7 | Ok(LispVal::Promise(LispPromise::Unevaluated { body: args.clone(), env: new_env }).into()) 8 | }); 9 | 10 | h.builtin("force", |_, args| { 11 | let [promise] = args.params_n("force")?; 12 | let mut promise = promise.borrow_mut(); 13 | let promise = promise.expect_promise_mut("force")?; 14 | match promise { 15 | LispPromise::Evaluated { val } => Ok(val.clone().into()), 16 | LispPromise::Unevaluated { body, env } => { 17 | let evaluation = env.eval_begin(body)?; 18 | let val = env.eval_tco(evaluation)?; 19 | *promise = LispPromise::Evaluated { val: val.clone() }; 20 | Ok(val.into()) 21 | } 22 | } 23 | }); 24 | 25 | h.builtin("promise?", |_, args| { 26 | let [arg] = args.params_n("promise?")?; 27 | Ok(LispVal::Bool(matches!(**arg, LispVal::Promise(_))).into()) 28 | }); 29 | } -------------------------------------------------------------------------------- /code_rs/test/src/lisp/eval/builtins/strings.rs: -------------------------------------------------------------------------------- 1 | use crate::lisp::eval::builtins::Helper; 2 | use crate::lisp::val::LispVal; 3 | use crate::parm::heap::string::String; 4 | 5 | pub(crate) fn init(h: &mut Helper) { 6 | h.builtin("string?", |_, args| { 7 | let [arg] = args.params_n("string?")?; 8 | Ok(LispVal::Bool(matches!(**arg, LispVal::Str(_))).into()) 9 | }); 10 | 11 | h.builtin("string-length", |_, args| { 12 | let string = args.expect::<(&String,)>("string-length")?; 13 | Ok(LispVal::Int(string.len() as i32).into()) 14 | }); 15 | 16 | h.builtin("string-ref", |_, args| { 17 | let (string, index) = args.expect::<(&String, i32)>("string-ref")?; 18 | Ok(LispVal::Char(*string.get(index as usize).ok_or("string-ref")?).into()) 19 | }); 20 | 21 | h.builtin("make-string", |_, args| { 22 | let (length, char) = args.expect::<(usize, char)>("make-string")?; 23 | Ok(LispVal::Str(String::from_char(length, char)).into()) 24 | }); 25 | } 26 | -------------------------------------------------------------------------------- /code_rs/test/src/lisp/eval/builtins/symbols.rs: -------------------------------------------------------------------------------- 1 | use crate::lisp::eval::builtins::Helper; 2 | use crate::lisp::val::{LispList, LispSymbol, LispVal}; 3 | use crate::parm::heap::string::String; 4 | use crate::parm::rand::rand; 5 | use crate::print; 6 | 7 | pub(crate) fn init(h: &mut Helper) { 8 | h.builtin("symbol?", |_, args| { 9 | let [arg] = args.params_n("symbol?")?; 10 | Ok(LispVal::Bool(matches!(**arg, LispVal::Symbol(_))).into()) 11 | }); 12 | 13 | h.builtin("string->symbol", |_, args| { 14 | let string = args.expect::<(&String,)>("string->symbol")?; 15 | Ok(LispVal::Symbol(LispSymbol { name: string.clone(), interned: true }).into()) 16 | }); 17 | 18 | h.builtin("string->uninterned-symbol", |_, args| { 19 | let string = args.expect::<(&String,)>("string->uninterned-symbol")?; 20 | Ok(LispVal::Symbol(LispSymbol { name: string.clone(), interned: false }).into()) 21 | }); 22 | 23 | h.builtin("symbol-interned?", |_, args| { 24 | let symbol = args.expect::<(&LispSymbol,)>("symbol-interned?")?; 25 | Ok(LispVal::Bool(symbol.interned).into()) 26 | }); 27 | 28 | h.builtin("gensym", |_, args| { 29 | let base: &[char] = match args { 30 | LispList::Empty => &['g'], 31 | LispList::Cons(base, rest) => { 32 | let base = base.expect_string("gensym")?; 33 | if !matches!(**rest, LispVal::List(LispList::Empty)) { 34 | return Err("gensym: too many arguments".into()); 35 | } 36 | &base 37 | }, 38 | }; 39 | let mut res = String::new(); 40 | print!(base, rand(), => &mut res); 41 | Ok(LispVal::Symbol(LispSymbol { name: res, interned: false }).into()) 42 | }); 43 | } 44 | -------------------------------------------------------------------------------- /code_rs/test/src/lisp/eval/builtins/syntax.rs: -------------------------------------------------------------------------------- 1 | use crate::lisp::eval::builtins::Helper; 2 | use crate::lisp::val::LispVal; 3 | 4 | pub(crate) fn init(h: &mut Helper) { 5 | h.builtin_macro("set!", false,|env, args| { 6 | let [var, value] = args.params_n("set!")?; 7 | let var = var.expect_symbol("set!")?; 8 | let value = env.eval(value)?; 9 | env.set(var.name.clone(), value); 10 | Ok(LispVal::Void.into()) 11 | }); 12 | } 13 | -------------------------------------------------------------------------------- /code_rs/test/src/lisp/eval/builtins/void.rs: -------------------------------------------------------------------------------- 1 | use crate::lisp::eval::builtins::Helper; 2 | use crate::lisp::val::LispVal; 3 | 4 | pub(crate) fn init(h: &mut Helper) { 5 | h.builtin("void", |_, _args| Ok(LispVal::Void.into())); 6 | 7 | h.builtin("void?", |_, args| { 8 | let [void] = args.params_n("void?")?; 9 | Ok(LispVal::Bool(matches!(**void, LispVal::Void)).into()) 10 | }); 11 | } 12 | -------------------------------------------------------------------------------- /code_rs/test/src/lisp/eval/call.rs: -------------------------------------------------------------------------------- 1 | use crate::lisp::env::SchemeEnv; 2 | use crate::lisp::val::{ClosureArgs, LispList, LispListIter, LispProc, LispVal, ProcEvalMode, ProcType}; 3 | use crate::parm::heap::string::String; 4 | use crate::parm::heap::vec::Vec; 5 | use crate::{makestr, println, LispValBox, print}; 6 | use crate::lisp::eval::CallEvaluation; 7 | 8 | impl SchemeEnv { 9 | pub(crate) fn eval_call( 10 | &mut self, 11 | proc @ LispProc { fct, eval_mode }: &LispProc, 12 | args: &LispList, 13 | ) -> Result { 14 | 15 | match eval_mode { 16 | ProcEvalMode::Macro { eval_out: false } => { 17 | if self.0.trace { 18 | println!("macro raw: ", proc, ' ', args); 19 | } 20 | self.eval_nonmacro_call_tco(fct, args) 21 | } 22 | ProcEvalMode::Macro { eval_out: true } => { 23 | if self.0.trace { 24 | println!("macro raw: ", proc, ' ', args); 25 | } 26 | let expansion = self.eval_nonmacro_call(fct, args)?; 27 | self.eval_inner(&expansion) 28 | } 29 | ProcEvalMode::Regular => { 30 | if self.0.trace { 31 | println!("nonmacro raw: ", proc, ' ', args); 32 | } 33 | let evaluated = self.eval_list(args)?; 34 | let evald = unsafe { evaluated.expect_list("").unwrap_unchecked() }; 35 | if self.0.trace { 36 | println!("nonmacro: ", proc, ' ', evald); 37 | } 38 | self.eval_nonmacro_call_tco(fct, evald) 39 | } 40 | } 41 | } 42 | 43 | pub(crate) fn eval_nonmacro_call_tco( 44 | &mut self, 45 | head: &ProcType, 46 | items: &LispList, 47 | ) -> Result { 48 | if self.0.trace { 49 | println!("nonmacro tco: ", items); 50 | } 51 | match head { 52 | ProcType::Builtin(_name, f) => f(self, items), 53 | ProcType::Closure { 54 | name: _, 55 | args, 56 | body, 57 | env, 58 | } => self.eval_closure_call(items, args, body, env), 59 | } 60 | } 61 | 62 | pub(crate) fn eval_nonmacro_call( 63 | &mut self, 64 | head: &ProcType, 65 | items: &LispList, 66 | ) -> Result { 67 | let evaluation = self.eval_nonmacro_call_tco(head, items)?; 68 | self.eval_tco(evaluation) 69 | } 70 | 71 | fn eval_closure_call( 72 | &mut self, 73 | items: &LispList, 74 | args: &ClosureArgs, 75 | body: &LispList, 76 | env: &SchemeEnv, 77 | ) -> Result { 78 | let mut new_env = env.make_child(); 79 | let mut iter = items.iter(); 80 | match args { 81 | ClosureArgs::Whole(name) => { 82 | new_env.set_new(name.clone(), LispVal::List(items.clone()).into()); 83 | } 84 | ClosureArgs::Dispatch(names, vararg_name) => { 85 | self.process_dispatch_args(&mut new_env, &mut iter, names, vararg_name)?; 86 | } 87 | } 88 | new_env.eval_begin(body) 89 | } 90 | 91 | fn process_dispatch_args( 92 | &mut self, 93 | new_env: &mut SchemeEnv, 94 | iter: &mut LispListIter, 95 | names: &Vec, 96 | vararg_name: &Option, 97 | ) -> Result<(), String> { 98 | for name in names.iter() { 99 | let arg = iter.next().ok_or("call: not enough arguments")?; 100 | new_env.set_new(name.clone(), arg.clone()); 101 | } 102 | if let Some(name) = vararg_name { 103 | new_env.set_new(name.clone(), LispList::from_iter(iter)); 104 | } else if let Some(remaining) = iter.next() { 105 | let mut err = makestr!("call: too many arguments, unexpected ", remaining, ", arguments were"); 106 | for name in names.iter() { 107 | print!(" ", name, => &mut err); 108 | } 109 | return Err(err); 110 | } 111 | Ok(()) 112 | } 113 | } 114 | -------------------------------------------------------------------------------- /code_rs/test/src/lisp/eval/conditionals.rs: -------------------------------------------------------------------------------- 1 | use crate::lisp::env::SchemeEnv; 2 | use crate::lisp::val::{LispList, LispSymbol, LispVal}; 3 | use crate::parm::heap::string::String; 4 | use crate::{makestr, LispValBox}; 5 | use crate::lisp::eval::CallEvaluation; 6 | 7 | impl SchemeEnv { 8 | pub(crate) fn eval_if(&mut self, args: &LispList) -> Result { 9 | let ([cond, then], mut rest) = args.get_n_iter().ok_or("if")?; 10 | let cond = self.eval(cond)?; 11 | if cond.is_truthy() { 12 | self.eval_inner(then) 13 | } else { 14 | match rest.next() { 15 | None => Ok(LispVal::Void.into()), 16 | Some(res) => { 17 | if rest.has_next() { 18 | return Err(String::from("too many arguments to if")); 19 | } 20 | self.eval_inner(res) 21 | } 22 | } 23 | } 24 | } 25 | 26 | pub(crate) fn eval_and(&mut self, args: &LispList) -> Result { 27 | let mut res = LispVal::Bool(true).into(); 28 | for item in args.iter() { 29 | let item = self.eval(item)?; 30 | if matches!(&*item, LispVal::Bool(false)) { 31 | return Ok(LispVal::Bool(false).into()); 32 | } 33 | res = item; 34 | } 35 | Ok(res) 36 | } 37 | 38 | pub(crate) fn eval_or(&mut self, args: &LispList) -> Result { 39 | for item in args.iter() { 40 | let item = self.eval(item)?; 41 | if !matches!(&*item, LispVal::Bool(false)) { 42 | return Ok(item.clone()); 43 | } 44 | } 45 | Ok(LispVal::Bool(false).into()) 46 | } 47 | 48 | pub(crate) fn eval_cond(&mut self, args: &LispList) -> Result { 49 | for clause in args { 50 | let (head, rest) = clause.expect_list("cond")?.expect_cons("cond")?; 51 | return match &**head { 52 | LispVal::Symbol(LispSymbol { name, .. }) if name == "else" => { 53 | self.eval_begin(rest.expect_list("cond")?) 54 | } 55 | _ => { 56 | let test = self.eval(head)?; 57 | if matches!(&*test, LispVal::Bool(false)) { 58 | continue; 59 | } 60 | let body = rest.expect_list("cond")?; 61 | match body { 62 | LispList::Empty => Ok(CallEvaluation::Normal(test)), 63 | LispList::Cons(head, rest) => match &**head { 64 | LispVal::Symbol(LispSymbol { name, .. }) if name == "=>" => { 65 | let proc = rest.expect_nonmacro("cond")?; 66 | self.eval_nonmacro_call_tco(proc, &LispList::singleton(test)) 67 | } 68 | _ => self.eval_begin(body), 69 | }, 70 | } 71 | } 72 | }; 73 | } 74 | Ok(CallEvaluation::Normal(LispVal::Void.into())) 75 | } 76 | 77 | pub(crate) fn eval_case(&mut self, args: &LispList) -> Result { 78 | let (scrutinee, cases) = args.expect_cons("case")?; 79 | let scrutinee = self.eval(scrutinee)?; 80 | for case in cases.expect_list("case: expected case list")?.iter() { 81 | match &**case { 82 | LispVal::List(case_items) => { 83 | let (test, body) = case_items.expect_cons("case: expected case")?; 84 | let valid = match **test { 85 | LispVal::Symbol(LispSymbol { name: ref s, .. }) if s == "else" => true, 86 | LispVal::List(ref values) => values.iter().any(|v| v.equal(&scrutinee)), 87 | _ => return Err(makestr!("case: expected list or 'else', got ", test)), 88 | }; 89 | if valid { 90 | let body = body.expect_list("case: expected body")?; 91 | return self.make_child().eval_begin(body); 92 | } 93 | } 94 | _ => return Err(makestr!("case: expected list, got ", case)), 95 | } 96 | } 97 | Ok(CallEvaluation::Normal(LispVal::Void.into())) 98 | } 99 | 100 | pub(crate) fn eval_when( 101 | &mut self, 102 | args: &LispList, 103 | invert: bool, 104 | ) -> Result { 105 | let (test, body) = args.expect_cons("when")?; 106 | let cond = self.eval(test)?; 107 | if cond.is_truthy() ^ invert { 108 | self.make_child() 109 | .eval_begin(body.expect_list("when: expected body")?) 110 | } else { 111 | Ok(CallEvaluation::Normal(LispVal::Void.into())) 112 | } 113 | } 114 | } 115 | -------------------------------------------------------------------------------- /code_rs/test/src/lisp/eval/forms.rs: -------------------------------------------------------------------------------- 1 | use crate::lisp::env::SchemeEnv; 2 | use crate::lisp::val::{LispList, LispListBuilder, LispSymbol, LispVal, ProcEvalMode}; 3 | use crate::parm::heap::string::String; 4 | use crate::{makestr, println, LispValBox}; 5 | use crate::lisp::eval::CallEvaluation; 6 | 7 | impl SchemeEnv { 8 | // don't remove this; event with the trampoline hack, there are too many literals 9 | #[inline(never)] 10 | fn eval_builtin_form( 11 | &mut self, 12 | name: &String, 13 | items: &LispList, 14 | ) -> Option> { 15 | use CallEvaluation::Normal; 16 | if name == "quote" { 17 | return Some(items.params_n("quote").map(|[v]| v.clone()).map(Normal)); 18 | } 19 | if name == "quasiquote" { 20 | return Some( 21 | items 22 | .params_n("quasiquote") 23 | .and_then(|[v]| self.eval_quasiquote(v)) 24 | .map(Normal) 25 | ); 26 | } 27 | let args = items; 28 | if name == "define" { 29 | return Some(self.eval_define(args, false).map(Normal)); 30 | } 31 | if name == "define-macro" { 32 | return Some(self.eval_define(args, true).map(Normal)); 33 | } 34 | if name == "begin" { 35 | return Some(self.make_child().eval_begin(args)); 36 | } 37 | if name == "lambda" { 38 | return Some(self.eval_lambda(args).map(Normal)); 39 | } 40 | if name == "list" { 41 | return Some(self.eval_list(args).map(Normal)); 42 | } 43 | if name == "let" { 44 | return Some(self.eval_let(args, false)); 45 | } 46 | if name == "letrec" || name == "let*" { 47 | return Some(self.eval_let(args, true)); 48 | } 49 | if name == "if" { 50 | return Some(self.eval_if(args)); 51 | } 52 | if name == "and" { 53 | return Some(self.eval_and(args).map(Normal)); 54 | } 55 | if name == "or" { 56 | return Some(self.eval_or(args).map(Normal)); 57 | } 58 | if name == "cond" { 59 | return Some(self.eval_cond(args)); 60 | } 61 | if name == "when" { 62 | return Some(self.eval_when(args, false)); 63 | } 64 | if name == "unless" { 65 | return Some(self.eval_when(args, true)); 66 | } 67 | if name == "case" { 68 | return Some(self.eval_case(args)); 69 | } 70 | None 71 | } 72 | 73 | pub(crate) fn eval_list(&mut self, items: &LispList) -> Result { 74 | let mut res = LispListBuilder::new(); 75 | for item in items.iter() { 76 | res.push(self.eval(item)?); 77 | } 78 | Ok(res.finish()) 79 | } 80 | 81 | pub(crate) fn eval_define( 82 | &mut self, 83 | items: &LispList, 84 | is_macro: bool, 85 | ) -> Result { 86 | if self.0.trace { 87 | println!("define: ", items); 88 | } 89 | let (head, rest) = items.expect_cons("define")?; 90 | match &**head { 91 | LispVal::Symbol(LispSymbol { name, .. }) => { 92 | let mut value = self.eval(items.expect_cadr("define: expected value")?)?; 93 | if is_macro { 94 | let mut res = value.expect_callable("define-macro")?.clone(); 95 | res.eval_mode = ProcEvalMode::Macro { eval_out: true }; 96 | value = LispVal::Procedure(res).into(); 97 | } 98 | self.set_new(name.clone(), value); 99 | } 100 | LispVal::List(fct_items) => { 101 | let (name, args) = fct_items.expect_cons("define")?; 102 | let args = self.eval_lambda_args(args)?; 103 | let lambda = 104 | self.eval_closure(args, rest.expect_list("define: expected body")?, is_macro)?; 105 | self.set_new(name.expect_symbol("define")?.name.clone(), lambda); 106 | } 107 | _ => return Err(makestr!("define: expected symbol or list, got ", head)), 108 | } 109 | Ok(LispVal::Void.into()) 110 | } 111 | 112 | pub(crate) fn eval_form(&mut self, items: &LispList) -> Result { 113 | 114 | let (head, rest) = items.expect_cons("call")?; 115 | let rest = rest.expect_list("call")?; 116 | 117 | if let Ok(LispSymbol { name, .. }) = head.expect_symbol("eval") { 118 | if let Some(res) = self.eval_builtin_form(name, rest) { 119 | return res; 120 | } 121 | } 122 | 123 | let binding = self.eval(head)?; 124 | self.eval_call(binding.expect_callable("call")?, rest) 125 | } 126 | } 127 | -------------------------------------------------------------------------------- /code_rs/test/src/lisp/eval/lambda.rs: -------------------------------------------------------------------------------- 1 | use crate::lisp::env::SchemeEnv; 2 | use crate::lisp::val::{ClosureArgs, LispList, LispProc, LispSymbol, LispVal, ProcEvalMode, ProcType}; 3 | use crate::parm::heap::string::String; 4 | use crate::parm::heap::vec::Vec; 5 | use crate::{makestr, LispValBox}; 6 | 7 | impl SchemeEnv { 8 | pub(crate) fn eval_lambda_args(&mut self, args: &LispValBox) -> Result { 9 | Ok(match &**args { 10 | LispVal::List(args) => self.eval_lambda_args_list(args)?, 11 | LispVal::Symbol(LispSymbol { name, .. }) => ClosureArgs::Whole(name.clone()), 12 | _ => { 13 | return Err(makestr!("lambda: expected list or symbol, got ", args)); 14 | } 15 | }) 16 | } 17 | 18 | pub(crate) fn eval_lambda_args_list(&mut self, args: &LispList) -> Result { 19 | let mut iter = args.iter(); 20 | let mut syms = Vec::new(); 21 | for arg in iter.by_ref() { 22 | syms.push(arg.expect_symbol("lambda")?.name.clone()); 23 | } 24 | Ok(ClosureArgs::Dispatch( 25 | syms, 26 | iter.tail() 27 | .map(|s| s.expect_symbol("lambda")) 28 | .transpose()? 29 | .map(|s| &s.name) 30 | .cloned(), 31 | )) 32 | } 33 | 34 | pub(crate) fn eval_lambda(&mut self, args: &LispList) -> Result { 35 | let (args, body) = args.expect_cons("lambda")?; 36 | self.eval_lambda_args(args).and_then(|cl_args| { 37 | self.eval_closure(cl_args, body.expect_list("lambda: expected body")?, false) 38 | }) 39 | } 40 | 41 | pub(crate) fn eval_closure( 42 | &mut self, 43 | args: ClosureArgs, 44 | body: &LispList, 45 | is_macro: bool, 46 | ) -> Result { 47 | Ok(self.make_closure(None, args, body.clone(), is_macro).into()) 48 | } 49 | 50 | fn make_closure( 51 | &mut self, 52 | name: Option, 53 | args: ClosureArgs, 54 | body: LispList, 55 | is_macro: bool, 56 | ) -> LispVal { 57 | LispVal::Procedure(LispProc { 58 | fct: ProcType::Closure { 59 | name, 60 | args, 61 | body, 62 | env: self.clone(), 63 | }, 64 | eval_mode: if is_macro { ProcEvalMode::Macro { eval_out: true } } else { ProcEvalMode::Regular }, 65 | }) 66 | } 67 | } 68 | -------------------------------------------------------------------------------- /code_rs/test/src/lisp/eval/let.rs: -------------------------------------------------------------------------------- 1 | use crate::lisp::env::SchemeEnv; 2 | use crate::lisp::val::{ClosureArgs, LispList, LispSymbol, LispVal}; 3 | use crate::parm::heap::string::String; 4 | use crate::parm::heap::vec::Vec; 5 | use crate::{makestr, LispValBox}; 6 | use crate::lisp::eval::CallEvaluation; 7 | 8 | impl SchemeEnv { 9 | fn eval_let_binding(&mut self, items: &LispList) -> Result<(String, LispValBox), String> { 10 | let [name, value] = items 11 | .get_n() 12 | .ok_or("let binding: expected list of length 2")?; 13 | let name = name.expect_symbol("let binding")?.name.clone(); 14 | let value = self.eval(value)?; 15 | Ok((name, value)) 16 | } 17 | 18 | fn eval_named_let( 19 | &mut self, 20 | name: &String, 21 | bindings: &LispList, 22 | body: &LispValBox, 23 | ) -> Result { 24 | let mut proc_bindings = Vec::new(); 25 | let mut lambda_env = self.make_child(); 26 | let mut first_call_env = lambda_env.make_child(); 27 | for item in bindings.iter() { 28 | match &**item { 29 | LispVal::List(items) => { 30 | let (name, val) = self.eval_let_binding(items)?; 31 | first_call_env.set(name.clone(), val); 32 | proc_bindings.push(name); 33 | } 34 | _ => return Err(makestr!("let: expected list, got ", item)), 35 | } 36 | } 37 | let args = ClosureArgs::Dispatch(proc_bindings, None); 38 | let body = body.expect_list("let: expected body")?; 39 | let lambda = lambda_env.eval_closure(args, body, false)?; 40 | lambda_env.set(name.clone(), lambda); 41 | first_call_env.eval_begin(body) 42 | } 43 | 44 | pub(crate) fn eval_let(&mut self, args: &LispList, rec: bool) -> Result { 45 | let mut env = self.make_child(); 46 | let (bindings, body) = args.expect_cons("let: expected list of length 2 or 3")?; 47 | if let LispVal::Symbol(LispSymbol { name, .. }) = &**bindings { 48 | let (bindings, body) = body.expect_list("let")?.expect_cons("let: expected body")?; 49 | return self.eval_named_let(name, bindings.expect_list("let")?, body); 50 | } 51 | let bindings = bindings.expect_list("let")?; 52 | for item in bindings.iter() { 53 | match &**item { 54 | LispVal::List(items) => { 55 | let (name, val) = if rec { 56 | env.eval_let_binding(items) 57 | } else { 58 | self.eval_let_binding(items) 59 | }?; 60 | env.set(name, val); 61 | } 62 | _ => return Err(makestr!("let: expected list, got ", item)), 63 | } 64 | } 65 | env.eval_begin(body.expect_list("let: expected body")?) 66 | } 67 | } 68 | -------------------------------------------------------------------------------- /code_rs/test/src/lisp/eval/quote.rs: -------------------------------------------------------------------------------- 1 | use crate::lisp::env::SchemeEnv; 2 | use crate::lisp::val::{LispList, LispListBuilder, LispSymbol, LispVal}; 3 | use crate::parm::heap::string::String; 4 | use crate::LispValBox; 5 | 6 | impl SchemeEnv { 7 | // don't remove this; event with the trampoline hack, there are too many literals 8 | #[inline(never)] 9 | pub(crate) fn eval_quasiquote(&mut self, val: &LispValBox) -> Result { 10 | fn expect_one<'a>( 11 | cdr: &'a LispValBox, 12 | origin: &'static str, 13 | ) -> Result<&'a LispValBox, String> { 14 | let (cadr, cddr) = cdr.expect_list(origin)?.expect_cons(origin)?; 15 | if **cddr != LispVal::List(LispList::Empty) { 16 | return Err(String::from("expected exactly one arg")); 17 | } 18 | Ok(cadr) 19 | } 20 | 21 | match &**val { 22 | LispVal::List(LispList::Cons(car, cdr)) => { 23 | match &**car { 24 | LispVal::Symbol(LispSymbol { name, .. }) => { 25 | if name == "unquote" { 26 | return self.eval(expect_one(cdr, "unquote")?); 27 | } else if name == "unquote-splicing" { 28 | return Err(String::from("unquote-splicing not allowed in quasiquote")); 29 | } 30 | } 31 | LispVal::List(LispList::Cons(caar, cdar)) => { 32 | if let LispVal::Symbol(LispSymbol { name, .. }) = &**caar { 33 | if name == "unquote-splicing" { 34 | let arg = self.eval(expect_one(cdar, "unquote-splicing")?)?; 35 | let d = self.eval_quasiquote(cdr)?; 36 | if matches!(*d, LispVal::List(LispList::Empty)) { 37 | return Ok(arg.clone()); 38 | } 39 | let mut res = LispListBuilder::new(); 40 | for item in arg.expect_list("unquote-splicing")? { 41 | res.push(item.clone()); 42 | } 43 | for item in d.expect_list("unquote-splicing")? { 44 | res.push(item.clone()); 45 | } 46 | return Ok(res.finish()); 47 | } 48 | } 49 | } 50 | _ => {} 51 | } 52 | Ok(LispVal::List(LispList::Cons( 53 | self.eval_quasiquote(car)?, 54 | self.eval_quasiquote(cdr)?, 55 | )) 56 | .into()) 57 | } 58 | _ => Ok(val.clone()), 59 | } 60 | } 61 | } 62 | -------------------------------------------------------------------------------- /code_rs/test/src/lisp/mod.rs: -------------------------------------------------------------------------------- 1 | pub(crate) mod env; 2 | mod eval; 3 | pub(crate) mod parse; 4 | pub(crate) mod val; 5 | -------------------------------------------------------------------------------- /code_rs/test/src/main.rs: -------------------------------------------------------------------------------- 1 | #![no_main] 2 | #![no_std] 3 | 4 | mod parm; 5 | 6 | fn main() { 7 | println!("Hello, world!"); 8 | } 9 | -------------------------------------------------------------------------------- /code_rs/test/src/parm/control.rs: -------------------------------------------------------------------------------- 1 | use crate::parm::mmio::BREAKpin; 2 | 3 | #[inline(always)] 4 | pub fn breakpoint() { 5 | BREAKpin.write(1); 6 | } 7 | -------------------------------------------------------------------------------- /code_rs/test/src/parm/float.rs: -------------------------------------------------------------------------------- 1 | /*#![allow(non_camel_case_types)] 2 | #![allow(non_snake_case)] 3 | #![allow(non_upper_case_globals)] 4 | 5 | /*============================================================================ 6 | This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic 7 | Package, Release 3a, by John R. Hauser. 8 | Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of 9 | California. All rights reserved. 10 | Redistribution and use in source and binary forms, with or without 11 | modification, are permitted provided that the following conditions are met: 12 | 1. Redistributions of source code must retain the above copyright notice, 13 | this list of conditions, and the following disclaimer. 14 | 2. Redistributions in binary form must reproduce the above copyright notice, 15 | this list of conditions, and the following disclaimer in the documentation 16 | and/or other materials provided with the distribution. 17 | 3. Neither the name of the University nor the names of its contributors may 18 | be used to endorse or promote products derived from this software without 19 | specific prior written permission. 20 | THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY 21 | EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 22 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE 23 | DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY 24 | DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 25 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 26 | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 27 | ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 28 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 29 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 | =============================================================================*/ 31 | 32 | use crate::println; 33 | 34 | type aeabi_float_t = u32; 35 | 36 | #[no_mangle] 37 | fn __aeabi_ui2f(x: u32) -> aeabi_float_t { 38 | if x == 0 { 39 | return 0; 40 | } 41 | 42 | if x & 0x80000000 != 0 { 43 | softfloat_roundPackToF32(false, 0x9D, x >> 1 | (x & 1)) 44 | } else { 45 | softfloat_normRoundPackToF32(false, 0x9C, x) 46 | } 47 | } 48 | 49 | fn packToF32UI(sign: bool, exp: i16, sig: u32) -> aeabi_float_t { 50 | let sign = sign as u32; 51 | (sign << 31) + (exp as u32) << 23 + sig 52 | } 53 | 54 | #[no_mangle] 55 | fn softfloat_roundPackToF32(sign: bool, mut exp: i16, sig: u32) -> aeabi_float_t { 56 | let mut round_increment = 0x40; 57 | let mut round_bits = sig & 0x7F; 58 | if 0xFD <= (exp as u16) { 59 | if exp < 0 { 60 | let is_tiny = exp < -1 || sig + round_increment < 0x80000000; 61 | let sig = softfloat_shiftRightJam32(sig, -exp as u16); 62 | exp = 0; 63 | round_bits = sig & 0x7F; 64 | if is_tiny && round_bits != 0 { 65 | println!("underflow"); 66 | } 67 | } else if (0xFD < exp) || (0x80000000 <= sig + round_increment) { 68 | println!("overflow + inexact"); 69 | return packToF32UI(sign, 0xFF, 0) - if round_increment == 0 { 1 } else { 0 }; 70 | } 71 | } 72 | if round_bits != 0 { 73 | println!("inexact"); 74 | } 75 | let sig = (sig + round_increment) >> 7; 76 | let sig = sig & !(!(round_bits ^ 0x40) & 1); 77 | packToF32UI(sign, if sig != 0 { exp } else { 0 }, sig) 78 | } 79 | 80 | fn softfloat_shiftRightJam32(a: u32, count: u16) -> u32 { 81 | if count < 31 { 82 | (a >> count) | ((a << (32 - count)) != 0) as u32 83 | } else { 84 | (a != 0) as u32 85 | } 86 | } 87 | 88 | fn softfloat_normRoundPackToF32(sign: bool, exp: i16, sig: u32) -> aeabi_float_t { 89 | let shift_count = softfloat_countLeadingZeros32(sig) - 1; 90 | let exp = exp - (shift_count as i16); 91 | if 7 <= shift_count && (exp as u16) <= 0xFD { 92 | packToF32UI(sign, if sig != 0 { exp } else { 0 }, sig << (shift_count - 7)) 93 | } else { 94 | softfloat_roundPackToF32(sign, exp, sig << shift_count) 95 | } 96 | } 97 | 98 | const softfloat_countLeadingZeros8: [u8; 256] = [ 99 | 8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, 100 | 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 101 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 102 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 103 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 104 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 105 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 106 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 107 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 108 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 109 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 110 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 111 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 112 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 113 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 114 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 115 | ]; 116 | 117 | fn softfloat_countLeadingZeros32(mut a: u32) -> u8 { 118 | let mut count = 0; 119 | if a < 0x10000 { 120 | count += 16; 121 | a <<= 16; 122 | } 123 | if a < 0x1000000 { 124 | count += 8; 125 | a <<= 8; 126 | } 127 | count + softfloat_countLeadingZeros8[(a >> 24) as usize] 128 | } 129 | 130 | #[no_mangle] 131 | fn __aeabi_fadd(a: aeabi_float_t, b: aeabi_float_t) -> aeabi_float_t { 132 | let sign_a = (a >> 31) != 0; 133 | let sign_b = (b >> 31) != 0; 134 | if sign_a == sign_b { 135 | softfloat_addMagsF32(a, b, sign_a) 136 | } else { 137 | softfloat_subMagsF32(a, b, sign_a) 138 | } 139 | } 140 | 141 | fn signF32UI(a: aeabi_float_t) -> bool { 142 | (a >> 31) != 0 143 | } 144 | 145 | fn expF32UI(a: aeabi_float_t) -> i16 { 146 | ((a >> 23) & 0xFF) as i16 147 | } 148 | 149 | fn fracF32UI(a: aeabi_float_t) -> u32 { 150 | a & 0x7FFFFF 151 | } 152 | 153 | fn softfloat_addMagsF32(a: aeabi_float_t, b: aeabi_float_t, sign: bool) -> aeabi_float_t { 154 | let exp_a = expF32UI(a); 155 | let exp_b = expF32UI(b); 156 | let exp_diff = exp_a - exp_b; 157 | let sig_a = fracF32UI(a) << 6; 158 | let sig_b = fracF32UI(b) << 6; 159 | return if exp_diff == 0 { 160 | if exp_a == 0xff { 161 | if sig_a | sig_b != 0 { 162 | return softfloat_propagateNaNF32UI(a, b); 163 | } 164 | return a; 165 | } 166 | if exp_a == 0 { 167 | return packToF32UI(sign, 0, (a + b) & 0x7FFFFFFF); 168 | } 169 | softfloat_roundPackToF32(sign, exp_a, 0x40000000 + sig_a + sig_b) 170 | } else { 171 | let mut exp_z; 172 | let mut sig_z; 173 | let mut sig_a = sig_a; 174 | let mut sig_b = sig_b; 175 | if exp_diff < 0 { 176 | if exp_b == 0xff { 177 | if sig_b != 0 { 178 | return softfloat_propagateNaNF32UI(a, b); 179 | } 180 | return packToF32UI(sign_b, 0xff, 0); 181 | } 182 | exp_z = exp_b; 183 | sig_a += if exp_a != 0 { 0x20000000 } else { sig_a }; 184 | sig_a = softfloat_shiftRightJam32(sig_a, -exp_diff as u16); 185 | } else { 186 | if exp_a == 0xff { 187 | if sig_a != 0 { 188 | return softfloat_propagateNaNF32UI(a, b); 189 | } 190 | return a; 191 | } 192 | exp_z = exp_a; 193 | sig_b += if exp_b != 0 { 0x20000000 } else { sig_b }; 194 | sig_b = softfloat_shiftRightJam32(sig_b, exp_diff as u16); 195 | } 196 | sig_z = 0x20000000 + sig_a + sig_b; 197 | if sig_z < 0x40000000 { 198 | exp_z -= 1; 199 | sig_z <<= 1; 200 | } 201 | softfloat_roundPackToF32(sign, exp_z, sig_z) 202 | } 203 | }*/ 204 | -------------------------------------------------------------------------------- /code_rs/test/src/parm/keyb.rs: -------------------------------------------------------------------------------- 1 | use crate::parm::mmio::{KEYBchr, KEYBeof}; 2 | 3 | #[inline(always)] 4 | pub fn wait_key() { 5 | while KEYBeof.read() == 0 {} 6 | } 7 | 8 | #[inline(always)] 9 | pub fn read_key() -> u32 { 10 | wait_key(); 11 | KEYBchr.read() 12 | } 13 | 14 | #[inline(always)] 15 | pub fn read_char() -> char { 16 | unsafe { char::from_u32_unchecked(read_key()) } 17 | } 18 | 19 | #[inline(always)] 20 | pub fn read() -> Option { 21 | if KEYBeof.read() != 0 { 22 | Some(KEYBchr.read()) 23 | } else { 24 | None 25 | } 26 | } 27 | 28 | #[inline(always)] 29 | pub fn key_available() -> bool { 30 | KEYBeof.read() != 0 31 | } 32 | 33 | #[inline(always)] 34 | pub fn flush() { 35 | while key_available() { 36 | let _ = read_key(); 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /code_rs/test/src/parm/mmio.rs: -------------------------------------------------------------------------------- 1 | const MMIO_BASE: *mut u32 = -256i32 as _; 2 | 3 | #[inline(always)] 4 | const fn mmio(pin: u8) -> *mut u32 { 5 | match pin { 6 | 0..=15 => unsafe { MMIO_BASE.offset(pin as isize) }, 7 | _ => panic!("Invalid pin"), 8 | } 9 | } 10 | 11 | pub struct ReadPin(u8); 12 | impl ReadPin { 13 | #[inline(always)] 14 | pub fn read(&self) -> u32 { 15 | unsafe { core::ptr::read_volatile(mmio(self.0)) } 16 | } 17 | #[inline(always)] 18 | pub fn address(&self) -> *mut u32 { 19 | mmio(self.0) 20 | } 21 | } 22 | 23 | pub struct ReadWritePin(u8); 24 | impl ReadWritePin { 25 | #[inline(always)] 26 | pub fn read(&self) -> u32 { 27 | ReadPin(self.0).read() 28 | } 29 | 30 | #[inline(always)] 31 | pub fn write(&self, val: u32) { 32 | WritePin(self.0).write(val); 33 | } 34 | 35 | #[inline(always)] 36 | pub fn address(&self) -> *mut u32 { 37 | mmio(self.0) 38 | } 39 | } 40 | 41 | pub struct WritePin(u8); 42 | impl WritePin { 43 | #[inline(always)] 44 | pub fn write(&self, val: u32) { 45 | unsafe { 46 | core::ptr::write_volatile(mmio(self.0), val); 47 | } 48 | } 49 | 50 | #[inline(always)] 51 | pub fn address(&self) -> *mut u32 { 52 | mmio(self.0) 53 | } 54 | } 55 | 56 | macro_rules! pins { 57 | (@pin $name:ident in $pin:literal) => { 58 | pins!{@pin $name ReadPin $pin} 59 | }; 60 | 61 | (@pin $name:ident out $pin:literal) => { 62 | pins!{@pin $name WritePin $pin} 63 | }; 64 | 65 | (@pin $name:ident inout $pin:literal) => { 66 | pins!{@pin $name ReadWritePin $pin} 67 | }; 68 | 69 | (@pin $name:ident $ty:ident $pin:literal) => { 70 | #[allow(non_upper_case_globals)] 71 | pub const $name: $ty = $ty($pin); 72 | }; 73 | 74 | ($($name:ident => $pin:literal ( $kind:ident ) ),*) => { 75 | $(pins!{@pin $name $kind $pin})* 76 | } 77 | } 78 | 79 | pins! { 80 | TTYchr => 0(inout), 81 | RES => 1(inout), 82 | TELNETdata => 2(inout), 83 | TELNETavail => 3(in), 84 | MIDInote => 3(out), 85 | MIDIvol => 4(out), 86 | MIDIon => 5(out), 87 | MIDIinstr => 6(out), 88 | KEYBeof => 6(in), 89 | KEYBchr => 7(in), 90 | RNG32 => 10(in), 91 | RESbcd => 11(in), 92 | R2divR3 => 12(in), 93 | R2modR3 => 13(in), 94 | DISPbuf => 14(inout), 95 | BREAKpin => 15(out) 96 | } 97 | -------------------------------------------------------------------------------- /code_rs/test/src/parm/mod.rs: -------------------------------------------------------------------------------- 1 | #![allow(dead_code)] 2 | #![allow(named_asm_labels)] 3 | 4 | pub mod control; 5 | mod float; 6 | pub mod heap; 7 | pub mod keyb; 8 | pub mod math; 9 | pub mod midi; 10 | pub mod mmio; 11 | pub mod screen; 12 | pub mod telnet; 13 | pub mod tty; 14 | pub mod util; 15 | pub mod rand; 16 | 17 | #[link_section = ".start"] 18 | #[export_name = "run"] 19 | pub fn _start() -> ! { 20 | let main: unsafe fn() -> () = crate::main; 21 | 22 | unsafe { 23 | core::arch::asm!( 24 | r#" 25 | movs r0, #1 26 | lsls r0, r0, #20 27 | mov sp, r0 28 | movs r0, #0 29 | "# 30 | ); 31 | main(); 32 | } 33 | loop {} 34 | } 35 | 36 | #[export_name = "_ZN4core9panicking5panicXXX"] 37 | pub fn panic(expr: &'static str) -> ! { 38 | println!("PANIC:", expr); 39 | breakpoint(); 40 | loop {} 41 | } 42 | 43 | #[no_mangle] 44 | pub fn expect_failed(msg: &'static str) -> ! { 45 | unsafe { 46 | core::arch::asm!("_ZN4core6option13expect_failedXXX:"); 47 | } 48 | panic(msg) 49 | } 50 | 51 | #[export_name = "unwrap_failed"] 52 | #[inline(always)] 53 | pub fn unwrap_failed() -> ! { 54 | unsafe { 55 | core::arch::asm!("_ZN4core6result13unwrap_failedXXX:"); 56 | } 57 | panic("unwrap_failed"); 58 | } 59 | 60 | #[export_name = "panic_bounds_check"] 61 | #[inline(always)] 62 | fn panic_bounds_check() -> ! { 63 | unsafe { 64 | core::arch::asm!("_ZN4core9panicking18panic_bounds_checkXXX:"); 65 | } 66 | panic("index out of bounds") 67 | } 68 | 69 | #[export_name = "panic_fmt"] 70 | #[inline(always)] 71 | fn panic_fmt() -> ! { 72 | unsafe { 73 | core::arch::asm!("_ZN4core9panicking9panic_fmtXXX:"); 74 | } 75 | panic("panic_fmt") 76 | } 77 | 78 | #[export_name = "panic_already_borrowed"] 79 | #[inline(always)] 80 | fn panic_already_borrowed() -> ! { 81 | unsafe { 82 | core::arch::asm!("_ZN4core4cell22panic_already_borrowedXXX:"); 83 | } 84 | panic("panic_already_borrowed") 85 | } 86 | 87 | #[export_name = "borrow_mut_error"] 88 | fn borrow_mut_error() -> ! { 89 | unsafe { 90 | core::arch::asm!( 91 | "_ZN63_$LT$core..cell..BorrowMutError$u20$as$u20$core..fmt..Debug$GT$3fmtXXX:" 92 | ); 93 | } 94 | panic("borrow_mut error") 95 | } 96 | 97 | #[export_name = "const_div_by_zero"] 98 | fn const_div_by_zero() -> ! { 99 | unsafe { 100 | core::arch::asm!( 101 | "_ZN4core9panicking11panic_const23panic_const_div_by_zeroXXX:" 102 | ); 103 | } 104 | panic("const div by zero") 105 | } 106 | 107 | #[export_name = "slicee_end_index_len_fail"] 108 | fn slice_end_index_len_fail(_index: usize, _len: usize) -> ! { 109 | unsafe { 110 | core::arch::asm!("_ZN4core5slice5index26slice_start_index_len_failXXX:"); 111 | core::arch::asm!("_ZN4core5slice5index24slice_end_index_len_failXXX:"); 112 | core::arch::asm!("_ZN4core5slice29__DOL_LT_DOL_impl_DOL_u20_DOL__DOL_u5b_DOL_T_DOL_u5d_DOL__DOL_GT_DOL_15copy_from_slice17len_mismatch_failXXX:"); 113 | } 114 | panic("slice index out of bounds"); 115 | } 116 | 117 | #[no_mangle] 118 | fn slice_index_order_fail(_index: usize, _end: usize) -> ! { 119 | unsafe { 120 | core::arch::asm!("_ZN4core5slice5index22slice_index_order_failXXX:"); 121 | } 122 | panic("slice index start is larger than end"); 123 | } 124 | 125 | core::arch::global_asm!( 126 | r#" 127 | _ZN63_$LT$core..cell..BorrowMutError$u20$as$u20$core..fmt..Debug$GT$3fmt17hd3989ea40ef8781cE: nop 128 | "# 129 | ); 130 | 131 | use crate::println; 132 | use core::panic::PanicInfo; 133 | use crate::parm::control::breakpoint; 134 | 135 | #[panic_handler] 136 | fn handler(_info: &PanicInfo) -> ! { 137 | println!("handler"); 138 | loop {} 139 | } 140 | /* 141 | #[no_mangle] 142 | pub unsafe extern "C" fn rust_begn_unwind( 143 | _args: ::core::fmt::Arguments, 144 | _file: &'static str, 145 | _line: u32, 146 | ) -> ! { 147 | panic("unwind"); 148 | }*/ 149 | -------------------------------------------------------------------------------- /code_rs/test/src/parm/rand.rs: -------------------------------------------------------------------------------- 1 | use crate::parm::mmio::RNG32; 2 | 3 | pub fn rand() -> u32 { 4 | RNG32.read() 5 | } -------------------------------------------------------------------------------- /code_rs/test/src/parm/telnet.rs: -------------------------------------------------------------------------------- 1 | use crate::parm::heap::string::String; 2 | use crate::parm::heap::vec::Vec; 3 | use crate::parm::mmio::{TELNETavail, TELNETdata, RES}; 4 | use crate::parm::tty::{AsciiEncodable, DisplayTarget}; 5 | use crate::print; 6 | 7 | pub fn flush_all() { 8 | while data_available() { 9 | let _ = TELNETdata.read(); 10 | } 11 | } 12 | 13 | pub fn send(data: u8) { 14 | TELNETdata.write(data as u32); 15 | } 16 | 17 | #[inline(always)] 18 | pub fn data_available() -> bool { 19 | TELNETavail.read() != 0 20 | } 21 | 22 | #[inline(always)] 23 | pub fn read_blocking() -> u8 { 24 | while !data_available() { 25 | continue; 26 | } 27 | TELNETdata.read() as u8 28 | } 29 | 30 | #[inline(always)] 31 | pub fn read() -> Option { 32 | if data_available() { 33 | Some(TELNETdata.read() as u8) 34 | } else { 35 | None 36 | } 37 | } 38 | 39 | pub fn read_arr_blocking() -> [u8; N] { 40 | let mut arr = [0; N]; 41 | for i in 0..N { 42 | arr[i] = read_blocking(); 43 | } 44 | arr 45 | } 46 | 47 | pub fn read_n_blocking(n: usize) -> Vec { 48 | let mut vec = Vec::with_capacity(n); 49 | for i in 0..n { 50 | RES.write(i as u32); 51 | unsafe { 52 | vec.push_unchecked(read_blocking()); 53 | } 54 | } 55 | vec 56 | } 57 | 58 | pub fn read_all_as(conv: fn(u8) -> T, stop: fn(u8) -> bool) -> Vec { 59 | while !data_available() { 60 | continue; 61 | } 62 | let mut data = Vec::with_capacity(32); 63 | while data_available() { 64 | let char_read = TELNETdata.read() as u8; 65 | if stop(char_read) { 66 | break; 67 | } 68 | data.push(conv(char_read)); 69 | } 70 | data 71 | } 72 | 73 | pub fn read_until_as(conv: fn(u8) -> T, stop: fn(u8) -> bool) -> Vec { 74 | while !data_available() { 75 | continue; 76 | } 77 | let mut data = Vec::with_capacity(32); 78 | loop { 79 | let char_read = read_blocking(); 80 | if stop(char_read) { 81 | break; 82 | } 83 | data.push(conv(char_read)); 84 | } 85 | data 86 | } 87 | 88 | pub fn read_all() -> Vec { 89 | read_all_as(|x| x, |_| false) 90 | } 91 | 92 | pub fn read_all_string() -> String { 93 | unsafe { String::from_utf32_unchecked(read_all_as(|x| x as char, |_| false)) } 94 | } 95 | 96 | pub fn read_line() -> String { 97 | unsafe { String::from_utf32_unchecked(read_until_as(|x| x as char, |x| x == b'\n')) } 98 | } 99 | 100 | pub fn read_line_to(out: &mut String, echo: bool) { 101 | while !data_available() { 102 | continue; 103 | } 104 | loop { 105 | let char_read = read_blocking(); 106 | if echo { 107 | print!(char_read as char); 108 | } 109 | if char_read == b'\n' { 110 | break; 111 | } 112 | out.push(char_read as char); 113 | } 114 | } 115 | 116 | pub struct Telnet; 117 | 118 | static mut TELNET: Telnet = Telnet; 119 | #[inline(always)] 120 | pub fn get_telnet() -> &'static mut Telnet { 121 | unsafe { &mut TELNET } 122 | } 123 | 124 | impl DisplayTarget for Telnet { 125 | #[inline(always)] 126 | fn print_char(&mut self, c: impl AsciiEncodable) { 127 | send(c.ascii_encode()); 128 | } 129 | 130 | #[inline(always)] 131 | fn print_slice(&mut self, s: &[char]) { 132 | s.iter().for_each(|c| self.print_char(*c)); 133 | } 134 | 135 | #[inline(always)] 136 | fn print_rust_str(&mut self, s: &str) { 137 | s.bytes().for_each(|c| self.print_char(c)); 138 | } 139 | } 140 | -------------------------------------------------------------------------------- /code_rs/test/src/parm/util.rs: -------------------------------------------------------------------------------- 1 | pub mod fxhash; 2 | -------------------------------------------------------------------------------- /code_rs/test/src/parm/util/fxhash.rs: -------------------------------------------------------------------------------- 1 | use core::hash::Hasher; 2 | use core::ops::BitXor; 3 | 4 | const ROTATE: u32 = 5; 5 | const SEED64: u64 = 0x517cc1b727220a95; 6 | const SEED32: u32 = (SEED64 & 0xFFFF_FFFF) as u32; 7 | 8 | const SEED: usize = SEED32 as usize; 9 | 10 | trait HashWord { 11 | fn hash_word(&mut self, word: Self); 12 | } 13 | 14 | macro_rules! impl_hash_word { 15 | ($($ty:ty = $key:ident),* $(,)*) => ( 16 | $( 17 | impl HashWord for $ty { 18 | #[inline] 19 | fn hash_word(&mut self, word: Self) { 20 | *self = self.rotate_left(ROTATE).bitxor(word).wrapping_mul($key); 21 | } 22 | } 23 | )* 24 | ) 25 | } 26 | 27 | impl_hash_word!(usize = SEED, u32 = SEED32, u64 = SEED64); 28 | 29 | #[inline] 30 | fn write32(mut hash: u32, mut bytes: &[u8]) -> u32 { 31 | while bytes.len() >= 4 { 32 | let n = unsafe { *(bytes.as_ptr() as *const u32) }; 33 | hash.hash_word(n); 34 | bytes = bytes.split_at(4).1; 35 | } 36 | 37 | for byte in bytes { 38 | hash.hash_word(*byte as u32); 39 | } 40 | hash 41 | } 42 | 43 | #[inline] 44 | fn write64(mut hash: u64, mut bytes: &[u8]) -> u64 { 45 | while bytes.len() >= 8 { 46 | let n = unsafe { *(bytes.as_ptr() as *const u64) }; 47 | hash.hash_word(n); 48 | bytes = bytes.split_at(8).1; 49 | } 50 | 51 | if bytes.len() >= 4 { 52 | let n = unsafe { *(bytes.as_ptr() as *const u32) }; 53 | hash.hash_word(n as u64); 54 | bytes = bytes.split_at(4).1; 55 | } 56 | 57 | for byte in bytes { 58 | hash.hash_word(*byte as u64); 59 | } 60 | hash 61 | } 62 | 63 | #[inline] 64 | fn write(hash: usize, bytes: &[u8]) -> usize { 65 | write32(hash as u32, bytes) as usize 66 | } 67 | 68 | /// This hashing algorithm was extracted from the Rustc compiler. 69 | /// This is the same hashing algoirthm used for some internal operations in FireFox. 70 | /// The strength of this algorithm is in hashing 8 bytes at a time on 64-bit platforms, 71 | /// where the FNV algorithm works on one byte at a time. 72 | /// 73 | /// This hashing algorithm should not be used for cryptographic, or in scenarios where 74 | /// DOS attacks are a concern. 75 | #[derive(Clone)] 76 | pub struct FxHasher { 77 | hash: usize, 78 | } 79 | 80 | impl Default for FxHasher { 81 | #[inline] 82 | fn default() -> FxHasher { 83 | FxHasher { hash: 0 } 84 | } 85 | } 86 | 87 | impl Hasher for FxHasher { 88 | #[inline] 89 | fn finish(&self) -> u64 { 90 | self.hash as u64 91 | } 92 | 93 | #[inline] 94 | fn write(&mut self, bytes: &[u8]) { 95 | self.hash = write(self.hash, bytes); 96 | } 97 | 98 | #[inline] 99 | fn write_u8(&mut self, i: u8) { 100 | self.hash.hash_word(i as usize); 101 | } 102 | 103 | #[inline] 104 | fn write_u16(&mut self, i: u16) { 105 | self.hash.hash_word(i as usize); 106 | } 107 | 108 | #[inline] 109 | fn write_u32(&mut self, i: u32) { 110 | self.hash.hash_word(i as usize); 111 | } 112 | 113 | #[inline] 114 | fn write_u64(&mut self, i: u64) { 115 | self.hash.hash_word(i as usize); 116 | self.hash.hash_word((i >> 32) as usize); 117 | } 118 | 119 | #[inline] 120 | fn write_usize(&mut self, i: usize) { 121 | self.hash.hash_word(i); 122 | } 123 | } 124 | -------------------------------------------------------------------------------- /code_rs/test/src/plotter.rs: -------------------------------------------------------------------------------- 1 | #![no_main] 2 | #![no_std] 3 | #![feature(min_specialization)] 4 | 5 | #![feature(step_trait)] 6 | #![feature(slice_pattern)] 7 | 8 | use crate::parm::math::fp32; 9 | use crate::parm::screen::tty::{get_videotty, init}; 10 | use crate::parm::screen::{ 11 | circle, line, rgb32, set_pixel_unchecked, ColorEncodable, ColorEncoded, ColorSimple, HEIGHT, 12 | WIDTH, 13 | }; 14 | use crate::parm::tty::DisplayTarget; 15 | 16 | mod parm; 17 | 18 | const WINDOW_WIDTH: f32 = 15.0; 19 | const WINDOW_HEIGHT: f32 = 6.0; 20 | 21 | fn xy(f: fn(fp32) -> fp32) -> impl FnOnce(ColorEncoded) { 22 | move |color| { 23 | let step = fp32::from(WINDOW_WIDTH / WIDTH as f32); 24 | let min = fp32::from(-WINDOW_WIDTH / 2.0) + step; 25 | 26 | let mut cur = min; 27 | for i in 0..WIDTH { 28 | let val = f(cur); 29 | let val_on_screen = HEIGHT as i32 / 2 30 | - (val * fp32::from(HEIGHT as f32 / WINDOW_HEIGHT)).integer_part(); 31 | if val_on_screen >= 0 && val_on_screen < HEIGHT as i32 { 32 | unsafe { 33 | set_pixel_unchecked(i, val_on_screen as isize, color); 34 | } 35 | } 36 | cur += step; 37 | } 38 | } 39 | } 40 | 41 | fn add(f: impl FnOnce(ColorEncoded), name: &'static str, color: impl ColorEncodable) { 42 | *get_videotty() = get_videotty().fg(color).map(|tty| println!(name, => tty)); 43 | f(color.encode()); 44 | } 45 | 46 | fn main() { 47 | init(); 48 | 49 | circle(10, 10, 100, ColorSimple::White); 50 | 51 | get_videotty().offset(10, 10); 52 | 53 | line(0, HEIGHT / 2, WIDTH - 1, HEIGHT / 2, ColorSimple::Black); 54 | line(WIDTH / 2, 0, WIDTH / 2, HEIGHT - 1, ColorSimple::Black); 55 | 56 | add(xy(fp32::sin), "sin(x)", rgb32(255, 0, 0)); 57 | add(xy(fp32::cos), "cos(x)", rgb32(0, 128, 0)); 58 | add( 59 | xy(|f| f.recip().unwrap_or(fp32::MAX)), 60 | "1/x", 61 | ColorSimple::Blue, 62 | ); 63 | add( 64 | |c| circle(WIDTH / 2, HEIGHT / 2, 100, c), 65 | "circle", 66 | rgb32(192, 192, 0), 67 | ); 68 | 69 | /*let r = 80; 70 | for angle in (0..2 * fp32::PI.get_raw_data()).step_by(fp32::from(0.01).get_raw_data() as usize) 71 | { 72 | let angle = fp32::from_raw(angle); 73 | let x = angle.cos() * fp32::from(r); 74 | let y = angle.sin() * fp32::from(r); 75 | set_pixel( 76 | (x + fp32::from(WIDTH / 2)).integer_part() as isize, 77 | (y + fp32::from(HEIGHT / 2)).integer_part() as isize, 78 | ColorSimple::Magenta, 79 | ); 80 | }*/ 81 | } 82 | -------------------------------------------------------------------------------- /code_rs/test/src/simpletelnet.rs: -------------------------------------------------------------------------------- 1 | #![no_main] 2 | #![no_std] 3 | #![feature(min_specialization)] 4 | #![feature(associated_type_defaults)] 5 | #![feature(iter_order_by)] 6 | #![feature(step_trait)] 7 | 8 | mod parm; 9 | 10 | use parm::keyb; 11 | use parm::telnet; 12 | 13 | fn main() { 14 | loop { 15 | if let Some(ch) = telnet::read() { 16 | print!(ch as char); 17 | } 18 | 19 | if let Some(ch) = keyb::read() { 20 | telnet::send(ch as u8); 21 | } 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /code_rs/test/src/telnet_video.rs: -------------------------------------------------------------------------------- 1 | #![no_main] 2 | #![no_std] 3 | #![feature(min_specialization)] 4 | #![feature(associated_type_defaults)] 5 | #![feature(iter_order_by)] 6 | #![feature(step_trait)] 7 | #![feature(slice_pattern)] 8 | 9 | mod parm; 10 | 11 | use crate::parm::{keyb, telnet}; 12 | use parm::screen::tty::*; 13 | 14 | fn main() { 15 | init(); 16 | 17 | loop { 18 | if let Some(ch) = telnet::read() { 19 | print!(ch as char, => get_videotty()); 20 | } 21 | 22 | if let Some(ch) = keyb::read() { 23 | telnet::send(ch as u8); 24 | } 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /code_rs/test/src/testdyn.rs: -------------------------------------------------------------------------------- 1 | #![no_main] 2 | #![no_std] 3 | #![feature(min_specialization)] 4 | #![feature(associated_type_defaults)] 5 | #![feature(iter_order_by)] 6 | #![feature(step_trait)] 7 | 8 | mod parm; 9 | 10 | use parm::keyb; 11 | 12 | fn main() { 13 | let _x = 1.5; 14 | let y = 2.0 * keyb::read_key() as f32; 15 | let z = y as i32; 16 | println!(z); 17 | } 18 | -------------------------------------------------------------------------------- /code_rs/test/src/testfp.rs: -------------------------------------------------------------------------------- 1 | #![no_main] 2 | #![no_std] 3 | 4 | use crate::parm::math::fp32; 5 | 6 | mod parm; 7 | 8 | fn main() { 9 | let val = fp32::from(3.5); 10 | let val2 = fp32::from(7.5); 11 | let val3 = val * val2; 12 | 13 | println!(val, "*", val2, " =\n", val3); 14 | 15 | println!("sqrt =", val3.sqrt()); 16 | 17 | let x = fp32::from(0.375); 18 | let mysin = x.sin(); 19 | println!("sin(", x, ") =", mysin); 20 | let mycos = x.cos(); 21 | println!("cos(", x, ") =", mycos); 22 | println!( 23 | "sin^2(", 24 | x, 25 | ") + cos^2(", 26 | x, 27 | ") =", 28 | mysin * mysin + mycos * mycos 29 | ); 30 | } 31 | -------------------------------------------------------------------------------- /code_rs/test/src/testrgb.rs: -------------------------------------------------------------------------------- 1 | #![no_main] 2 | #![no_std] 3 | 4 | extern crate alloc; 5 | 6 | use crate::parm::rgb::{pixel_set, Color24bpp}; 7 | 8 | mod parm; 9 | 10 | unsafe fn main() { 11 | /*let picture = r#" 12 | # | 13 | ## ## | 14 | #.# #..# | 15 | #.# # # # #.BW.# | 16 | #..# #.#.#.##..BB.# | 17 | #..####.......#......# ### | 18 | #.......##.##.........#.B.#| 19 | #.................#......#| 20 | ##..........#.....###### | 21 | #..........#........# | 22 | #..######..# ######## | 23 | #..#..# #..# | 24 | ## ## ## 25 | "#;*/ 26 | 27 | let picture = r#" 28 | +++++++++++++++++++++++++| 29 | +++++++++O+O+O+O+++++++++| 30 | +++++++O++OOOOO++O+++++++| 31 | --------OOOOOOOOO--------| 32 | -O-O-O-OOOOOOOOOOO-O-O-O-| 33 | --OO--OOOOOOOOOOOOO--OO--| 34 | WWWOWWOOOOWBOWBOOOOWWOWWW| 35 | WWWWOOOOOOBBOBBOOOOOOWWWW| 36 | WWWWWObOOOOOOOOOOObOWWWWW| 37 | ----bO-bbbbbbbbbbb-Ob----| 38 | -----bO-b-------b-Ob-----| 39 | ------b-----------b------| 40 | +++++++b+++++++++b+++++++| 41 | +++++++++++++++++++++++++| 42 | +++++++++++++++++++++++++| 43 | "#; 44 | /* let picture = r#" 45 | ********************************| 46 | ********************************| 47 | ********************************| 48 | ********************************| 49 | ********************************| 50 | ********************************| 51 | ********************************| 52 | ********************************| 53 | ********************************| 54 | ********************************| 55 | ********************************| 56 | ********************************| 57 | ********************************| 58 | ********************************| 59 | ********************************| 60 | ********************************| 61 | "#; 62 | */ 63 | let mut x = 0; 64 | let mut y = 0; 65 | for c in (picture[1..]).bytes() { 66 | let color = match c { 67 | b'#' => Color24bpp::new(17, 117, 47), 68 | b'.' => Color24bpp::new(110, 218, 111), 69 | b'W' => Color24bpp::new(255, 255, 255), 70 | b'B' => Color24bpp::new(0, 0, 0), 71 | b'O' => Color24bpp::new(229, 149, 0), 72 | b'b' => Color24bpp::new(160, 106, 66), 73 | b'+' => Color24bpp::new(91, 207, 250), 74 | b'-' => Color24bpp::new(245, 170, 185), 75 | b'|' => { 76 | x = 0; 77 | y += 1; 78 | continue; 79 | } 80 | b'\n' => continue, 81 | _ => { 82 | x += 1; 83 | continue; 84 | } 85 | }; 86 | pixel_set(x, y, color); 87 | x += 1; 88 | } 89 | /* let pic = [ 90 | 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 91 | 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 92 | ];*/ 93 | /*pixel_set(0, 0, c1); 94 | pixel_set(0, 1, c1); 95 | pixel_set(0, 2, c1); 96 | pixel_set(0, 3, c1); 97 | pixel_set(0, 4, c1); 98 | pixel_set(1, 5, c1); 99 | pixel_set(1, 6, c1); 100 | pixel_set(2, 7, c1); 101 | pixel_set(3, 8, c1); 102 | pixel_set(4, 8, c1); 103 | pixel_set(5, 9, c1); 104 | pixel_set(4, 10, c1); 105 | pixel_set(4, 11, c1); 106 | pixel_set(5, 12, c1); 107 | pixel_set(6, 12, c1); 108 | pixel_set(7, 11, c1); 109 | pixel_set(8, 11, c1);*/ 110 | /*fn sq(x: fp32) -> fp32 { 111 | return x.sin(); 112 | } 113 | 114 | for x in 0..32 { 115 | pixel_set(16, x, parm::rgb::Color24bpp::new(0, 0, 0)); 116 | pixel_set(x, 16, parm::rgb::Color24bpp::new(0, 0, 0)); 117 | } 118 | 119 | const SCREEN_WIDTH: u8 = 32; 120 | const SCREEN_HEIGHT: u8 = 32; 121 | const WINDOW_WIDTH: f32 = 6.0; 122 | const WINDOW_HEIGHT: f32 = 5.0; 123 | let step = fp32::from(WINDOW_WIDTH / SCREEN_WIDTH as f32); 124 | let min = fp32::from(-WINDOW_WIDTH / 2.0) + step; 125 | 126 | let color = parm::rgb::Color24bpp::new(255, 0, 0); 127 | let mut cur = min; 128 | for i in 0..SCREEN_WIDTH { 129 | let val = sq(cur); 130 | let val_on_screen = SCREEN_HEIGHT as i32 / 2 - (val * fp32::from(SCREEN_HEIGHT as f32 / WINDOW_HEIGHT)).integer_part(); 131 | if val_on_screen >= 0 && val_on_screen < SCREEN_HEIGHT as i32 { 132 | pixel_set(i as u8, val_on_screen as u8, color); 133 | } 134 | cur += step; 135 | }*/ 136 | } 137 | -------------------------------------------------------------------------------- /code_rs/test/src/vendor/midly/LICENSE: -------------------------------------------------------------------------------- 1 | This is free and unencumbered software released into the public domain. 2 | 3 | Anyone is free to copy, modify, publish, use, compile, sell, or 4 | distribute this software, either in source code form or as a compiled 5 | binary, for any purpose, commercial or non-commercial, and by any 6 | means. 7 | 8 | In jurisdictions that recognize copyright laws, the author or authors 9 | of this software dedicate any and all copyright interest in the 10 | software to the public domain. We make this dedication for the benefit 11 | of the public at large and to the detriment of our heirs and 12 | successors. We intend this dedication to be an overt act of 13 | relinquishment in perpetuity of all present and future rights to this 14 | software under copyright law. 15 | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 17 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 18 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 19 | IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR 20 | OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 21 | ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 22 | OTHER DEALINGS IN THE SOFTWARE. 23 | 24 | For more information, please refer to 25 | -------------------------------------------------------------------------------- /code_rs/test/src/vendor/midly/error.rs: -------------------------------------------------------------------------------- 1 | 2 | 3 | #[cfg(not(all(debug_assertions, feature = "alloc")))] 4 | mod error_impl { 5 | use super::{Error, ErrorExt, ErrorKind}; 6 | 7 | /// In release mode errors are just a thin pointer. 8 | pub type ErrorInner = &'static ErrorKind; 9 | impl ErrorExt for Error { 10 | #[inline] 11 | fn kind(&self) -> ErrorKind { 12 | *self.inner 13 | } 14 | #[inline] 15 | fn source(&self) -> Option<&Error> { 16 | None 17 | } 18 | #[inline] 19 | fn chain_ctx(self, ctx: &'static ErrorKind) -> Error { 20 | Error { inner: ctx } 21 | } 22 | } 23 | impl From<&'static ErrorKind> for Error { 24 | #[inline] 25 | fn from(inner: &'static ErrorKind) -> Error { 26 | Error { inner } 27 | } 28 | } 29 | } 30 | 31 | /// Represents an error while parsing an SMF file or MIDI stream. 32 | /// 33 | /// This type wraps an `ErrorKind` and includes backtrace and error chain data in debug mode. 34 | /// In release mode it is a newtype wrapper around `ErrorKind`, so the `Error::source` method 35 | /// always returns `None`. 36 | /// 37 | /// If the `std` feature is enabled, this type implements `std::error::Error`. 38 | /// Otherwise, only `Display` and `Debug` are implemented (the `source` method on the `Error` type 39 | /// itself is still available, though). 40 | /// 41 | /// For more information about the error policy used by `midly`, see 42 | /// [`ErrorKind`](enum.ErrorKind.html). 43 | #[derive(Clone)] 44 | pub struct Error { 45 | inner: error_impl::ErrorInner, 46 | } 47 | impl Error { 48 | /// Create a new error with the given `ErrorKind`. 49 | #[inline] 50 | pub fn new(kind: &'static ErrorKind) -> Error { 51 | Error::from(kind) 52 | } 53 | 54 | /// More information about the error itself. 55 | #[inline] 56 | pub fn kind(&self) -> ErrorKind { 57 | ErrorExt::kind(self) 58 | } 59 | 60 | /// The underlying cause for this error. 61 | /// 62 | /// Note that this method will always return `None` in release mode, since error chains 63 | /// are not tracked in release. 64 | /// 65 | /// This method is available even if the `std` feature is not enabled. 66 | #[inline] 67 | pub fn source(&self) -> Option<&Error> { 68 | ErrorExt::source(self) 69 | } 70 | } 71 | 72 | trait ErrorExt { 73 | fn kind(&self) -> ErrorKind; 74 | fn source(&self) -> Option<&Error>; 75 | fn chain_ctx(self, ctx: &'static ErrorKind) -> Error; 76 | } 77 | 78 | /// The type of error that occurred while parsing. 79 | /// 80 | /// As a library consumer, detailed errors about what specific part of the MIDI spec was 81 | /// violated are not very useful. 82 | /// For this reason, errors are broadly categorized into 2 classes, and specific error info is 83 | /// provided as a non-normative string literal. 84 | #[derive(Copy, Clone)] 85 | pub enum ErrorKind { 86 | /// Fatal errors while reading the file. It is likely that the file is not a MIDI file or 87 | /// is severely corrupted. 88 | /// 89 | /// This error cannot be ignored, as there is not enough data to continue parsing. 90 | /// No information about the file could be rescued. 91 | Invalid(&'static str), 92 | 93 | /// Non-fatal error, but the file is clearly corrupted. 94 | /// 95 | /// This kind of error is not emitted by default, only if the `strict` crate feature is 96 | /// enabled. 97 | /// 98 | /// Ignoring these errors (if the `strict` feature is disabled) can cause whole tracks to be 99 | /// dropped. 100 | Malformed(&'static str), 101 | } 102 | impl ErrorKind { 103 | /// Get the informative message on what exact part of the MIDI format was not respected. 104 | #[inline] 105 | pub fn message(&self) -> &'static str { 106 | match *self { 107 | ErrorKind::Invalid(msg) => msg, 108 | ErrorKind::Malformed(msg) => msg, 109 | } 110 | } 111 | } 112 | 113 | macro_rules! err_invalid { 114 | ($msg:expr) => {{ 115 | const ERR_KIND: &'static ErrorKind = &ErrorKind::Invalid($msg); 116 | ERR_KIND 117 | }}; 118 | } 119 | macro_rules! err_malformed { 120 | ($msg:expr) => {{ 121 | const ERR_KIND: &'static ErrorKind = &ErrorKind::Malformed($msg); 122 | ERR_KIND 123 | }}; 124 | } 125 | 126 | pub(crate) trait ResultExt { 127 | fn context(self, ctx: &'static ErrorKind) -> StdResult; 128 | } 129 | impl ResultExt for StdResult { 130 | #[inline] 131 | fn context(self, ctx: &'static ErrorKind) -> StdResult { 132 | self.map_err(|err| err.chain_ctx(ctx)) 133 | } 134 | } 135 | impl ResultExt for StdResult { 136 | #[inline] 137 | fn context(self, ctx: &'static ErrorKind) -> StdResult { 138 | self.map_err(|errkind| Error::from(errkind).chain_ctx(ctx)) 139 | } 140 | } 141 | 142 | /// The result type used by the MIDI parser. 143 | pub type Result = StdResult; 144 | pub(crate) use core::result::Result as StdResult; 145 | -------------------------------------------------------------------------------- /code_rs/test/src/vendor/midly/riff.rs: -------------------------------------------------------------------------------- 1 | //! There's an abomination called RMID, MIDI embedded in a RIFF file. 2 | //! Support for these files is provided by unwrapping the input slice, stripping away the RIFF 3 | //! wrappers around the raw SMF file. 4 | 5 | use crate::vendor::midly::prelude::*; 6 | 7 | struct ChunkIter<'a>(&'a [u8]); 8 | impl<'a> Iterator for ChunkIter<'a> { 9 | type Item = ([u8; 4], &'a [u8]); 10 | fn next(&mut self) -> Option<([u8; 4], &'a [u8])> { 11 | if self.0.len() >= 8 { 12 | let mut id = [0; 4]; 13 | let mut len = [0; 4]; 14 | id.copy_from_slice(&self.0[..4]); 15 | len.copy_from_slice(&self.0[4..8]); 16 | self.0 = &self.0[8..]; 17 | let len = u32::from_le_bytes(len); 18 | let data = match self.0.split_checked(len as usize) { 19 | Some(data) => data, 20 | None => mem::replace(&mut self.0, &[]), 21 | }; 22 | if len % 2 == 1 { 23 | let _pad = self.0.split_checked(1); 24 | } 25 | Some((id, data)) 26 | } else { 27 | None 28 | } 29 | } 30 | } 31 | 32 | pub fn unwrap(raw: &[u8]) -> Result<&[u8]> { 33 | let (id, mut riff) = ChunkIter(raw) 34 | .next() 35 | .ok_or(err_invalid!("no main riff chunk"))?; 36 | if &id != b"RIFF" { 37 | bail!(err_invalid!("invalid main riff chunk")); 38 | } 39 | let formtype = riff 40 | .split_checked(4) 41 | .ok_or(err_invalid!("failed to read riff formtype"))?; 42 | if formtype != b"RMID" { 43 | bail!(err_invalid!("not an rmid riff file")); 44 | } 45 | for (id, chunk) in ChunkIter(riff) { 46 | if &id == b"data" { 47 | return Ok(chunk); 48 | } 49 | } 50 | bail!(err_invalid!("no rmid data chunk")) 51 | } 52 | -------------------------------------------------------------------------------- /code_rs/test/src/vendor/mod.rs: -------------------------------------------------------------------------------- 1 | pub mod midly; 2 | -------------------------------------------------------------------------------- /code_rs/test/telnetrunner.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | exec 3<>/dev/tcp/127.0.0.1/4567 3 | cd ~ 4 | unbuffer -p sh -c 'stty echo -onlcr cols 80 rows 25;sh' <&3 1>&3 2>&3 5 | -------------------------------------------------------------------------------- /code_rs/test/telnetrunner_video.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | exec 3<>/dev/tcp/127.0.0.1/4567 3 | cd ~ 4 | unbuffer -p sh -c 'stty echo -onlcr cols 80 rows 30 erase ^H;sh' <&3 1>&3 2>&3 5 | -------------------------------------------------------------------------------- /code_rs/test/test.bin: -------------------------------------------------------------------------------- 1 | v2.0 raw 2 | e7fe 200d 43c0 6801 2280 430a 6002 2101 0389 6802 438a 6002 e7fd 3 | -------------------------------------------------------------------------------- /code_rs/test/test.s: -------------------------------------------------------------------------------- 1 | run: 2 | 0: movs r0, #13 3 | 2: mvns r0, r0 4 | 4: ldr r1, [r0, #0] 5 | 6: movs r2, #128 ; 0x80 6 | 8: orrs r2, r1 7 | a: str r2, [r0, #0] 8 | c: movs r1, #1 9 | e: lsls r1, r1, #14 10 | 10: ldr r2, [r0, #0] 11 | 12: bics r2, r1 12 | 14: str r2, [r0, #0] 13 | 16: b.n 16 14 | -------------------------------------------------------------------------------- /code_rs/test/testfp.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zdimension/parm_extended/f3247976c2265619fe43b25d2262b79ad25e7cf4/code_rs/test/testfp.out -------------------------------------------------------------------------------- /digital_project/Flags_APSR.dig: -------------------------------------------------------------------------------- 1 | 2 | 3 | 1 4 | 5 | 6 | 7 | In 8 | 9 | 10 | Label 11 | Update_Mask 12 | 13 | 14 | Bits 15 | 4 16 | 17 | 18 | 19 | 20 | 21 | In 22 | 23 | 24 | Label 25 | Flags_In 26 | 27 | 28 | Bits 29 | 4 30 | 31 | 32 | 33 | 34 | 35 | In 36 | 37 | 38 | Label 39 | Clk 40 | 41 | 42 | 43 | 44 | 45 | In 46 | 47 | 48 | Label 49 | Rst 50 | 51 | 52 | 53 | 54 | 55 | And 56 | 57 | 58 | Bits 59 | 4 60 | 61 | 62 | wideShape 63 | true 64 | 65 | 66 | inverterConfig 67 | 68 | In_2 69 | 70 | 71 | 72 | 73 | 74 | 75 | And 76 | 77 | 78 | Bits 79 | 4 80 | 81 | 82 | wideShape 83 | true 84 | 85 | 86 | 87 | 88 | 89 | Or 90 | 91 | 92 | Bits 93 | 4 94 | 95 | 96 | wideShape 97 | true 98 | 99 | 100 | 101 | 102 | 103 | Out 104 | 105 | 106 | Label 107 | Flags_Out 108 | 109 | 110 | Bits 111 | 4 112 | 113 | 114 | 115 | 116 | 117 | D_FF_AS 118 | 119 | 120 | Label 121 | Flags 122 | 123 | 124 | Bits 125 | 4 126 | 127 | 128 | 129 | 130 | 131 | Ground 132 | 133 | 134 | rotation 135 | 136 | 137 | 138 | 139 | 140 | 141 | 142 | 143 | 144 | 145 | 146 | 147 | 148 | 149 | 150 | 151 | 152 | 153 | 154 | 155 | 156 | 157 | 158 | 159 | 160 | 161 | 162 | 163 | 164 | 165 | 166 | 167 | 168 | 169 | 170 | 171 | 172 | 173 | 174 | 175 | 176 | 177 | 178 | 179 | 180 | 181 | 182 | 183 | 184 | 185 | 186 | 187 | 188 | 189 | 190 | 191 | 192 | 193 | 194 | 195 | 196 | 197 | 198 | 199 | 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 209 | 210 | 211 | 212 | 213 | 214 | 215 | 216 | 217 | 218 | 219 | 220 | 221 | 222 | 223 | 224 | 225 | 226 | 227 | 228 | 229 | 230 | 231 | 232 | 233 | 234 | 235 | 236 | 237 | 238 | 239 | 240 | 241 | 242 | 243 | 244 | 245 | 246 | 247 | 248 | 249 | 250 | 251 | 252 | 253 | 254 | 255 | 256 | -------------------------------------------------------------------------------- /digital_project/LoToHi.dig: -------------------------------------------------------------------------------- 1 | 2 | 3 | 1 4 | 5 | 6 | 7 | In 8 | 9 | 10 | Label 11 | Reg 12 | 13 | 14 | Bits 15 | 3 16 | 17 | 18 | 19 | 20 | 21 | Out 22 | 23 | 24 | Label 25 | Out 26 | 27 | 28 | Bits 29 | 4 30 | 31 | 32 | 33 | 34 | 35 | Splitter 36 | 37 | 38 | Input Splitting 39 | 3,1 40 | 41 | 42 | Output Splitting 43 | 4 44 | 45 | 46 | 47 | 48 | 49 | Const 50 | 51 | 52 | Value 53 | 0 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | -------------------------------------------------------------------------------- /digital_project/midi.dig: -------------------------------------------------------------------------------- 1 | 2 | 3 | 1 4 | 5 | 6 | 7 | MIDI 8 | 9 | 10 | midiInstrument 11 | Halo Pad 12 | 13 | 14 | 15 | 16 | 17 | Clock 18 | 19 | 20 | Frequency 21 | 5 22 | 23 | 24 | runRealTime 25 | true 26 | 27 | 28 | 29 | 30 | 31 | Const 32 | 33 | 34 | 35 | 36 | Const 37 | 38 | 39 | 40 | 41 | Const 42 | 43 | 44 | Value 45 | 127 46 | 47 | 48 | Bits 49 | 7 50 | 51 | 52 | 53 | 54 | 55 | Counter 56 | 57 | 58 | Bits 59 | 7 60 | 61 | 62 | 63 | 64 | 65 | Const 66 | 67 | 68 | Value 69 | 0 70 | 71 | 72 | 73 | 74 | 75 | Const 76 | 77 | 78 | 79 | 80 | Add 81 | 82 | 83 | Bits 84 | 7 85 | 86 | 87 | 88 | 89 | 90 | Const 91 | 92 | 93 | Value 94 | 48 95 | 96 | 97 | Bits 98 | 7 99 | 100 | 101 | 102 | 103 | 104 | Const 105 | 106 | 107 | 108 | 109 | 110 | 111 | 112 | 113 | 114 | 115 | 116 | 117 | 118 | 119 | 120 | 121 | 122 | 123 | 124 | 125 | 126 | 127 | 128 | 129 | 130 | 131 | 132 | 133 | 134 | 135 | 136 | 137 | 138 | 139 | 140 | 141 | 142 | 143 | 144 | 145 | 146 | 147 | 148 | 149 | 150 | 151 | 152 | 153 | 154 | 155 | 156 | 157 | 158 | 159 | 160 | -------------------------------------------------------------------------------- /digital_project/terminal.dig: -------------------------------------------------------------------------------- 1 | 2 | 3 | 2 4 | 5 | 6 | 7 | Terminal 8 | 9 | 10 | 11 | 12 | Telnet 13 | 14 | 15 | telnetEscape 16 | false 17 | 18 | 19 | port 20 | 4567 21 | 22 | 23 | 24 | 25 | 26 | Keyboard 27 | 28 | 29 | 30 | 31 | Clock 32 | 33 | 34 | Frequency 35 | 100 36 | 37 | 38 | runRealTime 39 | true 40 | 41 | 42 | 43 | 44 | 45 | Tunnel 46 | 47 | 48 | NetName 49 | Clock 50 | 51 | 52 | 53 | 54 | 55 | Tunnel 56 | 57 | 58 | rotation 59 | 60 | 61 | 62 | NetName 63 | Clock 64 | 65 | 66 | 67 | 68 | 69 | Tunnel 70 | 71 | 72 | rotation 73 | 74 | 75 | 76 | NetName 77 | Clock 78 | 79 | 80 | 81 | 82 | 83 | Tunnel 84 | 85 | 86 | rotation 87 | 88 | 89 | 90 | NetName 91 | Clock 92 | 93 | 94 | 95 | 96 | 97 | Const 98 | 99 | 100 | 101 | 102 | Const 103 | 104 | 105 | 106 | 107 | Splitter 108 | 109 | 110 | Input Splitting 111 | 16 112 | 113 | 114 | 115 | 116 | 117 | 118 | 119 | 120 | 121 | 122 | 123 | 124 | 125 | 126 | 127 | 128 | 129 | 130 | 131 | 132 | 133 | 134 | 135 | 136 | 137 | 138 | 139 | 140 | 141 | 142 | 143 | 144 | 145 | 146 | 147 | 148 | 149 | 150 | 151 | 152 | 153 | 154 | 155 | 156 | 157 | 158 | 159 | 160 | 161 | 162 | 163 | 164 | 165 | 166 | 167 | 168 | 169 | 170 | 171 | 172 | 173 | 174 | 175 | 176 | 177 | 178 | 179 | 180 | -------------------------------------------------------------------------------- /lca_expanded.bin: -------------------------------------------------------------------------------- 1 | v2.0 raw 2 | 00 f0 00 f8 01 20 00 05 85 46 00 20 5f e0 83 b0 00 92 01 93 02 94 02 46 0b 46 cf 24 e4 43 20 68 61 68 00 9a 01 9b 02 9c 03 b0 70 47 81 b0 00 91 ff 21 c9 43 08 60 00 99 01 b0 70 47 82 b0 00 91 bc 46 77 46 01 97 67 46 01 00 0a 28 04 d3 0a 21 ff f7 dd ff ff f7 f2 ff 30 31 08 00 ff f7 e6 ff 00 99 bc 46 01 9f be 46 67 46 02 b0 70 47 02 b0 84 b0 00 94 01 96 02 97 bc 46 77 46 03 97 67 46 02 af ff 20 c4 43 00 20 a1 69 00 29 fc d0 e1 69 08 29 0a d0 0a 29 0e d0 0a 46 30 3a 0a 2a f3 d2 21 60 0a 21 41 43 50 18 ee e7 08 21 21 60 0a 21 ff f7 ad ff e8 e7 0a 21 21 60 00 9c 01 9e 02 9f bc 46 03 9f be 46 67 46 04 b0 70 47 04 b0 7b 20 ff f7 b4 ff ff f7 cc ff 01 00 41 20 ff f7 a6 ff 08 00 ff f7 ab ff 3 | -------------------------------------------------------------------------------- /lca_expanded.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zdimension/parm_extended/f3247976c2265619fe43b25d2262b79ad25e7cf4/lca_expanded.raw -------------------------------------------------------------------------------- /lca_expanded.s: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | run: 12 | movs r0, #1 13 | lsls r0, r0, #20 14 | mov sp, r0 15 | movs r0, #0 16 | 17 | b main 18 | 19 | divmod_uint: 20 | push {r2, r3, r4} 21 | mov r2, r0 22 | mov r3, r1 23 | movs r4, #207 24 | mvns r4, r4 25 | ldr r0, [r4] 26 | ldr r1, [r4, #4] 27 | pop {r2, r3, r4} 28 | bx lr 29 | 30 | print_char: 31 | push {r1} 32 | movs r1, #255 33 | mvns r1, r1 34 | str r0, [r1] 35 | pop {r1} 36 | bx lr 37 | 38 | print_int: 39 | push {r1, lr} 40 | movs r1, r0 41 | cmp r0, #10 42 | blo .print_int_one_digit 43 | movs r1, #10 44 | bl divmod_uint 45 | bl print_int 46 | .print_int_one_digit: 47 | adds r1, #48 48 | movs r0, r1 49 | bl print_char 50 | pop {r1, pc} 51 | 52 | read_int: 53 | push {r4, r6, r7, lr} 54 | .setfp r7, sp, #8 55 | add r7, sp, #8 56 | movs r0, #255 57 | mvns r4, r0 58 | movs r0, #0 59 | .read_int_loop: 60 | ldr r1, [r4, #24] 61 | cmp r1, #0 62 | beq .read_int_loop 63 | ldr r1, [r4, #28] 64 | cmp r1, #8 65 | beq .read_int_backspace 66 | cmp r1, #10 67 | beq .read_int_end 68 | mov r2, r1 69 | subs r2, #48 70 | cmp r2, #10 71 | bhs .read_int_loop 72 | str r1, [r4] 73 | movs r1, #10 74 | muls r1, r0, r1 75 | adds r0, r2, r1 76 | b .read_int_loop 77 | .read_int_backspace: 78 | movs r1, #8 79 | str r1, [r4] 80 | movs r1, #10 81 | bl divmod_uint 82 | b .read_int_loop 83 | .read_int_end: 84 | movs r1, #10 85 | str r1, [r4] 86 | pop {r4, r6, r7, pc} 87 | 88 | main: 89 | movs r0, #123 90 | bl print_int 91 | 92 | bl read_int 93 | movs r1, r0 94 | movs r0, #65 95 | bl print_char 96 | movs r0, r1 97 | bl print_int 98 | -------------------------------------------------------------------------------- /lca_programme.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zdimension/parm_extended/f3247976c2265619fe43b25d2262b79ad25e7cf4/lca_programme.bin -------------------------------------------------------------------------------- /lca_programme.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zdimension/parm_extended/f3247976c2265619fe43b25d2262b79ad25e7cf4/lca_programme.o -------------------------------------------------------------------------------- /lca_project/README.md: -------------------------------------------------------------------------------- 1 | # Projet Compilation 2 | 3 | *Note: on suppose ici que vous travaillez dans un environnement Linux. Sur Windows, WSL2 (pas WSL1) convient. Sur Mac, il faudra une VM.* 4 | 5 | ## Dépendances 6 | 7 | ### Paquets Linux 8 | 9 | ``` 10 | sudo apt install build-essential gcc-arm-linux-gnueabi qemu-user 11 | ``` 12 | 13 | ### PARM 14 | 15 | 1. Clonez quelque part le dépôt http://github.com/zdimension/parm-extended 16 | 2. Téléchargez quelque part Digital depuis [ce lien](https://github.com/hneemann/Digital/releases/download/v0.30/Digital.zip) 17 | 3. Téléchargez [ce jar](https://domino.zdimension.fr/poubelle/digital.jar) et mettez le dans le dossier de Digital en remplaçant l'existant 18 | 4. Lancez Digital (via le jar) et assurez vous qu'aucune erreur n'est affichée 19 | 20 | # Structure générale 21 | 22 | Votre compilateur émettra du code assembleur dans le fichier `lca_programme.S` (S majuscule) présent dans ce dossier. Voici un exemple de sortie : 23 | 24 | ```arm 25 | #include "lca_lib.S" 26 | 27 | main: 28 | @ affiche 123 29 | movs r0, #123 30 | bl print_int 31 | 32 | @ lit un nombre 33 | bl read_int 34 | movs r1, r0 35 | 36 | @ affiche 'A' 37 | movs r0, #65 38 | bl print_char 39 | 40 | @ affiche le nombre lu 41 | movs r0, r1 42 | bl print_int 43 | 44 | @ quitte avec le nombre lu comme code de sortie 45 | bl exit 46 | ``` 47 | 48 | Les programmes assembleur incluent la librairie standard du projet (`lca_lib.S`) à l'aide de la directive `#include`. Cette ligne doit toujours être présente en haut du fichier généré. 49 | 50 | Le programme peut contenir plusieurs fonctions, mais il doit contenir au minimum un label `main:` qui sera exécuté quand le programme est lancé. Cette fonction `main` doit se terminer par un appel à la fonction `exit`. 51 | 52 | # Compilation 53 | 54 | Les fichiers générés pourront être compilés à la fois pour Linux et pour PARM. 55 | 56 | Il faut se placer dans un terminal dans le dossier `lca_project`. 57 | 58 | ## Pour Linux 59 | 60 | Exécuter le fichier `./build_linux.sh`. 61 | 62 | Ensuite, lancer le programme via `qemu-arm ./lca_programme.exe`. 63 | 64 | Pour le programme d'exemple fourni plus-haut, la sortie du programme devrait ressembler à ceci : 65 | 66 | ``` 67 | $ qemu-arm ./lca_programme.exe # on lance QEMU 68 | 123 69 | 42 70 | A42 71 | $ echo $? # on regarde le code de retour pour vérifier que c'est bien le nombre saisi 72 | 42 73 | ``` 74 | 75 | ## Pour PARM 76 | 77 | Exécuter le fichier `./build_parm.sh`. 78 | 79 | Votre code assembleur est compilé vers le fichier lca_expanded.raw qui sera lu par Digital. 80 | 81 | Vous pouvez ensuite lancer le circuit dans Digital, le programme est chargé automatiquement. 82 | 83 | Sur PARM, le code de retour (donné à `exit`) est affiché dans `RES`. 84 | 85 | Pour le programme d'exemple, voici à quoi ça ressemble : 86 | 87 | https://github.com/zdimension/parm_extended/assets/4533568/04af769a-1932-43f6-950d-55f42555ab5b 88 | 89 | 90 | # Librairie standard 91 | 92 | Les fonctions suivantes sont fournies dans la librairie standard : 93 | 94 | - `exit` : quitte le programme 95 | - paramètres : `r0` (code de sortie) 96 | 97 | - `print_char` : affiche un seul caractère 98 | - paramètres : `r0` (caractère à afficher, exemple : 65 pour le caractère A majuscule) 99 | 100 | - `print_int` : affiche un nombre entier (non signé) suivi d'un saut de ligne 101 | - paramètres : `r0` (nombre à afficher) 102 | 103 | - `read_int` : lit un nombre entier (non signé) depuis le clavier 104 | - aucun paramètre 105 | - renvoie le nombre lu dans `r0` 106 | 107 | - `divmod_uint` : divise deux nombres entiers (non signés) 108 | - paramètres : `r0` (dividende), `r1` (diviseur) 109 | - renvoie `r0 / r1` (le quotient) dans `r2` et `r0 % r1` (le reste) dans `r3` 110 | 111 | **Rappel :** une fonction est appelée par `bl nomdelafonction` après avoir rempli ses paramètres. 112 | 113 | Après un appel de fonction, les valeurs qui se trouvaient dans les registres auparavant 114 | sont restaurées sauf dans le cas où la fonction renvoie une valeur dans ces registres, exemple : 115 | 116 | ```arm 117 | movs r1, #123 118 | bl fonction ; on suppose que fonction renvoie une valeur dans r0 119 | ; ici, r1 est garanti de toujours valoir 123 120 | ``` 121 | 122 | Si une fonction ne renvoie rien, tous les registres sont préservés. 123 | 124 | # PARM et utilisation de Digital 125 | 126 | ## Navigation 127 | 128 | Clic-droit-glisser pour se déplacer, molette pour zoomer. 129 | 130 | ## Exécution 131 | 132 | D'abord, choisir l'horloge désirée en faisant clic-droit sur le composant horloge : 133 | 134 | ![image](https://github.com/zdimension/parm_extended/assets/4533568/8e7bddab-7cb6-4482-9d9e-20c850299c45) 135 | 136 | Pour déboguer pas-à-pas, décocher la case. Pour lancer le programme en entier, cocher, et mettre par exemple 100 ou 200 Hz. 137 | 138 | Pour lancer l'exécution, utiliser le triangle, pour arrêter, utiliser le carré : 139 | 140 | ![image](https://github.com/zdimension/parm_extended/assets/4533568/99159e78-9274-4e4b-b171-b7cd5adfe187) 141 | 142 | Pendant l'exécution, vous pouvez inspecter l'état du processeur (registres, ...) via la fenêtre Mesure accessible via le menu Simulation → Afficher le tableau des mesures. 143 | 144 | En mode pas-à-pas, vous pouvez sur l'horloge pour faire un tic de processeur. 145 | 146 | # Problèmes courants 147 | 148 | ## \r command not found 149 | 150 | ``` 151 | $ ./build_linux.sh 152 | ./build_linux.sh: line 2: $'\r': command not found 153 | ``` 154 | 155 | Vous êtes probablement sous Windows et Git a mis les fichiers en format Windows. Faites `dos2unix build_linux.sh` pour corriger le fichier et réessayez. 156 | 157 | ## Impossible de lancer le .jar 158 | 159 | Avez-vous installé Java ? 160 | 161 | ## Composant "RAM32bit" non trouvé 162 | 163 | Menu Édition → Paramètres, onglet Avancé, définir le paramètre Bibliothèque au dossier `lib` situé dans le dossier `Digital`, puis fermer et rouvrir Digital. 164 | -------------------------------------------------------------------------------- /lca_project/build_linux.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | arm-linux-gnueabi-gcc -static -o lca_programme.exe lca_programme.S 4 | -------------------------------------------------------------------------------- /lca_project/build_parm.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | cpp -Ulinux -E lca_programme.S | grep -v '^#' > lca_expanded.s && 4 | ../asm/assembleur.py lca_expanded.s && 5 | cp lca_expanded.raw ../code_rs/test/bin/digital_out.raw 6 | -------------------------------------------------------------------------------- /lca_project/lca_expanded.bin: -------------------------------------------------------------------------------- 1 | v2.0 raw 2 | 00 f0 00 f8 01 20 00 05 85 46 00 20 78 e0 fb 21 c9 43 08 60 fe e7 83 b0 00 92 01 93 02 94 02 46 0b 46 cf 24 e4 43 20 68 61 68 00 9a 01 9b 02 9c 03 b0 70 47 81 b0 00 91 ff 21 c9 43 08 60 00 99 01 b0 70 47 83 b0 00 90 01 91 bc 46 77 46 02 97 67 46 01 00 0a 28 04 d3 0a 21 ff f7 dc ff ff f7 f1 ff 30 31 08 00 ff f7 e5 ff 00 98 01 99 bc 46 02 9f be 46 67 46 03 b0 70 47 03 b0 82 b0 00 90 bc 46 77 46 01 97 67 46 ff f7 dc ff 0a 20 ff f7 d1 ff 00 98 bc 46 01 9f be 46 67 46 02 b0 70 47 02 b0 84 b0 00 94 01 96 02 97 bc 46 77 46 03 97 67 46 02 af ff 20 c4 43 00 20 a1 69 00 29 fc d0 e1 69 08 29 0a d0 0a 29 0e d0 0a 46 30 3a 0a 2a f3 d2 21 60 0a 21 41 43 50 18 ee e7 08 21 21 60 0a 21 ff f7 98 ff e8 e7 0a 21 21 60 00 9c 01 9e 02 9f bc 46 03 9f be 46 67 46 04 b0 70 47 04 b0 7b 20 ff f7 bb ff ff f7 cc ff 01 00 41 20 ff f7 91 ff 08 00 ff f7 b2 ff ff f7 79 ff 3 | -------------------------------------------------------------------------------- /lca_project/lca_expanded.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zdimension/parm_extended/f3247976c2265619fe43b25d2262b79ad25e7cf4/lca_project/lca_expanded.raw -------------------------------------------------------------------------------- /lca_project/lca_expanded.s: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | @ MMIO ports 5 | @ entry point 6 | run: 7 | @ init stack pointer to 0x100000 8 | movs r0, #1 9 | lsls r0, r0, #20 10 | mov sp, r0 11 | movs r0, #0 12 | 13 | b main 14 | 15 | @ stores exit code in #251 and loops infinitely 16 | exit: 17 | movs r1, #251 18 | mvns r1, r1 19 | str r0, [r1] 20 | .exit_loop: 21 | b .exit_loop 22 | 23 | @ divides r0 by r1, returns quotient in r0 and remainder in r1 24 | divmod_uint: 25 | push {r2, r3, r4} 26 | mov r2, r0 27 | mov r3, r1 28 | movs r4, #207 29 | mvns r4, r4 30 | ldr r0, [r4] 31 | ldr r1, [r4, #4] 32 | pop {r2, r3, r4} 33 | bx lr 34 | 35 | @ prints char in r0 to TTY 36 | print_char: 37 | push {r1} 38 | movs r1, #255 39 | mvns r1, r1 40 | str r0, [r1] 41 | pop {r1} 42 | bx lr 43 | 44 | @ prints (unsigned) int in r0 to TTY 45 | print_int_no_newline: 46 | push {r0, r1, lr} 47 | movs r1, r0 48 | cmp r0, #10 49 | blo .print_int_one_digit 50 | movs r1, #10 51 | bl divmod_uint 52 | bl print_int_no_newline 53 | .print_int_one_digit: 54 | adds r1, #48 55 | movs r0, r1 56 | bl print_char 57 | pop {r0, r1, pc} 58 | 59 | print_int: 60 | push {r0, lr} 61 | bl print_int_no_newline 62 | movs r0, #10 63 | bl print_char 64 | pop {r0, pc} 65 | 66 | @ reads int from keyboard, echoing to TTY 67 | read_int: 68 | push {r4, r6, r7, lr} 69 | .setfp r7, sp, #8 70 | add r7, sp, #8 71 | movs r0, #255 72 | mvns r4, r0 73 | movs r0, #0 74 | .read_int_loop: 75 | ldr r1, [r4, #24] 76 | cmp r1, #0 77 | beq .read_int_loop 78 | ldr r1, [r4, #28] 79 | cmp r1, #8 80 | beq .read_int_backspace 81 | cmp r1, #10 82 | beq .read_int_end 83 | mov r2, r1 84 | subs r2, #48 85 | cmp r2, #10 86 | bhs .read_int_loop 87 | str r1, [r4] 88 | movs r1, #10 89 | muls r1, r0, r1 90 | adds r0, r2, r1 91 | b .read_int_loop 92 | .read_int_backspace: 93 | movs r1, #8 94 | str r1, [r4] 95 | movs r1, #10 96 | bl divmod_uint 97 | b .read_int_loop 98 | .read_int_end: 99 | movs r1, #10 100 | str r1, [r4] 101 | pop {r4, r6, r7, pc} 102 | 103 | main: 104 | @ affiche 123 105 | movs r0, #123 106 | bl print_int 107 | 108 | @ lit un nombre 109 | bl read_int 110 | movs r1, r0 111 | 112 | @ affiche 'A' 113 | movs r0, #65 114 | bl print_char 115 | 116 | @ affiche le nombre lu 117 | movs r0, r1 118 | bl print_int 119 | 120 | @ quitte avec le nombre lu comme code de sortie 121 | bl exit 122 | -------------------------------------------------------------------------------- /lca_project/lca_lib.S: -------------------------------------------------------------------------------- 1 | #ifdef linux 2 | #include "lca_lib_linux.S" 3 | #else 4 | #include "lca_lib_parm.S" 5 | #endif 6 | -------------------------------------------------------------------------------- /lca_project/lca_lib_linux.S: -------------------------------------------------------------------------------- 1 | .LC0: 2 | .ascii "%d\000" 3 | .align 2 4 | .LC1: 5 | .ascii "%d\012\000" 6 | .text 7 | .align 2 8 | .LC2: 9 | .ascii "%c\000" 10 | .align 2 11 | .global main 12 | 13 | .global print_int 14 | print_int: 15 | push {r0, r1, lr} 16 | movs r1, r0 17 | ldr r0, =.LC1 18 | bl printf 19 | pop {r0, r1, pc} 20 | 21 | .global read_int 22 | read_int: 23 | push {r1, lr} 24 | ldr r0, =.LC0 25 | sub sp, #4 26 | movs r1, sp 27 | bl scanf 28 | ldr r0, [sp] 29 | add sp, #4 30 | pop {r1, pc} 31 | 32 | .global print_char 33 | print_char: 34 | push {r0, r1, lr} 35 | movs r1, r0 36 | ldr r0, =.LC2 37 | bl printf 38 | pop {r0, r1, pc} 39 | -------------------------------------------------------------------------------- /lca_project/lca_lib_parm.S: -------------------------------------------------------------------------------- 1 | @ MMIO ports 2 | #define TTYchr #255 3 | #define RES #251 4 | #define TELNETdata #247 5 | #define TELNETavail #243 6 | #define MIDInote #239 7 | #define MIDIvol #235 8 | #define MIDIon #231 9 | #define MIDIinstr #227 10 | #define KEYBeof #223 11 | #define KEYBchr #219 12 | #define RNG32 #215 13 | #define RESbcd #211 14 | #define R2divR3 #207 15 | #define R2modR3 #203 16 | 17 | @ entry point 18 | run: 19 | @ init stack pointer to 0x100000 20 | movs r0, #1 21 | lsls r0, r0, #20 22 | mov sp, r0 23 | movs r0, #0 24 | 25 | b main 26 | 27 | @ stores exit code in RES and loops infinitely 28 | exit: 29 | movs r1, RES 30 | mvns r1, r1 31 | str r0, [r1] 32 | .exit_loop: 33 | b .exit_loop 34 | 35 | @ divides r0 by r1, returns quotient in r0 and remainder in r1 36 | divmod_uint: 37 | push {r2, r3, r4} 38 | mov r2, r0 39 | mov r3, r1 40 | movs r4, R2divR3 41 | mvns r4, r4 42 | ldr r0, [r4] 43 | ldr r1, [r4, #4] 44 | pop {r2, r3, r4} 45 | bx lr 46 | 47 | @ prints char in r0 to TTY 48 | print_char: 49 | push {r1} 50 | movs r1, TTYchr 51 | mvns r1, r1 52 | str r0, [r1] 53 | pop {r1} 54 | bx lr 55 | 56 | @ prints (unsigned) int in r0 to TTY 57 | print_int_no_newline: 58 | push {r0, r1, lr} 59 | movs r1, r0 60 | cmp r0, #10 61 | blo .print_int_one_digit 62 | movs r1, #10 63 | bl divmod_uint 64 | bl print_int_no_newline 65 | .print_int_one_digit: 66 | adds r1, #48 67 | movs r0, r1 68 | bl print_char 69 | pop {r0, r1, pc} 70 | 71 | print_int: 72 | push {r0, lr} 73 | bl print_int_no_newline 74 | movs r0, #10 75 | bl print_char 76 | pop {r0, pc} 77 | 78 | @ reads int from keyboard, echoing to TTY 79 | read_int: 80 | push {r4, r6, r7, lr} 81 | .setfp r7, sp, #8 82 | add r7, sp, #8 83 | movs r0, #255 84 | mvns r4, r0 85 | movs r0, #0 86 | .read_int_loop: 87 | ldr r1, [r4, #24] 88 | cmp r1, #0 89 | beq .read_int_loop 90 | ldr r1, [r4, #28] 91 | cmp r1, #8 92 | beq .read_int_backspace 93 | cmp r1, #10 94 | beq .read_int_end 95 | mov r2, r1 96 | subs r2, #48 97 | cmp r2, #10 98 | bhs .read_int_loop 99 | str r1, [r4] 100 | movs r1, #10 101 | muls r1, r0, r1 102 | adds r0, r2, r1 103 | b .read_int_loop 104 | .read_int_backspace: 105 | movs r1, #8 106 | str r1, [r4] 107 | movs r1, #10 108 | bl divmod_uint 109 | b .read_int_loop 110 | .read_int_end: 111 | movs r1, #10 112 | str r1, [r4] 113 | pop {r4, r6, r7, pc} 114 | -------------------------------------------------------------------------------- /lca_project/lca_programme.S: -------------------------------------------------------------------------------- 1 | #include "lca_lib.S" 2 | 3 | main: 4 | @ affiche 123 5 | movs r0, #123 6 | bl print_int 7 | 8 | @ lit un nombre 9 | bl read_int 10 | movs r1, r0 11 | 12 | @ affiche 'A' 13 | movs r0, #65 14 | bl print_char 15 | 16 | @ affiche le nombre lu 17 | movs r0, r1 18 | bl print_int 19 | 20 | @ quitte avec le nombre lu comme code de sortie 21 | bl exit --------------------------------------------------------------------------------