j/Chirp
1
1
Fork 0
Code Issues 3 Pull Requests Packages Projects Releases Wiki Activity
ef3d765651
Chirp/Cargo.lock

101 lines
2.4 KiB
Plaintext
Raw Normal View History

Initial commit: Created outline of emulator: The emulator has a Bus, which attaches a CPU to some Memory (Mapped Devices) The design isn't particularly efficient, but the interpreter only needs to run at ~500Hz or so. It's Rust. It can do that. Instructions yet to be implemented: Cxbb: "Store a random number, masked by bitmask bb, into vX" Dxyn: "Draw an 8 by n sprite to the screen at coordinates (x, y)" Fx0A: "Wait for a key, then set vX to the value of the pressed key" Fx33: "BCD convert X, storing the results in &I[0..3]" Thoughts going forward: - It's probably a good idea to parse instructions out into an enum. I had this in an earlier design, but it didn't really look that good. However, I haven't read many other emulators before, so I don't know the style people generally go for. - I haven't used a native graphics library before, and my cg class was done entirely in a web browser. That kinda sucks, honestly. Sure the skill might transfer well, but, >JS
2023-03-08 12:07:33 +00:00
# This file is automatically @generated by Cargo.
# It is not intended for manual editing.
version = 3
Rumpulator: Change name to Chumpulator
2023-03-10 21:33:36 +00:00
[[package]]
name = "chumpulator"
version = "0.1.0"
dependencies = [
"owo-colors",
experimentation: benchmarking and alternate impl's - Do some basic benchmarking with std::time - Try writing bus writer based on iterator - Fail, because that requires mutable iterator - Begin rewriting bus based on simpler design instead. - Simpler design uses a unified memory model, which grows based on the maximum addresses expected in it - Still uses the "infallible" Read/Write traits from previous implementation. :( Alas, it's much faster during operation, even if it takes longer to instantiate. - Reassessed the syntax for bus macro - Made CPU tick generic over bus::Read and bus::Write traits
2023-03-18 01:06:31 +00:00
"rhexdump",
Rumpulator: Change name to Chumpulator
2023-03-10 21:33:36 +00:00
"serde",
"thiserror",
]
Initial commit: Created outline of emulator: The emulator has a Bus, which attaches a CPU to some Memory (Mapped Devices) The design isn't particularly efficient, but the interpreter only needs to run at ~500Hz or so. It's Rust. It can do that. Instructions yet to be implemented: Cxbb: "Store a random number, masked by bitmask bb, into vX" Dxyn: "Draw an 8 by n sprite to the screen at coordinates (x, y)" Fx0A: "Wait for a key, then set vX to the value of the pressed key" Fx33: "BCD convert X, storing the results in &I[0..3]" Thoughts going forward: - It's probably a good idea to parse instructions out into an enum. I had this in an earlier design, but it didn't really look that good. However, I haven't read many other emulators before, so I don't know the style people generally go for. - I haven't used a native graphics library before, and my cg class was done entirely in a web browser. That kinda sucks, honestly. Sure the skill might transfer well, but, >JS
2023-03-08 12:07:33 +00:00
[[package]]
name = "owo-colors"
version = "3.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c1b04fb49957986fdce4d6ee7a65027d55d4b6d2265e5848bbb507b58ccfdb6f"
[[package]]
name = "proc-macro2"
version = "1.0.51"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5d727cae5b39d21da60fa540906919ad737832fe0b1c165da3a34d6548c849d6"
dependencies = [
"unicode-ident",
]
[[package]]
name = "quote"
version = "1.0.23"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8856d8364d252a14d474036ea1358d63c9e6965c8e5c1885c18f73d70bff9c7b"
dependencies = [
"proc-macro2",
]
experimentation: benchmarking and alternate impl's - Do some basic benchmarking with std::time - Try writing bus writer based on iterator - Fail, because that requires mutable iterator - Begin rewriting bus based on simpler design instead. - Simpler design uses a unified memory model, which grows based on the maximum addresses expected in it - Still uses the "infallible" Read/Write traits from previous implementation. :( Alas, it's much faster during operation, even if it takes longer to instantiate. - Reassessed the syntax for bus macro - Made CPU tick generic over bus::Read and bus::Write traits
2023-03-18 01:06:31 +00:00
[[package]]
name = "rhexdump"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c5e9af64574935e39f24d1c0313a997c8b880ca0e087c888bc6af8af31579847"
Initial commit: Created outline of emulator: The emulator has a Bus, which attaches a CPU to some Memory (Mapped Devices) The design isn't particularly efficient, but the interpreter only needs to run at ~500Hz or so. It's Rust. It can do that. Instructions yet to be implemented: Cxbb: "Store a random number, masked by bitmask bb, into vX" Dxyn: "Draw an 8 by n sprite to the screen at coordinates (x, y)" Fx0A: "Wait for a key, then set vX to the value of the pressed key" Fx33: "BCD convert X, storing the results in &I[0..3]" Thoughts going forward: - It's probably a good idea to parse instructions out into an enum. I had this in an earlier design, but it didn't really look that good. However, I haven't read many other emulators before, so I don't know the style people generally go for. - I haven't used a native graphics library before, and my cg class was done entirely in a web browser. That kinda sucks, honestly. Sure the skill might transfer well, but, >JS
2023-03-08 12:07:33 +00:00
[[package]]
name = "serde"
experimentation: benchmarking and alternate impl's - Do some basic benchmarking with std::time - Try writing bus writer based on iterator - Fail, because that requires mutable iterator - Begin rewriting bus based on simpler design instead. - Simpler design uses a unified memory model, which grows based on the maximum addresses expected in it - Still uses the "infallible" Read/Write traits from previous implementation. :( Alas, it's much faster during operation, even if it takes longer to instantiate. - Reassessed the syntax for bus macro - Made CPU tick generic over bus::Read and bus::Write traits
2023-03-18 01:06:31 +00:00
version = "1.0.154"
Initial commit: Created outline of emulator: The emulator has a Bus, which attaches a CPU to some Memory (Mapped Devices) The design isn't particularly efficient, but the interpreter only needs to run at ~500Hz or so. It's Rust. It can do that. Instructions yet to be implemented: Cxbb: "Store a random number, masked by bitmask bb, into vX" Dxyn: "Draw an 8 by n sprite to the screen at coordinates (x, y)" Fx0A: "Wait for a key, then set vX to the value of the pressed key" Fx33: "BCD convert X, storing the results in &I[0..3]" Thoughts going forward: - It's probably a good idea to parse instructions out into an enum. I had this in an earlier design, but it didn't really look that good. However, I haven't read many other emulators before, so I don't know the style people generally go for. - I haven't used a native graphics library before, and my cg class was done entirely in a web browser. That kinda sucks, honestly. Sure the skill might transfer well, but, >JS
2023-03-08 12:07:33 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
experimentation: benchmarking and alternate impl's - Do some basic benchmarking with std::time - Try writing bus writer based on iterator - Fail, because that requires mutable iterator - Begin rewriting bus based on simpler design instead. - Simpler design uses a unified memory model, which grows based on the maximum addresses expected in it - Still uses the "infallible" Read/Write traits from previous implementation. :( Alas, it's much faster during operation, even if it takes longer to instantiate. - Reassessed the syntax for bus macro - Made CPU tick generic over bus::Read and bus::Write traits
2023-03-18 01:06:31 +00:00
checksum = "8cdd151213925e7f1ab45a9bbfb129316bd00799784b174b7cc7bcd16961c49e"
Initial commit: Created outline of emulator: The emulator has a Bus, which attaches a CPU to some Memory (Mapped Devices) The design isn't particularly efficient, but the interpreter only needs to run at ~500Hz or so. It's Rust. It can do that. Instructions yet to be implemented: Cxbb: "Store a random number, masked by bitmask bb, into vX" Dxyn: "Draw an 8 by n sprite to the screen at coordinates (x, y)" Fx0A: "Wait for a key, then set vX to the value of the pressed key" Fx33: "BCD convert X, storing the results in &I[0..3]" Thoughts going forward: - It's probably a good idea to parse instructions out into an enum. I had this in an earlier design, but it didn't really look that good. However, I haven't read many other emulators before, so I don't know the style people generally go for. - I haven't used a native graphics library before, and my cg class was done entirely in a web browser. That kinda sucks, honestly. Sure the skill might transfer well, but, >JS
2023-03-08 12:07:33 +00:00
dependencies = [
"serde_derive",
]
[[package]]
name = "serde_derive"
experimentation: benchmarking and alternate impl's - Do some basic benchmarking with std::time - Try writing bus writer based on iterator - Fail, because that requires mutable iterator - Begin rewriting bus based on simpler design instead. - Simpler design uses a unified memory model, which grows based on the maximum addresses expected in it - Still uses the "infallible" Read/Write traits from previous implementation. :( Alas, it's much faster during operation, even if it takes longer to instantiate. - Reassessed the syntax for bus macro - Made CPU tick generic over bus::Read and bus::Write traits
2023-03-18 01:06:31 +00:00
version = "1.0.154"
Initial commit: Created outline of emulator: The emulator has a Bus, which attaches a CPU to some Memory (Mapped Devices) The design isn't particularly efficient, but the interpreter only needs to run at ~500Hz or so. It's Rust. It can do that. Instructions yet to be implemented: Cxbb: "Store a random number, masked by bitmask bb, into vX" Dxyn: "Draw an 8 by n sprite to the screen at coordinates (x, y)" Fx0A: "Wait for a key, then set vX to the value of the pressed key" Fx33: "BCD convert X, storing the results in &I[0..3]" Thoughts going forward: - It's probably a good idea to parse instructions out into an enum. I had this in an earlier design, but it didn't really look that good. However, I haven't read many other emulators before, so I don't know the style people generally go for. - I haven't used a native graphics library before, and my cg class was done entirely in a web browser. That kinda sucks, honestly. Sure the skill might transfer well, but, >JS
2023-03-08 12:07:33 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
experimentation: benchmarking and alternate impl's - Do some basic benchmarking with std::time - Try writing bus writer based on iterator - Fail, because that requires mutable iterator - Begin rewriting bus based on simpler design instead. - Simpler design uses a unified memory model, which grows based on the maximum addresses expected in it - Still uses the "infallible" Read/Write traits from previous implementation. :( Alas, it's much faster during operation, even if it takes longer to instantiate. - Reassessed the syntax for bus macro - Made CPU tick generic over bus::Read and bus::Write traits
2023-03-18 01:06:31 +00:00
checksum = "4fc80d722935453bcafdc2c9a73cd6fac4dc1938f0346035d84bf99fa9e33217"
Initial commit: Created outline of emulator: The emulator has a Bus, which attaches a CPU to some Memory (Mapped Devices) The design isn't particularly efficient, but the interpreter only needs to run at ~500Hz or so. It's Rust. It can do that. Instructions yet to be implemented: Cxbb: "Store a random number, masked by bitmask bb, into vX" Dxyn: "Draw an 8 by n sprite to the screen at coordinates (x, y)" Fx0A: "Wait for a key, then set vX to the value of the pressed key" Fx33: "BCD convert X, storing the results in &I[0..3]" Thoughts going forward: - It's probably a good idea to parse instructions out into an enum. I had this in an earlier design, but it didn't really look that good. However, I haven't read many other emulators before, so I don't know the style people generally go for. - I haven't used a native graphics library before, and my cg class was done entirely in a web browser. That kinda sucks, honestly. Sure the skill might transfer well, but, >JS
2023-03-08 12:07:33 +00:00
dependencies = [
"proc-macro2",
"quote",
"syn",
]
[[package]]
name = "syn"
version = "1.0.109"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
dependencies = [
"proc-macro2",
"quote",
"unicode-ident",
]
[[package]]
name = "thiserror"
version = "1.0.39"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a5ab016db510546d856297882807df8da66a16fb8c4101cb8b30054b0d5b2d9c"
dependencies = [
"thiserror-impl",
]
[[package]]
name = "thiserror-impl"
version = "1.0.39"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5420d42e90af0c38c3290abcca25b9b3bdf379fc9f55c528f53a269d9c9a267e"
dependencies = [
"proc-macro2",
"quote",
"syn",
]
[[package]]
name = "unicode-ident"
version = "1.0.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e5464a87b239f13a63a501f2701565754bae92d243d4bb7eb12f6d57d2269bf4"
Reference in New Issue Copy Permalink