jeff/dust
1
0
Fork 0
Code

Begin rewrite with register-based bytecode

Browse Source
This commit is contained in:
Jeff 2024-09-11 23:07:20 -04:00
parent 974310ffab
commit 7b055d79b5
14 changed files with 542 additions and 1289 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

211
Cargo.lock generated
View File

@ -4,9 +4,9 @@ version = 3
[[package]]
name = "aho-corasick"
version = "1.1.2"
version = "1.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b2969dcb958b36655471fc61f7e416fa76033bdd4bfed0678d8fee1e2d07a1f0"
checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
dependencies = [
"memchr",
]
@ -23,15 +23,16 @@ dependencies = [
[[package]]
name = "anstream"
version = "0.6.13"
version = "0.6.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d96bd03f33fe50a863e394ee9718a706f988b9079b20c3784fb726e7678b62fb"
checksum = "64e15c1ab1f89faffbf04a634d5e1962e9074f2741eef6d97f3c4e322426d526"
dependencies = [
"anstyle",
"anstyle-parse",
"anstyle-query",
"anstyle-wincon",
"colorchoice",
"is_terminal_polyfill",
"utf8parse",
]
@ -43,32 +44,38 @@ checksum = "1bec1de6f59aedf83baf9ff929c98f2ad654b97c9510f4e70cf6f661d49fd5b1"
[[package]]
name = "anstyle-parse"
version = "0.2.3"
version = "0.2.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c75ac65da39e5fe5ab759307499ddad880d724eed2f6ce5b5e8a26f4f387928c"
checksum = "eb47de1e80c2b463c735db5b217a0ddc39d612e7ac9e2e96a5aed1f57616c1cb"
dependencies = [
"utf8parse",
]
[[package]]
name = "anstyle-query"
version = "1.0.2"
version = "1.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e28923312444cdd728e4738b3f9c9cac739500909bb3d3c94b43551b16517648"
checksum = "6d36fc52c7f6c869915e99412912f22093507da8d9e942ceaf66fe4b7c14422a"
dependencies = [
"windows-sys 0.52.0",
]
[[package]]
name = "anstyle-wincon"
version = "3.0.2"
version = "3.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1cd54b81ec8d6180e24654d0b371ad22fc3dd083b6ff8ba325b72e00c87660a7"
checksum = "5bf74e1b6e971609db8ca7a9ce79fd5768ab6ae46441c572e46cf596f59e57f8"
dependencies = [
"anstyle",
"windows-sys 0.52.0",
]
[[package]]
name = "byteorder"
version = "1.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
[[package]]
name = "cfg-if"
version = "1.0.0"
@ -77,9 +84,9 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
[[package]]
name = "clap"
version = "4.5.14"
version = "4.5.17"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c937d4061031a6d0c8da4b9a4f98a172fc2976dfb1c19213a9cf7d0d3c837e36"
checksum = "3e5a21b8495e732f1b3c364c9949b201ca7bae518c502c80256c96ad79eaf6ac"
dependencies = [
"clap_builder",
"clap_derive",
@ -87,9 +94,9 @@ dependencies = [
[[package]]
name = "clap_builder"
version = "4.5.14"
version = "4.5.17"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "85379ba512b21a328adf887e85f7742d12e96eb31f3ef077df4ffc26b506ffed"
checksum = "8cf2dd12af7a047ad9d6da2b6b249759a22a7abc0f474c1dae1777afa4b21a73"
dependencies = [
"anstream",
"anstyle",
@ -117,9 +124,9 @@ checksum = "1462739cb27611015575c0c11df5df7601141071f07518d56fcc1be504cbec97"
[[package]]
name = "colorchoice"
version = "1.0.0"
version = "1.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "acbf1af155f9b9ef647e42cdc158db4b64a1b61f743629225fde6f3e0be2a7c7"
checksum = "d3fd119d74b830634cea2a0f58bbd0d54540518a14397557951e79340abc28c0"
[[package]]
name = "colored"
@ -152,9 +159,9 @@ dependencies = [
[[package]]
name = "crossbeam-utils"
version = "0.8.19"
version = "0.8.20"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "248e3bacc7dc6baa3b21e405ee045c3047101a49145e7e9eca583ab4c2ca5345"
checksum = "22ec99545bb0ed0ea7bb9b8e1e9122ea386ff8a48c0922e43f36d45ab09e0e80"
[[package]]
name = "dust-lang"
@ -182,15 +189,15 @@ dependencies = [
[[package]]
name = "either"
version = "1.10.0"
version = "1.13.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "11157ac094ffbdde99aa67b23417ebdd801842852b500e395a45a9c0aac03e4a"
checksum = "60b1af1c220855b6ceac025d3f6ecdd2b7c4894bfe9cd9bda4fbb4bc7c0d4cf0"
[[package]]
name = "env_filter"
version = "0.1.0"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a009aa4810eb158359dda09d0c87378e4bbb89b5a801f016885a4707ba24f7ea"
checksum = "4f2c92ceda6ceec50f43169f9ee8424fe2db276791afde7b2cd8bc084cb376ab"
dependencies = [
"log",
"regex",
@ -211,9 +218,9 @@ dependencies = [
[[package]]
name = "getrandom"
version = "0.2.12"
version = "0.2.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "190092ea657667030ac6a35e305e62fc4dd69fd98ac98631e5d3a2b1575a12b5"
checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7"
dependencies = [
"cfg-if",
"libc",
@ -233,10 +240,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
[[package]]
name = "itoa"
version = "1.0.10"
name = "is_terminal_polyfill"
version = "1.70.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b1a46d1a171d865aa5f83f92695765caa047a9b4cbae2cbf37dbd613a793fd4c"
checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf"
[[package]]
name = "itoa"
version = "1.0.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
[[package]]
name = "lazy_static"
@ -246,9 +259,9 @@ checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
[[package]]
name = "libc"
version = "0.2.153"
version = "0.2.158"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9c198f91728a82281a64e1f4f9eeb25d82cb32a5de251c6bd1b5154d63a8e7bd"
checksum = "d8adc4bb1803a324070e64a98ae98f38934d91957a99cfb3a43dcbc01bc56439"
[[package]]
name = "log"
@ -258,30 +271,33 @@ checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"
[[package]]
name = "memchr"
version = "2.7.1"
version = "2.7.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "523dc4f511e55ab87b694dc30d0f820d60906ef06413f93d4d7a1385599cc149"
checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
[[package]]
name = "ppv-lite86"
version = "0.2.17"
version = "0.2.20"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04"
dependencies = [
"zerocopy",
]
[[package]]
name = "proc-macro2"
version = "1.0.79"
version = "1.0.86"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e835ff2298f5721608eb1a980ecaee1aef2c132bf95ecc026a11b7bf3c01c02e"
checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
dependencies = [
"unicode-ident",
]
[[package]]
name = "quote"
version = "1.0.35"
version = "1.0.37"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "291ec9ab5efd934aaf503a6466c5d5251535d108ee747472c3977cc5acc868ef"
checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
dependencies = [
"proc-macro2",
]
@ -318,9 +334,9 @@ dependencies = [
[[package]]
name = "rayon"
version = "1.9.0"
version = "1.10.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e4963ed1bc86e4f3ee217022bd855b297cef07fb9eac5dfa1f788b220b49b3bd"
checksum = "b418a60154510ca1a002a752ca9714984e21e4241e804d32555251faf8b78ffa"
dependencies = [
"either",
"rayon-core",
@ -338,9 +354,9 @@ dependencies = [
[[package]]
name = "regex"
version = "1.10.3"
version = "1.10.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b62dbe01f0b06f9d8dc7d49e05a0785f153b00b2c227856282f671e0318c9b15"
checksum = "4219d74c6b67a3654a9fbebc4b419e22126d13d2f3c4a07ee0cb61ff79a79619"
dependencies = [
"aho-corasick",
"memchr",
@ -350,9 +366,9 @@ dependencies = [
[[package]]
name = "regex-automata"
version = "0.4.6"
version = "0.4.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "86b83b8b9847f9bf95ef68afb0b8e6cdb80f498442f5179a29fad448fcc1eaea"
checksum = "38caf58cc5ef2fed281f89292ef23f6365465ed9a41b7a7754eb4e26496c92df"
dependencies = [
"aho-corasick",
"memchr",
@ -361,30 +377,30 @@ dependencies = [
[[package]]
name = "regex-syntax"
version = "0.8.2"
version = "0.8.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c08c74e62047bb2de4ff487b251e4a92e24f48745648451635cec7d591162d9f"
checksum = "7a66a03ae7c801facd77a29370b4faec201768915ac14a721ba36f20bc9c209b"
[[package]]
name = "ryu"
version = "1.0.17"
version = "1.0.18"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e86697c916019a8588c99b5fac3cead74ec0b4b819707a682fd4d23fa0ce1ba1"
checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
[[package]]
name = "serde"
version = "1.0.203"
version = "1.0.210"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7253ab4de971e72fb7be983802300c30b5a7f0c2e56fab8abfc6a214307c0094"
checksum = "c8e3592472072e6e22e0a54d5904d9febf8508f65fb8552499a1abc7d1078c3a"
dependencies = [
"serde_derive",
]
[[package]]
name = "serde_derive"
version = "1.0.203"
version = "1.0.210"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "500cbc0ebeb6f46627f50f3f5811ccf6bf00643be300b4c3eabc0ef55dc5b5ba"
checksum = "243902eda00fad750862fc144cea25caca5e20d615af0a81bee94ca738f1df1f"
dependencies = [
"proc-macro2",
"quote",
@ -393,11 +409,12 @@ dependencies = [
[[package]]
name = "serde_json"
version = "1.0.117"
version = "1.0.128"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "455182ea6142b14f93f4bc5320a2b31c1f266b66a4a5c858b013302a5d8cbfc3"
checksum = "6ff5456707a1de34e7e37f2a6fd3d3f808c318259cbd01ab6377795054b483d8"
dependencies = [
"itoa",
"memchr",
"ryu",
"serde",
]
@ -410,9 +427,9 @@ checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
[[package]]
name = "syn"
version = "2.0.53"
version = "2.0.77"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7383cd0e49fff4b6b90ca5670bfd3e9d6a733b3f90c686605aa7eec8c4996032"
checksum = "9f35bcdf61fd8e7be6caf75f429fdca8beb3ed76584befb503b1569faee373ed"
dependencies = [
"proc-macro2",
"quote",
@ -421,9 +438,9 @@ dependencies = [
[[package]]
name = "unicode-ident"
version = "1.0.12"
version = "1.0.13"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
checksum = "e91b56cd4cadaeb79bbf1a5645f6b4f8dc5bde8834ad5894a8db35fda9efa1fe"
[[package]]
name = "unicode-width"
@ -433,9 +450,9 @@ checksum = "0336d538f7abc86d282a4189614dfaa90810dfc2c6f6427eaf88e16311dd225d"
[[package]]
name = "utf8parse"
version = "0.2.1"
version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "711b9620af191e0cdc7468a8d14e709c3dcdb115b36f838e601583af800a370a"
checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
[[package]]
name = "wasi"
@ -458,7 +475,7 @@ version = "0.52.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
dependencies = [
"windows-targets 0.52.4",
"windows-targets 0.52.6",
]
[[package]]
@ -478,17 +495,18 @@ dependencies = [
[[package]]
name = "windows-targets"
version = "0.52.4"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7dd37b7e5ab9018759f893a1952c9420d060016fc19a472b4bb20d1bdd694d1b"
checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
dependencies = [
"windows_aarch64_gnullvm 0.52.4",
"windows_aarch64_msvc 0.52.4",
"windows_i686_gnu 0.52.4",
"windows_i686_msvc 0.52.4",
"windows_x86_64_gnu 0.52.4",
"windows_x86_64_gnullvm 0.52.4",
"windows_x86_64_msvc 0.52.4",
"windows_aarch64_gnullvm 0.52.6",
"windows_aarch64_msvc 0.52.6",
"windows_i686_gnu 0.52.6",
"windows_i686_gnullvm",
"windows_i686_msvc 0.52.6",
"windows_x86_64_gnu 0.52.6",
"windows_x86_64_gnullvm 0.52.6",
"windows_x86_64_msvc 0.52.6",
]
[[package]]
@ -499,9 +517,9 @@ checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
[[package]]
name = "windows_aarch64_gnullvm"
version = "0.52.4"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bcf46cf4c365c6f2d1cc93ce535f2c8b244591df96ceee75d8e83deb70a9cac9"
checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
[[package]]
name = "windows_aarch64_msvc"
@ -511,9 +529,9 @@ checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
[[package]]
name = "windows_aarch64_msvc"
version = "0.52.4"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "da9f259dd3bcf6990b55bffd094c4f7235817ba4ceebde8e6d11cd0c5633b675"
checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
[[package]]
name = "windows_i686_gnu"
@ -523,9 +541,15 @@ checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
[[package]]
name = "windows_i686_gnu"
version = "0.52.4"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b474d8268f99e0995f25b9f095bc7434632601028cf86590aea5c8a5cb7801d3"
checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
[[package]]
name = "windows_i686_gnullvm"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
[[package]]
name = "windows_i686_msvc"
@ -535,9 +559,9 @@ checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
[[package]]
name = "windows_i686_msvc"
version = "0.52.4"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1515e9a29e5bed743cb4415a9ecf5dfca648ce85ee42e15873c3cd8610ff8e02"
checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
[[package]]
name = "windows_x86_64_gnu"
@ -547,9 +571,9 @@ checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
[[package]]
name = "windows_x86_64_gnu"
version = "0.52.4"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5eee091590e89cc02ad514ffe3ead9eb6b660aedca2183455434b93546371a03"
checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
[[package]]
name = "windows_x86_64_gnullvm"
@ -559,9 +583,9 @@ checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
[[package]]
name = "windows_x86_64_gnullvm"
version = "0.52.4"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "77ca79f2451b49fa9e2af39f0747fe999fcda4f5e241b2898624dca97a1f2177"
checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
[[package]]
name = "windows_x86_64_msvc"
@ -571,6 +595,27 @@ checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
[[package]]
name = "windows_x86_64_msvc"
version = "0.52.4"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "32b752e52a2da0ddfbdbcc6fceadfeede4c939ed16d13e648833a61dfb611ed8"
checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
[[package]]
name = "zerocopy"
version = "0.7.35"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
dependencies = [
"byteorder",
"zerocopy-derive",
]
[[package]]
name = "zerocopy-derive"
version = "0.7.35"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
dependencies = [
"proc-macro2",
"quote",
"syn",
]

79
dust-lang/src/chunk.rs
View File

@ -4,9 +4,9 @@ use serde::{Deserialize, Serialize};
use crate::{AnnotatedError, Identifier, Instruction, Span, Value};
#[derive(Clone, Serialize, Deserialize)]
#[derive(Clone)]
pub struct Chunk {
code: Vec<(u8, Span)>,
code: Vec<(Instruction, Span)>,
constants: Vec<Option<Value>>,
identifiers: Vec<Local>,
scope_depth: usize,
@ -23,7 +23,7 @@ impl Chunk {
}
pub fn with_data(
code: Vec<(u8, Span)>,
code: Vec<(Instruction, Span)>,
constants: Vec<Value>,
identifiers: Vec<Local>,
) -> Self {
@ -47,17 +47,21 @@ impl Chunk {
self.scope_depth
}
pub fn get_code(&self, offset: usize, position: Span) -> Result<&(u8, Span), ChunkError> {
pub fn get_code(
&self,
offset: usize,
position: Span,
) -> Result<&(Instruction, Span), ChunkError> {
self.code
.get(offset)
.ok_or(ChunkError::CodeIndexOfBounds { offset, position })
}
pub fn push_code<T: Into<u8>>(&mut self, into_byte: T, position: Span) {
self.code.push((into_byte.into(), position));
pub fn push_code(&mut self, instruction: Instruction, position: Span) {
self.code.push((instruction, position));
}
pub fn get_constant(&self, index: u8, position: Span) -> Result<&Value, ChunkError> {
pub fn get_constant(&self, index: u16, position: Span) -> Result<&Value, ChunkError> {
self.constants
.get(index as usize)
.ok_or(ChunkError::ConstantIndexOutOfBounds { index, position })
@ -68,23 +72,15 @@ impl Chunk {
})
}
pub fn use_constant(&mut self, index: u8, position: Span) -> Result<Value, ChunkError> {
let index = index as usize;
pub fn use_constant(&mut self, index: u16, position: Span) -> Result<Value, ChunkError> {
self.constants
.get_mut(index)
.ok_or_else(|| ChunkError::ConstantIndexOutOfBounds {
index: index as u8,
position,
})?
.get_mut(index as usize)
.ok_or_else(|| ChunkError::ConstantIndexOutOfBounds { index, position })?
.take()
.ok_or(ChunkError::ConstantAlreadyUsed {
index: index as u8,
position,
})
.ok_or(ChunkError::ConstantAlreadyUsed { index, position })
}
pub fn push_constant(&mut self, value: Value, position: Span) -> Result<u8, ChunkError> {
pub fn push_constant(&mut self, value: Value, position: Span) -> Result<u16, ChunkError> {
let starting_length = self.constants.len();
if starting_length + 1 > (u8::MAX as usize) {
@ -92,7 +88,7 @@ impl Chunk {
} else {
self.constants.push(Some(value));
Ok(starting_length as u8)
Ok(starting_length as u16)
}
}
@ -102,7 +98,7 @@ impl Chunk {
.any(|local| &local.identifier == identifier)
}
pub fn get_local(&self, index: u8, position: Span) -> Result<&Local, ChunkError> {
pub fn get_local(&self, index: u16, position: Span) -> Result<&Local, ChunkError> {
self.identifiers
.get(index as usize)
.ok_or(ChunkError::IdentifierIndexOutOfBounds { index, position })
@ -120,14 +116,14 @@ impl Chunk {
&self,
identifier: &Identifier,
position: Span,
) -> Result<u8, ChunkError> {
) -> Result<u16, ChunkError> {
self.identifiers
.iter()
.rev()
.enumerate()
.find_map(|(index, local)| {
if &local.identifier == identifier {
Some(index as u8)
Some(index as u16)
} else {
None
}
@ -142,7 +138,7 @@ impl Chunk {
&mut self,
identifier: Identifier,
position: Span,
) -> Result<u8, ChunkError> {
) -> Result<u16, ChunkError> {
let starting_length = self.identifiers.len();
if starting_length + 1 > (u8::MAX as usize) {
@ -153,7 +149,7 @@ impl Chunk {
depth: self.scope_depth,
});
Ok(starting_length as u8)
Ok(starting_length as u16)
}
}
@ -183,32 +179,19 @@ impl Chunk {
let mut output = String::new();
let name_length = name.len();
let buffer_length = 32_usize.saturating_sub(name_length + 2);
let buffer_length = 34_usize.saturating_sub(name_length + 2);
let name_buffer = " ".repeat(buffer_length / 2);
let name_line = format!("{name_buffer} {name} {name_buffer}\n");
let name_line = format!("\n{name_buffer}{name}{name_buffer}\n");
let name_underline = format!("{name_buffer}{}{name_buffer}\n", "-".repeat(name_length));
output.push_str(&name_line);
output.push_str(&name_underline);
output.push_str("\n Code \n");
output.push_str("------ ------------ ------------\n");
output.push_str("OFFSET POSITION INSTRUCTION\n");
output.push_str("------ ------------ ------------\n");
let mut previous = None;
for (offset, (byte, position)) in self.code.iter().enumerate() {
if let Some(
Instruction::Constant
| Instruction::DeclareVariable
| Instruction::GetVariable
| Instruction::SetVariable,
) = previous
{
previous = None;
continue;
}
let instruction = Instruction::from_byte(*byte).unwrap();
for (offset, (instruction, position)) in self.code.iter().enumerate() {
let display = format!(
"{offset:4} {:12} {}\n",
position.to_string(),
@ -216,8 +199,6 @@ impl Chunk {
);
output.push_str(&display);
previous = Some(instruction);
}
output.push_str("\n Constants\n");
@ -296,18 +277,18 @@ pub enum ChunkError {
position: Span,
},
ConstantAlreadyUsed {
index: u8,
index: u16,
position: Span,
},
ConstantOverflow {
position: Span,
},
ConstantIndexOutOfBounds {
index: u8,
index: u16,
position: Span,
},
IdentifierIndexOutOfBounds {
index: u8,
index: u16,
position: Span,
},
IdentifierOverflow {

20
dust-lang/src/dust_error.rs
View File

@ -1,6 +1,6 @@
use annotate_snippets::{Level, Renderer, Snippet};
use crate::{vm::VmError, LexError, ParseError, Span};
use crate::{LexError, ParseError, Span};
#[derive(Debug, PartialEq)]
pub enum DustError<'src> {
@ -12,10 +12,6 @@ pub enum DustError<'src> {
error: ParseError,
source: &'src str,
},
Runtime {
error: VmError,
source: &'src str,
},
}
impl<'src> DustError<'src> {
@ -24,20 +20,6 @@ impl<'src> DustError<'src> {
let renderer = Renderer::styled();
match self {
DustError::Runtime { error, source } => {
let position = error.position();
let label = format!("Runtime error: {}", error.description());
let details = error
.details()
.unwrap_or_else(|| "While running this code".to_string());
let message = Level::Error.title(&label).snippet(
Snippet::source(source)
.fold(true)
.annotation(Level::Error.span(position.0..position.1).label(&details)),
);
report.push_str(&renderer.render(message).to_string());
}
DustError::Parse { error, source } => {
let position = error.position();
let label = format!("Parse error: {}", error.description());

305
dust-lang/src/instruction.rs
View File

@ -1,141 +1,214 @@
use std::fmt::{self, Display, Formatter};
use serde::{Deserialize, Serialize};
use crate::{Chunk, Span};
#[derive(Debug, Clone, Copy, Eq, PartialEq, Serialize, Deserialize)]
pub enum Instruction {
Constant = 0,
Return = 1,
Pop = 2,
// Variables
DeclareVariable = 3,
GetVariable = 4,
SetVariable = 5,
// Unary
Negate = 6,
Not = 7,
// Binary
Add = 8,
Subtract = 9,
Multiply = 10,
Divide = 11,
Greater = 12,
Less = 13,
GreaterEqual = 14,
LessEqual = 15,
Equal = 16,
NotEqual = 17,
And = 18,
Or = 19,
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Instruction {
opcode: OpCode,
to_register: u8,
arguments: [u8; 2],
}
impl Instruction {
pub fn from_byte(byte: u8) -> Option<Self> {
match byte {
0 => Some(Instruction::Constant),
1 => Some(Instruction::Return),
2 => Some(Instruction::Pop),
3 => Some(Instruction::DeclareVariable),
4 => Some(Instruction::GetVariable),
5 => Some(Instruction::SetVariable),
6 => Some(Instruction::Negate),
7 => Some(Instruction::Not),
8 => Some(Instruction::Add),
9 => Some(Instruction::Subtract),
10 => Some(Instruction::Multiply),
11 => Some(Instruction::Divide),
12 => Some(Instruction::Greater),
13 => Some(Instruction::Less),
14 => Some(Instruction::GreaterEqual),
15 => Some(Instruction::LessEqual),
16 => Some(Instruction::Equal),
17 => Some(Instruction::NotEqual),
18 => Some(Instruction::And),
19 => Some(Instruction::Or),
_ => None,
pub fn r#move(to_register: u8, from_register: u8) -> Instruction {
Instruction {
opcode: OpCode::Move,
to_register,
arguments: [from_register, 0],
}
}
pub fn close(to_register: u8) -> Instruction {
Instruction {
opcode: OpCode::Close,
to_register,
arguments: [0, 0],
}
}
pub fn load_constant(to_register: u8, constant_index: u16) -> Instruction {
Instruction {
opcode: OpCode::LoadConstant,
to_register,
arguments: constant_index.to_le_bytes(),
}
}
pub fn declare_variable(to_register: u8, variable_index: u16) -> Instruction {
Instruction {
opcode: OpCode::DeclareVariable,
to_register,
arguments: variable_index.to_le_bytes(),
}
}
pub fn get_variable(to_register: u8, variable_index: u16) -> Instruction {
Instruction {
opcode: OpCode::GetVariable,
to_register,
arguments: variable_index.to_le_bytes(),
}
}
pub fn set_variable(from_register: u8, variable_index: u16) -> Instruction {
Instruction {
opcode: OpCode::SetVariable,
to_register: from_register,
arguments: variable_index.to_le_bytes(),
}
}
pub fn add(to_register: u8, left_register: u8, right_register: u8) -> Instruction {
Instruction {
opcode: OpCode::Add,
to_register,
arguments: [left_register, right_register],
}
}
pub fn subtract(to_register: u8, left_register: u8, right_register: u8) -> Instruction {
Instruction {
opcode: OpCode::Subtract,
to_register,
arguments: [left_register, right_register],
}
}
pub fn multiply(to_register: u8, left_register: u8, right_register: u8) -> Instruction {
Instruction {
opcode: OpCode::Multiply,
to_register,
arguments: [left_register, right_register],
}
}
pub fn divide(to_register: u8, left_register: u8, right_register: u8) -> Instruction {
Instruction {
opcode: OpCode::Divide,
to_register,
arguments: [left_register, right_register],
}
}
pub fn negate(to_register: u8, from_register: u8) -> Instruction {
Instruction {
opcode: OpCode::Negate,
to_register,
arguments: [from_register, 0],
}
}
pub fn r#return() -> Instruction {
Instruction {
opcode: OpCode::Return,
to_register: 0,
arguments: [0, 0],
}
}
pub fn disassemble(&self, chunk: &Chunk, offset: usize) -> String {
let dummy_position = Span(0, 0);
match self {
Instruction::Constant => {
let (argument, position) = *chunk.get_code(offset + 1, dummy_position).unwrap();
let value_display = chunk
.get_constant(argument, position)
.map(|value| value.to_string())
.unwrap_or_else(|error| format!("{error:?}"));
format!("CONSTANT {value_display}")
match self.opcode {
OpCode::Move => format!(
"{:04} MOVE R{} R{}",
offset, self.to_register, self.arguments[0]
),
OpCode::Close => {
format!("{:04} CLOSE R{}", offset, self.to_register)
}
Instruction::Return => "RETURN".to_string(),
Instruction::Pop => "POP".to_string(),
OpCode::LoadConstant => {
let constant_index = u16::from_le_bytes(self.arguments);
let constant_display = match chunk.get_constant(constant_index, Span(0, 0)) {
Ok(value) => value.to_string(),
Err(error) => format!("{:?}", error),
};
// Variables
Instruction::DeclareVariable => {
let (argument, _) = chunk.get_code(offset + 1, dummy_position).unwrap();
let identifier_display = chunk
.get_identifier(*argument)
.map(|identifier| identifier.to_string())
.unwrap_or_else(|| "ERROR".to_string());
format!("DECLARE_VARIABLE {identifier_display}")
format!(
"{:04} LOAD_CONSTANT R{} C{} {}",
offset, self.to_register, constant_index, constant_display
)
}
Instruction::GetVariable => {
let (argument, _) = chunk.get_code(offset + 1, dummy_position).unwrap();
let identifier_display = chunk
.get_identifier(*argument)
.map(|identifier| identifier.to_string())
.unwrap_or_else(|| "ERROR".to_string());
OpCode::DeclareVariable => {
let variable_index = u16::from_le_bytes([self.arguments[0], self.arguments[1]]);
format!("GET_VARIABLE {identifier_display}")
format!(
"{:04} DECLARE_VARIABLE V{} R{}",
offset, variable_index, self.to_register
)
}
OpCode::GetVariable => {
let variable_index = u16::from_le_bytes([self.arguments[0], self.arguments[1]]);
Instruction::SetVariable => {
let (argument, _) = chunk.get_code(offset + 1, dummy_position).unwrap();
let identifier_display = chunk
.get_identifier(*argument)
.map(|identifier| identifier.to_string())
.unwrap_or_else(|| "ERROR".to_string());
format!("SET_VARIABLE {identifier_display}")
format!(
"{:04} GET_VARIABLE R{} V{}",
offset, self.to_register, variable_index
)
}
OpCode::SetVariable => {
let variable_index = u16::from_le_bytes([self.arguments[0], self.arguments[1]]);
// Unary
Instruction::Negate => "NEGATE".to_string(),
Instruction::Not => "NOT".to_string(),
// Binary
Instruction::Add => "ADD".to_string(),
Instruction::Subtract => "SUBTRACT".to_string(),
Instruction::Multiply => "MULTIPLY".to_string(),
Instruction::Divide => "DIVIDE".to_string(),
Instruction::Greater => "GREATER".to_string(),
Instruction::Less => "LESS".to_string(),
Instruction::GreaterEqual => "GREATER_EQUAL".to_string(),
Instruction::LessEqual => "LESS_EQUAL".to_string(),
Instruction::Equal => "EQUAL".to_string(),
Instruction::NotEqual => "NOT_EQUAL".to_string(),
Instruction::And => "AND".to_string(),
Instruction::Or => "OR".to_string(),
format!(
"{:04} SET_VARIABLE V{} R{}",
offset, variable_index, self.to_register
)
}
OpCode::Add => format!(
"{:04} ADD R{} = R{} + R{}",
offset, self.to_register, self.arguments[0], self.arguments[1]
),
OpCode::Subtract => format!(
"{:04} SUBTRACT R{} = R{} - R{}",
offset, self.to_register, self.arguments[0], self.arguments[1]
),
OpCode::Multiply => format!(
"{:04} MULTIPLY R{} = R{} * R{}",
offset, self.to_register, self.arguments[0], self.arguments[1]
),
OpCode::Divide => format!(
"{:04} DIVIDE R{} = R{} / R{}",
offset, self.to_register, self.arguments[0], self.arguments[1]
),
OpCode::Negate => format!(
"{:04} NEGATE R{} = !R{}",
offset, self.to_register, self.arguments[0]
),
OpCode::Return => format!("{:04} RETURN", offset),
}
}
}
impl Display for Instruction {
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
write!(f, "{self:?}")
}
#[derive(Clone, Copy, Debug, PartialEq)]
enum OpCode {
// Stack manipulation
Move,
Close,
// Constants
LoadConstant,
// Variables
DeclareVariable,
GetVariable,
SetVariable,
// Binary operations
Add,
Subtract,
Multiply,
Divide,
// Unary operations
Negate,
// Control flow
Return,
}
impl From<Instruction> for u8 {
fn from(instruction: Instruction) -> Self {
instruction as u8
#[cfg(test)]
mod tests {
use std::mem::size_of;
use super::*;
#[test]
fn instruction_is_32_bits() {
assert_eq!(size_of::<Instruction>(), 4);
}
}

55
dust-lang/src/lib.rs
View File

@ -1,34 +1,18 @@
//! The Dust programming language.
//!
//! To get started, you can use the `run` function to run a Dust program.
//!
//! ```rust
//! use dust_lang::{run, Value};
//!
//! let program = "
//! let foo = 21
//! let bar = 2
//! foo * bar
//! ";
//!
//! let the_answer = run(program).unwrap();
//!
//! assert_eq!(the_answer, Some(Value::integer(42)));
//! ```
pub mod chunk;
pub mod constructor;
pub mod dust_error;
pub mod identifier;
pub mod instruction;
pub mod lexer;
pub mod parser;
pub mod token;
pub mod r#type;
pub mod value;
pub mod vm;
mod chunk;
mod constructor;
mod dust_error;
mod identifier;
mod instruction;
mod lexer;
mod parser;
mod token;
mod r#type;
mod value;
pub use chunk::{Chunk, ChunkError, Local};
pub use constructor::{ConstructError, Constructor};
use std::fmt::Display;
pub use chunk::{Chunk, ChunkError};
pub use constructor::Constructor;
pub use dust_error::{AnnotatedError, DustError};
pub use identifier::Identifier;
pub use instruction::Instruction;
@ -36,18 +20,13 @@ pub use lexer::{lex, LexError, Lexer};
pub use parser::{parse, ParseError, Parser};
pub use r#type::{EnumType, FunctionType, RangeableType, StructType, Type, TypeConflict};
pub use token::{Token, TokenKind, TokenOwned};
pub use value::{Struct, Value, ValueError};
pub use vm::{run, Vm};
pub use value::{Enum, Function, Struct, Value};
use std::fmt::{self, Display, Formatter};
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Copy, Eq, PartialEq, PartialOrd, Ord, Serialize, Deserialize)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Span(pub usize, pub usize);
impl Display for Span {
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "({}, {})", self.0, self.1)
}
}

387
dust-lang/src/parser.rs → dust-lang/src/parser/mod.rs
View File

@ -1,3 +1,6 @@
#[cfg(test)]
mod tests;
use std::{
fmt::{self, Display, Formatter},
mem,
@ -24,12 +27,13 @@ pub fn parse(source: &str) -> Result<Chunk, DustError> {
#[derive(Debug)]
pub struct Parser<'src> {
lexer: Lexer<'src>,
chunk: Chunk,
previous_token: Token<'src>,
previous_position: Span,
lexer: Lexer<'src>,
current_register: u8,
current_token: Token<'src>,
current_position: Span,
previous_token: Token<'src>,
previous_position: Span,
}
impl<'src> Parser<'src> {
@ -42,10 +46,11 @@ impl<'src> Parser<'src> {
Parser {
lexer,
chunk: Chunk::new(),
previous_token: Token::Eof,
previous_position: Span(0, 0),
current_register: 0,
current_token,
current_position,
previous_token: Token::Eof,
previous_position: Span(0, 0),
}
}
@ -53,6 +58,20 @@ impl<'src> Parser<'src> {
matches!(self.current_token, Token::Eof)
}
fn increment_register(&mut self) -> Result<(), ParseError> {
let current = self.current_register;
if current == u8::MAX {
Err(ParseError::RegisterOverflow {
position: self.current_position,
})
} else {
self.current_register += 1;
Ok(())
}
}
fn advance(&mut self) -> Result<(), ParseError> {
if self.is_eof() {
return Ok(());
@ -90,16 +109,19 @@ impl<'src> Parser<'src> {
}
}
fn emit_byte<T: Into<u8>>(&mut self, into_byte: T, position: Span) {
self.chunk.push_code(into_byte.into(), position);
fn emit_instruction(&mut self, instruction: Instruction, position: Span) {
self.chunk.push_code(instruction, position);
}
fn emit_constant(&mut self, value: Value) -> Result<(), ParseError> {
let position = self.previous_position;
let constant_index = self.chunk.push_constant(value, position)?;
self.emit_byte(Instruction::Constant, position);
self.emit_byte(constant_index, position);
self.emit_instruction(
Instruction::load_constant(self.current_register, constant_index),
position,
);
self.increment_register()?;
Ok(())
}
@ -180,7 +202,9 @@ impl<'src> Parser<'src> {
fn parse_unary(&mut self, _allow_assignment: bool) -> Result<(), ParseError> {
let operator_position = self.previous_position;
let byte = match self.previous_token.kind() {
TokenKind::Minus => Instruction::Negate,
TokenKind::Minus => {
Instruction::negate(self.current_register, self.current_register - 1)
}
_ => {
return Err(ParseError::ExpectedTokenMultiple {
expected: vec![TokenKind::Minus],
@ -191,7 +215,7 @@ impl<'src> Parser<'src> {
};
self.parse_expression()?;
self.emit_byte(byte, operator_position);
self.emit_instruction(byte, operator_position);
Ok(())
}
@ -205,12 +229,18 @@ impl<'src> Parser<'src> {
self.parse(rule.precedence.increment())?;
let to_register = if self.current_register < 2 {
self.current_register + 2
} else {
self.current_register
};
let left_register = to_register - 1;
let right_register = to_register - 2;
let byte = match operator {
TokenKind::Plus => Instruction::Add,
TokenKind::Minus => Instruction::Subtract,
TokenKind::Star => Instruction::Multiply,
TokenKind::Slash => Instruction::Divide,
TokenKind::DoubleAmpersand => Instruction::And,
TokenKind::Plus => Instruction::add(to_register, left_register, right_register),
TokenKind::Minus => Instruction::subtract(to_register, left_register, right_register),
TokenKind::Star => Instruction::multiply(to_register, left_register, right_register),
TokenKind::Slash => Instruction::divide(to_register, left_register, right_register),
_ => {
return Err(ParseError::ExpectedTokenMultiple {
expected: vec![
@ -225,7 +255,7 @@ impl<'src> Parser<'src> {
}
};
self.emit_byte(byte, operator_position);
self.emit_instruction(byte, operator_position);
Ok(())
}
@ -240,11 +270,17 @@ impl<'src> Parser<'src> {
if allow_assignment && self.allow(TokenKind::Equal)? {
self.parse_expression()?;
self.emit_byte(Instruction::SetVariable, self.previous_position);
self.emit_byte(identifier_index, self.previous_position);
self.emit_instruction(
Instruction::set_variable(self.current_register, identifier_index),
self.previous_position,
);
self.increment_register()?;
} else {
self.emit_byte(Instruction::GetVariable, self.previous_position);
self.emit_byte(identifier_index, self.previous_position);
self.emit_instruction(
Instruction::get_variable(self.current_register - 1, identifier_index),
self.previous_position,
);
}
Ok(())
@ -254,7 +290,7 @@ impl<'src> Parser<'src> {
&mut self,
token: TokenOwned,
position: Span,
) -> Result<u8, ParseError> {
) -> Result<u16, ParseError> {
if let TokenOwned::Identifier(text) = token {
let identifier = Identifier::new(text);
@ -291,8 +327,10 @@ impl<'src> Parser<'src> {
.next_back()
.map_or(false, |local| local.depth > self.chunk.scope_depth())
{
self.emit_byte(Instruction::Pop, self.current_position);
self.chunk.pop_identifier();
self.emit_instruction(
Instruction::close(self.current_register),
self.current_position,
);
}
Ok(())
@ -326,7 +364,7 @@ impl<'src> Parser<'src> {
if is_expression_statement && !contains_block && !has_semicolon {
let end = self.previous_position.1;
self.emit_byte(Instruction::Return, Span(start, end))
self.emit_instruction(Instruction::r#return(), Span(start, end))
}
Ok(())
@ -353,8 +391,11 @@ impl<'src> Parser<'src> {
let identifier_index = self.chunk.declare_variable(identifier, position)?;
self.emit_byte(Instruction::DeclareVariable, position);
self.emit_byte(identifier_index, position);
self.emit_instruction(
Instruction::set_variable(self.current_register, identifier_index),
position,
);
self.increment_register()?;
Ok(())
}
@ -618,6 +659,9 @@ pub enum ParseError {
identifier: Identifier,
position: Span,
},
RegisterOverflow {
position: Span,
},
// Wrappers around foreign errors
Chunk(ChunkError),
@ -646,6 +690,7 @@ impl AnnotatedError for ParseError {
Self::ExpectedTokenMultiple { .. } => "Expected one of multiple tokens",
Self::InvalidAssignmentTarget { .. } => "Invalid assignment target",
Self::UndefinedVariable { .. } => "Undefined variable",
Self::RegisterOverflow { .. } => "Register overflow",
Self::Chunk { .. } => "Chunk error",
Self::Lex(_) => "Lex error",
Self::ParseIntError { .. } => "Failed to parse integer",
@ -654,9 +699,7 @@ impl AnnotatedError for ParseError {
fn details(&self) -> Option<String> {
match self {
Self::ExpectedExpression { found, .. } => {
Some(format!("Expected an expression, found \"{found}\""))
}
Self::ExpectedExpression { found, .. } => Some(format!("Found \"{found}\"")),
Self::ExpectedToken {
expected, found, ..
} => Some(format!("Expected \"{expected}\", found \"{found}\"")),
@ -664,11 +707,12 @@ impl AnnotatedError for ParseError {
expected, found, ..
} => Some(format!("Expected one of {expected:?}, found \"{found}\"")),
Self::InvalidAssignmentTarget { found, .. } => {
Some(format!("Invalid assignment target \"{found}\""))
Some(format!("Invalid assignment target, found \"{found}\""))
}
Self::UndefinedVariable { identifier, .. } => {
Some(format!("Undefined variable \"{identifier}\""))
}
Self::RegisterOverflow { .. } => None,
Self::Chunk(error) => error.details(),
Self::Lex(error) => Some(error.to_string()),
Self::ParseIntError { error, .. } => Some(error.to_string()),
@ -682,6 +726,7 @@ impl AnnotatedError for ParseError {
Self::ExpectedTokenMultiple { position, .. } => *position,
Self::InvalidAssignmentTarget { position, .. } => *position,
Self::UndefinedVariable { position, .. } => *position,
Self::RegisterOverflow { position } => *position,
Self::Chunk(error) => error.position(),
Self::Lex(error) => error.position(),
Self::ParseIntError { position, .. } => *position,
@ -694,283 +739,3 @@ impl From<LexError> for ParseError {
Self::Lex(error)
}
}
#[cfg(test)]
mod tests {
use crate::Local;
use super::*;
#[test]
fn block() {
let source = "{ 42; 42 }";
let test_chunk = parse(source);
assert_eq!(
test_chunk,
Ok(Chunk::with_data(
vec![
(Instruction::Constant as u8, Span(2, 4)),
(0, Span(2, 4)),
(Instruction::Constant as u8, Span(6, 8)),
(1, Span(6, 8)),
(Instruction::Return as u8, Span(6, 8)),
],
vec![Value::integer(42), Value::integer(42)],
vec![]
))
);
}
#[test]
fn add_variables() {
let source = "let x = 42; let y = 42; x + y";
let test_chunk = parse(source);
assert_eq!(
test_chunk,
Ok(Chunk::with_data(
vec![
(Instruction::Constant as u8, Span(8, 10)),
(0, Span(8, 10)),
(Instruction::DeclareVariable as u8, Span(4, 5)),
(0, Span(4, 5)),
(Instruction::Constant as u8, Span(20, 22)),
(1, Span(20, 22)),
(Instruction::DeclareVariable as u8, Span(16, 17)),
(1, Span(16, 17)),
(Instruction::GetVariable as u8, Span(24, 25)),
(0, Span(24, 25)),
(Instruction::GetVariable as u8, Span(28, 29)),
(1, Span(28, 29)),
(Instruction::Add as u8, Span(26, 27)),
(Instruction::Return as u8, Span(24, 29)),
],
vec![Value::integer(42), Value::integer(42)],
vec![
Local {
identifier: Identifier::new("x"),
depth: 0,
},
Local {
identifier: Identifier::new("y"),
depth: 0,
},
],
))
);
}
#[test]
fn let_statement() {
let source = "let x = 42;";
let test_chunk = parse(source);
assert_eq!(
test_chunk,
Ok(Chunk::with_data(
vec![
(Instruction::Constant as u8, Span(8, 10)),
(0, Span(8, 10)),
(Instruction::DeclareVariable as u8, Span(4, 5)),
(0, Span(4, 5)),
],
vec![Value::integer(42)],
vec![Local {
identifier: Identifier::new("x"),
depth: 0,
}],
))
);
}
#[test]
fn string() {
let source = "\"Hello, World!\"";
let test_chunk = parse(source);
assert_eq!(
test_chunk,
Ok(Chunk::with_data(
vec![
(Instruction::Constant as u8, Span(0, 15)),
(0, Span(0, 15)),
(Instruction::Return as u8, Span(0, 15)),
],
vec![Value::string("Hello, World!")],
vec![],
))
);
}
#[test]
fn integer() {
let source = "42";
let test_chunk = parse(source);
assert_eq!(
test_chunk,
Ok(Chunk::with_data(
vec![
(Instruction::Constant as u8, Span(0, 2)),
(0, Span(0, 2)),
(Instruction::Return as u8, Span(0, 2)),
],
vec![Value::integer(42)],
vec![],
))
);
}
#[test]
fn boolean() {
let source = "true";
let test_chunk = parse(source);
assert_eq!(
test_chunk,
Ok(Chunk::with_data(
vec![
(Instruction::Constant as u8, Span(0, 4)),
(0, Span(0, 4)),
(Instruction::Return as u8, Span(0, 4)),
],
vec![Value::boolean(true)],
vec![],
))
);
}
#[test]
fn grouping() {
let source = "(42 + 42) * 2";
let test_chunk = parse(source);
assert_eq!(
test_chunk,
Ok(Chunk::with_data(
vec![
(Instruction::Constant as u8, Span(1, 3)),
(0, Span(1, 3)),
(Instruction::Constant as u8, Span(6, 8)),
(1, Span(6, 8)),
(Instruction::Add as u8, Span(4, 5)),
(Instruction::Constant as u8, Span(12, 13)),
(2, Span(12, 13)),
(Instruction::Multiply as u8, Span(10, 11)),
(Instruction::Return as u8, Span(0, 13)),
],
vec![Value::integer(42), Value::integer(42), Value::integer(2)],
vec![],
))
);
}
#[test]
fn negation() {
let source = "-(42)";
let test_chunk = parse(source);
assert_eq!(
test_chunk,
Ok(Chunk::with_data(
vec![
(Instruction::Constant as u8, Span(2, 4)),
(0, Span(2, 4)),
(Instruction::Negate as u8, Span(0, 1)),
(Instruction::Return as u8, Span(0, 5)),
],
vec![Value::integer(42)],
vec![],
))
);
}
#[test]
fn addition() {
let source = "42 + 42";
let test_chunk = parse(source);
assert_eq!(
test_chunk,
Ok(Chunk::with_data(
vec![
(Instruction::Constant as u8, Span(0, 2)),
(0, Span(0, 2)),
(Instruction::Constant as u8, Span(5, 7)),
(1, Span(5, 7)),
(Instruction::Add as u8, Span(3, 4)),
(Instruction::Return as u8, Span(0, 7)),
],
vec![Value::integer(42), Value::integer(42)],
vec![],
))
);
}
#[test]
fn subtraction() {
let source = "42 - 42";
let test_chunk = parse(source);
assert_eq!(
test_chunk,
Ok(Chunk::with_data(
vec![
(Instruction::Constant as u8, Span(0, 2)),
(0, Span(0, 2)),
(Instruction::Constant as u8, Span(5, 7)),
(1, Span(5, 7)),
(Instruction::Subtract as u8, Span(3, 4)),
(Instruction::Return as u8, Span(0, 7)),
],
vec![Value::integer(42), Value::integer(42)],
vec![],
))
);
}
#[test]
fn multiplication() {
let source = "42 * 42";
let test_chunk = parse(source);
assert_eq!(
test_chunk,
Ok(Chunk::with_data(
vec![
(Instruction::Constant as u8, Span(0, 2)),
(0, Span(0, 2)),
(Instruction::Constant as u8, Span(5, 7)),
(1, Span(5, 7)),
(Instruction::Multiply as u8, Span(3, 4)),
(Instruction::Return as u8, Span(0, 7)),
],
vec![Value::integer(42), Value::integer(42)],
vec![],
))
);
}
#[test]
fn division() {
let source = "42 / 42";
let test_chunk = parse(source);
assert_eq!(
test_chunk,
Ok(Chunk::with_data(
vec![
(Instruction::Constant as u8, Span(0, 2)),
(0, Span(0, 2)),
(Instruction::Constant as u8, Span(5, 7)),
(1, Span(5, 7)),
(Instruction::Divide as u8, Span(3, 4)),
(Instruction::Return as u8, Span(0, 7)),
],
vec![Value::integer(42), Value::integer(42)],
vec![],
))
);
}
}

33
dust-lang/src/parser/tests.rs Normal file
View File

@ -0,0 +1,33 @@
use super::*;
#[test]
fn integer() {
assert_eq!(
parse("42"),
Ok(Chunk::with_data(
vec![
(Instruction::load_constant(0, 0), Span(0, 2)),
(Instruction::r#return(), Span(0, 2)),
],
vec![Value::integer(42),],
vec![]
))
);
}
#[test]
fn add() {
assert_eq!(
parse("1 + 2"),
Ok(Chunk::with_data(
vec![
(Instruction::load_constant(0, 0), Span(0, 1)),
(Instruction::load_constant(1, 1), Span(4, 5)),
(Instruction::add(2, 1, 0), Span(2, 3)),
(Instruction::r#return(), Span(0, 5)),
],
vec![Value::integer(1), Value::integer(2),],
vec![]
))
);
}

47
dust-lang/src/run.rs
View File

@ -1,47 +0,0 @@
use crate::{parse, DustError, Value, Vm};
pub fn run(source: &str) -> Result<Option<Value>, DustError> {
let chunk = parse(source)?;
let mut vm = Vm::new(chunk);
vm.run()
.map_err(|error| DustError::Runtime { error, source })
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn add_variables() {
let source = "let foo = 21; let bar = 21; foo + bar";
let result = run(source);
assert_eq!(result, Ok(Some(Value::integer(42))));
}
#[test]
fn variable() {
let source = "let foo = 42; foo";
let result = run(source);
assert_eq!(result, Ok(Some(Value::integer(42))));
}
#[test]
fn integer() {
let source = "42";
let result = run(source);
assert_eq!(result, Ok(Some(Value::integer(42))));
}
#[test]
fn addition() {
let source = "21 + 21";
let result = run(source);
assert_eq!(result, Ok(Some(Value::integer(42))));
}
}

8
dust-lang/src/token.rs
View File

@ -1,10 +1,8 @@
//! Token and TokenOwned types.
use std::fmt::{self, Display, Formatter};
use serde::{Deserialize, Serialize};
/// Source code token.
#[derive(Debug, Serialize, Deserialize, PartialEq)]
#[derive(Debug, PartialEq)]
pub enum Token<'src> {
// End of file
Eof,
@ -293,7 +291,7 @@ impl<'src> Display for Token<'src> {
/// Owned version of `Token`, which owns all the strings.
///
/// This is used for errors.
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
#[derive(Debug, PartialEq, Clone)]
pub enum TokenOwned {
Eof,
@ -412,7 +410,7 @@ impl Display for TokenOwned {
}
/// Token representation that holds no data.
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
#[derive(Debug, PartialEq, Clone)]
pub enum TokenKind {
Eof,

465
dust-lang/src/vm.rs
View File

@ -1,465 +0,0 @@
use crate::{
dust_error::AnnotatedError, parse, Chunk, ChunkError, DustError, Identifier, Instruction, Span,
Value, ValueError,
};
pub fn run(source: &str) -> Result<Option<Value>, DustError> {
let chunk = parse(source)?;
let mut vm = Vm::new(chunk);
vm.run()
.map_err(|error| DustError::Runtime { error, source })
}
#[derive(Debug, Eq, PartialEq)]
pub struct Vm {
chunk: Chunk,
ip: usize,
stack: Vec<Value>,
}
impl Vm {
const STACK_SIZE: usize = 256;
pub fn new(chunk: Chunk) -> Self {
Self {
chunk,
ip: 0,
stack: Vec::with_capacity(Self::STACK_SIZE),
}
}
pub fn run(&mut self) -> Result<Option<Value>, VmError> {
let mut current_position = Span(0, 0);
while let Ok((byte, position)) = self.read(current_position).copied() {
current_position = position;
let instruction = Instruction::from_byte(byte)
.ok_or_else(|| VmError::InvalidInstruction(byte, position))?;
log::trace!("Running instruction {instruction} at {position}");
match instruction {
Instruction::Constant => {
let (argument, _) = *self.read(position)?;
let value = self.chunk.use_constant(argument, position)?;
log::trace!("Pushing constant {value}");
self.push(value, position)?;
}
Instruction::Return => {
let value = self.pop(position)?;
log::trace!("Returning {value}");
return Ok(Some(value));
}
Instruction::Pop => {
let value = self.pop(position)?;
log::trace!("Popping {value:?}");
}
// Variables
Instruction::DeclareVariable => {
let (argument, _) = *self.read(position)?;
let identifier = self
.chunk
.get_identifier(argument)
.ok_or_else(|| VmError::UndeclaredVariable { position })?;
let value = self.stack.remove(argument as usize);
log::trace!("Declaring {identifier} as value {value}",);
self.push(value, position)?;
}
Instruction::GetVariable => {
let (argument, _) = *self.read(position)?;
let identifier = self
.chunk
.get_identifier(argument)
.ok_or_else(|| VmError::UndeclaredVariable { position })?;
let value = self.stack.remove(argument as usize);
log::trace!("Getting {identifier} as value {value}",);
self.push(value, position)?;
}
Instruction::SetVariable => {
let (argument, _) = *self.read(position)?;
let identifier = self
.chunk
.get_identifier(argument)
.ok_or_else(|| VmError::UndeclaredVariable { position })?
.clone();
if !self.chunk.contains_identifier(&identifier) {
return Err(VmError::UndefinedVariable {
identifier: identifier.clone(),
position,
});
}
let value = self.pop(position)?;
log::trace!("Setting {identifier} to {value}");
self.stack[argument as usize] = value;
}
// Unary
Instruction::Negate => {
let negated = self
.pop(position)?
.negate()
.map_err(|error| VmError::Value { error, position })?;
self.push(negated, position)?;
}
Instruction::Not => {
let not = self
.pop(position)?
.not()
.map_err(|error| VmError::Value { error, position })?;
self.push(not, position)?;
}
// Binary
Instruction::Add => {
let right = self.pop(position)?;
let left = self.pop(position)?;
let sum = left
.add(&right)
.map_err(|error| VmError::Value { error, position })?;
self.push(sum, position)?;
}
Instruction::Subtract => {
let right = self.pop(position)?;
let left = self.pop(position)?;
let difference = left
.subtract(&right)
.map_err(|error| VmError::Value { error, position })?;
self.push(difference, position)?;
}
Instruction::Multiply => {
let right = self.pop(position)?;
let left = self.pop(position)?;
let product = left
.multiply(&right)
.map_err(|error| VmError::Value { error, position })?;
self.push(product, position)?;
}
Instruction::Divide => {
let right = self.pop(position)?;
let left = self.pop(position)?;
let quotient = left
.divide(&right)
.map_err(|error| VmError::Value { error, position })?;
self.push(quotient, position)?;
}
Instruction::Greater => {
let right = self.pop(position)?;
let left = self.pop(position)?;
let greater = left
.greater_than(&right)
.map_err(|error| VmError::Value { error, position })?;
self.push(greater, position)?;
}
Instruction::Less => {
let right = self.pop(position)?;
let left = self.pop(position)?;
let less = left
.less_than(&right)
.map_err(|error| VmError::Value { error, position })?;
self.push(less, position)?;
}
Instruction::GreaterEqual => {
let right = self.pop(position)?;
let left = self.pop(position)?;
let greater_equal = left
.greater_than_or_equal(&right)
.map_err(|error| VmError::Value { error, position })?;
self.push(greater_equal, position)?;
}
Instruction::LessEqual => {
let right = self.pop(position)?;
let left = self.pop(position)?;
let less_equal = left
.less_than_or_equal(&right)
.map_err(|error| VmError::Value { error, position })?;
self.push(less_equal, position)?;
}
Instruction::Equal => {
let right = self.pop(position)?;
let left = self.pop(position)?;
let equal = left
.equal(&right)
.map_err(|error| VmError::Value { error, position })?;
self.push(equal, position)?;
}
Instruction::NotEqual => {
let right = self.pop(position)?;
let left = self.pop(position)?;
let not_equal = left
.not_equal(&right)
.map_err(|error| VmError::Value { error, position })?;
self.push(not_equal, position)?;
}
Instruction::And => {
let right = self.pop(position)?;
let left = self.pop(position)?;
let and = left
.and(&right)
.map_err(|error| VmError::Value { error, position })?;
self.push(and, position)?;
}
Instruction::Or => {
let right = self.pop(position)?;
let left = self.pop(position)?;
let or = left
.or(&right)
.map_err(|error| VmError::Value { error, position })?;
self.push(or, position)?;
}
}
}
Ok(None)
}
fn push(&mut self, value: Value, position: Span) -> Result<(), VmError> {
if self.stack.len() == Self::STACK_SIZE {
Err(VmError::StackOverflow(position))
} else {
self.stack.push(value);
Ok(())
}
}
fn pop(&mut self, position: Span) -> Result<Value, VmError> {
if let Some(stacked) = self.stack.pop() {
Ok(stacked)
} else {
Err(VmError::StackUnderflow(position))
}
}
fn read(&mut self, position: Span) -> Result<&(u8, Span), VmError> {
let current = self.chunk.get_code(self.ip, position)?;
self.ip += 1;
Ok(current)
}
}
#[derive(Debug, Clone, PartialEq)]
pub enum VmError {
InvalidInstruction(u8, Span),
StackOverflow(Span),
StackUnderflow(Span),
UndeclaredVariable {
position: Span,
},
UndefinedVariable {
identifier: Identifier,
position: Span,
},
// Wrappers for foreign errors
Chunk(ChunkError),
Value {
error: ValueError,
position: Span,
},
}
impl From<ChunkError> for VmError {
fn from(v: ChunkError) -> Self {
Self::Chunk(v)
}
}
impl AnnotatedError for VmError {
fn title() -> &'static str {
"Runtime Error"
}
fn description(&self) -> &'static str {
match self {
Self::InvalidInstruction(_, _) => "Invalid instruction",
Self::StackOverflow(_) => "Stack overflow",
Self::StackUnderflow(_) => "Stack underflow",
Self::UndeclaredVariable { .. } => "Undeclared variable",
Self::UndefinedVariable { .. } => "Undefined variable",
Self::Chunk(_) => "Chunk error",
Self::Value { .. } => "Value error",
}
}
fn details(&self) -> Option<String> {
match self {
Self::InvalidInstruction(byte, _) => Some(format!(
"The byte {byte} does not correspond to a valid instruction"
)),
Self::StackOverflow(position) => Some(format!("Stack overflow at {position}")),
Self::StackUnderflow(position) => Some(format!("Stack underflow at {position}")),
Self::UndeclaredVariable { .. } => Some("Variable is not declared".to_string()),
Self::UndefinedVariable { identifier, .. } => {
Some(format!("{identifier} is not in scope"))
}
Self::Chunk(error) => error.details(),
Self::Value { error, .. } => Some(error.to_string()),
}
}
fn position(&self) -> Span {
match self {
Self::InvalidInstruction(_, position) => *position,
Self::StackUnderflow(position) => *position,
Self::StackOverflow(position) => *position,
Self::UndeclaredVariable { position } => *position,
Self::UndefinedVariable { position, .. } => *position,
Self::Chunk(error) => error.position(),
Self::Value { position, .. } => *position,
}
}
}
#[cfg(test)]
pub mod tests {
use super::*;
#[test]
fn negation() {
let mut chunk = Chunk::new();
let dummy_position = Span(0, 0);
let constant = chunk
.push_constant(Value::integer(42), dummy_position)
.unwrap();
chunk.push_code(Instruction::Constant as u8, dummy_position);
chunk.push_code(constant, dummy_position);
chunk.push_code(Instruction::Negate as u8, dummy_position);
chunk.push_code(Instruction::Return as u8, dummy_position);
let mut vm = Vm::new(chunk);
let result = vm.run();
assert_eq!(result, Ok(Some(Value::integer(-42))));
}
#[test]
fn addition() {
let mut chunk = Chunk::new();
let dummy_position = Span(0, 0);
let left = chunk
.push_constant(Value::integer(42), dummy_position)
.unwrap();
let right = chunk
.push_constant(Value::integer(23), dummy_position)
.unwrap();
chunk.push_code(Instruction::Constant, dummy_position);
chunk.push_code(left, dummy_position);
chunk.push_code(Instruction::Constant, dummy_position);
chunk.push_code(right, dummy_position);
chunk.push_code(Instruction::Add, dummy_position);
chunk.push_code(Instruction::Return, dummy_position);
let mut vm = Vm::new(chunk);
let result = vm.run();
assert_eq!(result, Ok(Some(Value::integer(65))));
}
#[test]
fn subtraction() {
let mut chunk = Chunk::new();
let dummy_position = Span(0, 0);
let left = chunk
.push_constant(Value::integer(42), dummy_position)
.unwrap();
let right = chunk
.push_constant(Value::integer(23), dummy_position)
.unwrap();
chunk.push_code(Instruction::Constant, dummy_position);
chunk.push_code(left, dummy_position);
chunk.push_code(Instruction::Constant, dummy_position);
chunk.push_code(right, dummy_position);
chunk.push_code(Instruction::Subtract, dummy_position);
chunk.push_code(Instruction::Return, dummy_position);
let mut vm = Vm::new(chunk);
let result = vm.run();
assert_eq!(result, Ok(Some(Value::integer(19))));
}
#[test]
fn multiplication() {
let mut chunk = Chunk::new();
let dummy_position = Span(0, 0);
let left = chunk
.push_constant(Value::integer(42), dummy_position)
.unwrap();
let right = chunk
.push_constant(Value::integer(23), dummy_position)
.unwrap();
chunk.push_code(Instruction::Constant, dummy_position);
chunk.push_code(left, dummy_position);
chunk.push_code(Instruction::Constant, dummy_position);
chunk.push_code(right, dummy_position);
chunk.push_code(Instruction::Multiply, dummy_position);
chunk.push_code(Instruction::Return, dummy_position);
let mut vm = Vm::new(chunk);
let result = vm.run();
assert_eq!(result, Ok(Some(Value::integer(966))));
}
#[test]
fn division() {
let mut chunk = Chunk::new();
let dummy_position = Span(0, 0);
let left = chunk
.push_constant(Value::integer(42), dummy_position)
.unwrap();
let right = chunk
.push_constant(Value::integer(23), dummy_position)
.unwrap();
chunk.push_code(Instruction::Constant, dummy_position);
chunk.push_code(left, dummy_position);
chunk.push_code(Instruction::Constant, dummy_position);
chunk.push_code(right, dummy_position);
chunk.push_code(Instruction::Divide, dummy_position);
chunk.push_code(Instruction::Return, dummy_position);
let mut vm = Vm::new(chunk);
let result = vm.run();
assert_eq!(result, Ok(Some(Value::integer(1))));
}
}

9
dust-lang/tests/operations.rs
View File

@ -1,9 +0,0 @@
use dust_lang::*;
#[test]
fn addition() {
let source = "21 + 21";
let result = run(source);
assert_eq!(result, Ok(Some(Value::integer(42))));
}

49
dust-lang/tests/values.rs
View File

@ -1,49 +0,0 @@
use dust_lang::*;
#[test]
fn integer() {
let source = "42";
let result = run(source);
assert_eq!(result, Ok(Some(Value::integer(42))));
}
#[test]
fn float() {
let source = "42.0";
let result = run(source);
assert_eq!(result, Ok(Some(Value::float(42.0))));
}
#[test]
fn string() {
let source = "\"Hello, World!\"";
let result = run(source);
assert_eq!(result, Ok(Some(Value::string("Hello, World!"))));
}
#[test]
fn boolean() {
let source = "true";
let result = run(source);
assert_eq!(result, Ok(Some(Value::boolean(true))));
}
#[test]
fn byte() {
let source = "0x42";
let result = run(source);
assert_eq!(result, Ok(Some(Value::byte(0x42))));
}
#[test]
fn character() {
let source = "'a'";
let result = run(source);
assert_eq!(result, Ok(Some(Value::character('a'))));
}

33
dust-lang/tests/variables.rs
View File

@ -1,33 +0,0 @@
use dust_lang::*;
#[test]
fn add_variables() {
let source = "let foo = 21; let bar = 21; foo + bar";
let result = run(source);
assert_eq!(result, Ok(Some(Value::integer(42))));
}
#[test]
fn variable() {
let source = "let foo = 42; foo";
let result = run(source);
assert_eq!(result, Ok(Some(Value::integer(42))));
}
#[test]
fn lots_of_variables() {
env_logger::builder().is_test(true).try_init().unwrap();
let source = "
let foo = 1;
let bar = 2;
let baz = 3;
let qux = 4;
let quux = 5;
foo + bar + baz + qux + quux";
let result = run(source);
assert_eq!(result, Ok(Some(Value::integer(15))));
}

130
dust-shell/src/main.rs
View File

@ -1,78 +1,78 @@
use std::{fs::read_to_string, io::Write};
// use std::{fs::read_to_string, io::Write};
use clap::Parser;
use colored::Colorize;
use dust_lang::{parse, run};
use log::Level;
// use clap::Parser;
// use colored::Colorize;
// use dust_lang::{parse, run};
// use log::Level;
#[derive(Parser)]
struct Cli {
#[arg(short, long)]
command: Option<String>,
// #[derive(Parser)]
// struct Cli {
// #[arg(short, long)]
// command: Option<String>,
#[arg(short, long)]
parse: bool,
// #[arg(short, long)]
// parse: bool,
path: Option<String>,
}
// path: Option<String>,
// }
fn main() {
env_logger::builder()
.parse_env("DUST_LOG")
.format(|buf, record| {
let level = match record.level() {
Level::Error => "ERROR".red(),
Level::Warn => "WARN".yellow(),
Level::Info => "INFO".white(),
Level::Debug => "DEBUG".blue(),
Level::Trace => "TRACE".purple(),
}
.bold();
let level_display = format!("[{level:^5}]").white().on_black();
let module = record
.module_path()
.map(|path| path.split("::").last().unwrap_or("unknown"))
.unwrap_or("unknown")
.dimmed();
// env_logger::builder()
// .parse_env("DUST_LOG")
// .format(|buf, record| {
// let level = match record.level() {
// Level::Error => "ERROR".red(),
// Level::Warn => "WARN".yellow(),
// Level::Info => "INFO".white(),
// Level::Debug => "DEBUG".blue(),
// Level::Trace => "TRACE".purple(),
// }
// .bold();
// let level_display = format!("[{level:^5}]").white().on_black();
// let module = record
// .module_path()
// .map(|path| path.split("::").last().unwrap_or("unknown"))
// .unwrap_or("unknown")
// .dimmed();
writeln!(buf, "{level_display} {module:^6} {}", record.args())
})
.init();
// writeln!(buf, "{level_display} {module:^6} {}", record.args())
// })
// .init();
let args = Cli::parse();
// let args = Cli::parse();
if let Some(command) = &args.command {
if args.parse {
parse_and_display_errors(command);
} else {
run_and_display_errors(command);
}
} else if let Some(path) = &args.path {
let source = read_to_string(path).expect("Failed to read file");
// if let Some(command) = &args.command {
// if args.parse {
// parse_and_display_errors(command);
// } else {
// run_and_display_errors(command);
// }
// } else if let Some(path) = &args.path {
// let source = read_to_string(path).expect("Failed to read file");
if args.parse {
parse_and_display_errors(&source);
} else {
run_and_display_errors(&source);
}
}
// if args.parse {
// parse_and_display_errors(&source);
// } else {
// run_and_display_errors(&source);
// }
// }
}
fn parse_and_display_errors(source: &str) {
match parse(source) {
Ok(chunk) => println!("{}", chunk.disassemble("Dust CLI Input")),
Err(error) => {
eprintln!("{:?}", error);
}
}
}
// fn parse_and_display_errors(source: &str) {
// match parse(source) {
// Ok(chunk) => println!("{}", chunk.disassemble("Dust CLI Input")),
// Err(error) => {
// eprintln!("{:?}", error);
// }
// }
// }
fn run_and_display_errors(source: &str) {
match run(source) {
Ok(Some(value)) => println!("{}", value),
Ok(_) => {}
Err(error) => {
eprintln!("{}", error.report());
}
}
}
// fn run_and_display_errors(source: &str) {
// match run(source) {
// Ok(Some(value)) => println!("{}", value),
// Ok(_) => {}
// Err(error) => {
// eprintln!("{}", error.report());
// }
// }
// }