Compare commits
8 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 Oleksandr Kozachuk
|
9b10723a95 | ||
|
Oleksandr Kozachuk
|
15f8005b6d | ||
|
Oleksandr Kozachuk
|
4769987b20 | ||
|
Oleksandr Kozachuk
|
d55a27873e | ||
 Oleksandr Kozachuk
|
645b00d6e8 | ||
|
Oleksandr Kozachuk
|
9efb92ddc8 | ||
|
Oleksandr Kozachuk
|
706c73ce2a | ||
|
Oleksandr Kozachuk
|
a89d7ca704 |
+61
-1
@@ -5,6 +5,66 @@ All notable changes to WAFER are documented in this file.
|
||||
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
|
||||
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
|
||||
|
||||
## [0.2.4] - 2026-08-06
|
||||
|
||||
### Fixed
|
||||
|
||||
- **Errors from host words in the browser build read like Forth errors
|
||||
again.** A host word signals failure by throwing across the JS
|
||||
boundary, and the browser runtime reported the exception with its
|
||||
`Debug` form, so an empty-stack `RESIZE` came back as
|
||||
`call_func(134) failed: JsValue(Error: Stack underflow ...)` trailed by
|
||||
an engine stack trace. The thrown message is the Forth message, so it
|
||||
is now surfaced verbatim — `Stack underflow`, exactly what the native
|
||||
CLI prints. Exceptions that carry no message keep the call context,
|
||||
since those are genuine runtime faults rather than Forth throws.
|
||||
`CATCH` was never affected: it reads the throw code from its own
|
||||
channel, not from the message.
|
||||
|
||||
## [0.2.3] - 2026-08-06
|
||||
|
||||
### Fixed
|
||||
|
||||
- **Release builds of `wafer-web` no longer fail on proc-macro loading.**
|
||||
Cargo strips debuginfo from release artifacts by default, and on macOS
|
||||
that also strips the metadata proc-macro dylibs need to be loadable, so
|
||||
`wasm-pack build --release` died with `can't find crate` for
|
||||
`rustversion`, `thiserror_impl` and every other proc-macro. Build
|
||||
scripts and proc-macros gain nothing from stripping, so
|
||||
`[profile.release.build-override]` now exempts them; release binaries
|
||||
stay stripped. Debug builds were never affected, which is why the test
|
||||
suite stayed green while the browser REPL could not be built for
|
||||
production.
|
||||
- `wafer-web` and `wafer-cli` requested `wafer-core` version `0.2.1`
|
||||
while the workspace had moved to `0.2.2`. The caret requirement still
|
||||
resolved, so nothing broke, but the pin is now kept in step.
|
||||
|
||||
## [0.2.2] - 2026-08-06
|
||||
|
||||
### Added
|
||||
|
||||
- **SwiftForth-style input number conversion.** Punctuation (`,` `.` `+`
|
||||
`/` `:` and an embedded `-`) anywhere after the leftmost digit now forces
|
||||
double-cell conversion, so `12.34`, `1,234`, `12:30:45` and `2026-08-06`
|
||||
all convert as doubles without a custom parser. Previously only a
|
||||
trailing `.` worked and `1.5` was an "unknown word" error. The
|
||||
punctuation is a double-cell marker, not a fractional point: every
|
||||
spelling of `1234` (`1234.`, `123.4`, `.1234`) yields the same value.
|
||||
- **`DPL`** ( -- addr ): digits to the right of the rightmost punctuation
|
||||
character in the last converted number, negative when the token carried
|
||||
none. Seeded at -1024 and bumped once per digit, matching `sf64`.
|
||||
Together with `<# #>` this is how fixed-point input is scaled.
|
||||
- **`NH`** ( -- addr ): the high-order cell dropped by a single-cell
|
||||
conversion, so a token that overflows a cell can be recovered as a
|
||||
double (`4000000000 NH @ D.`).
|
||||
|
||||
Verified token-for-token against SwiftForth `sf64`: DPL values, double
|
||||
promotion and sign handling agree on every probed form. One deliberate
|
||||
divergence — WAFER also accepts a sign before a base prefix (`-$FF`), which
|
||||
`sf64` rejects; the Forth 2012 spelling `$-FF` works in both. A leading `+`
|
||||
is punctuation rather than a sign in both engines, so `+7` is the double 7
|
||||
with `DPL` = 1.
|
||||
|
||||
## [0.2.1] - 2026-08-06
|
||||
|
||||
### Fixed
|
||||
@@ -78,7 +138,7 @@ safety net under every compiled word.
|
||||
### Fixed
|
||||
|
||||
- Multi-line command output in the CLI REPL starts on its own line
|
||||
(inline ` ok` echo only for single-line output).
|
||||
(inline `ok` echo only for single-line output).
|
||||
- `.S` printed in decimal regardless of `BASE`.
|
||||
- A bare interpreted `R>` underflowed silently (exposed by the new stack
|
||||
guards; compliance baseline updated).
|
||||
|
||||
@@ -79,7 +79,7 @@ Handle in `interpret_token_immediate()` or `compile_token()` as a special case.
|
||||
|
||||
## Testing
|
||||
|
||||
- Run `cargo test --workspace` before committing (currently 542 unit + 1 benchmark + 11 compliance + 9 comparison + 5 crypto)
|
||||
- Run `cargo test --workspace` before committing (currently 562 unit + 1 benchmark + 11 compliance + 9 comparison + 5 crypto)
|
||||
- Forth 2012 compliance: `cargo test -p wafer-core --test compliance`
|
||||
- Cross-engine comparison (vs gforth): `cargo test -p wafer-core --test comparison`
|
||||
- Performance benchmarks (release mode): `cargo test -p wafer-core --test comparison -- --nocapture --ignored`
|
||||
|
||||
Generated
+23
-87
@@ -132,15 +132,6 @@ dependencies = [
|
||||
"generic-array",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "block-buffer"
|
||||
version = "0.12.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d2f6c7dbe95a6ed67ad9f18e57daf93a2f034c524b99fd2b76d18fdfeb6660aa"
|
||||
dependencies = [
|
||||
"hybrid-array",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "bumpalo"
|
||||
version = "3.20.3"
|
||||
@@ -182,9 +173,9 @@ checksum = "f079e83a288787bcd14a6aea84cee5c87a67c5a3e660c30f557a3d24761b3527"
|
||||
|
||||
[[package]]
|
||||
name = "clap"
|
||||
version = "4.6.5"
|
||||
version = "4.6.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "301b56658598e48f3648647ac6fc887be7e7108eddfa4e9b63fcf3ec58c0cadf"
|
||||
checksum = "473c7e07f409a8d772161724aa8db6a765a2532a70f9667eeb7b49d3d02fbdca"
|
||||
dependencies = [
|
||||
"clap_builder",
|
||||
"clap_derive",
|
||||
@@ -192,9 +183,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "clap_builder"
|
||||
version = "4.6.5"
|
||||
version = "4.6.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "94a65403d1a1bd28f7dc68eb8506e8874808ee5eecb59298de588e2e1407a078"
|
||||
checksum = "7b48fea5a88e9ae728a2dcbedbfc0e730f7d60da42e1cb049a83c9fb8b789889"
|
||||
dependencies = [
|
||||
"anstream",
|
||||
"anstyle",
|
||||
@@ -255,12 +246,6 @@ dependencies = [
|
||||
"windows-sys",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "const-oid"
|
||||
version = "0.10.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a6ef517f0926dd24a1582492c791b6a4818a4d94e789a334894aa15b0d12f55c"
|
||||
|
||||
[[package]]
|
||||
name = "cpp_demangle"
|
||||
version = "0.5.1"
|
||||
@@ -279,15 +264,6 @@ dependencies = [
|
||||
"libc",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "cpufeatures"
|
||||
version = "0.3.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "8b2a41393f66f16b0823bb79094d54ac5fbd34ab292ddafb9a0456ac9f87d201"
|
||||
dependencies = [
|
||||
"libc",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "cranelift-assembler-x64"
|
||||
version = "0.134.3"
|
||||
@@ -352,7 +328,7 @@ dependencies = [
|
||||
"rustc-hash",
|
||||
"serde",
|
||||
"serde_derive",
|
||||
"sha2 0.10.9",
|
||||
"sha2",
|
||||
"smallvec",
|
||||
"target-lexicon",
|
||||
"wasmtime-internal-core",
|
||||
@@ -478,15 +454,6 @@ dependencies = [
|
||||
"typenum",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "crypto-common"
|
||||
version = "0.2.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ce6e4c961d6cd6c9a86db418387425e8bdeaf05b3c8bc1411e6dca4c252f1453"
|
||||
dependencies = [
|
||||
"hybrid-array",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "debugid"
|
||||
version = "0.8.0"
|
||||
@@ -502,19 +469,8 @@ version = "0.10.7"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
|
||||
dependencies = [
|
||||
"block-buffer 0.10.4",
|
||||
"crypto-common 0.1.7",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "digest"
|
||||
version = "0.11.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f1dd6dbb5841937940781866fa1281a1ff7bd3bf827091440879f9994983d5c2"
|
||||
dependencies = [
|
||||
"block-buffer 0.12.1",
|
||||
"const-oid",
|
||||
"crypto-common 0.2.2",
|
||||
"block-buffer",
|
||||
"crypto-common",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -795,15 +751,6 @@ dependencies = [
|
||||
"windows-sys",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "hybrid-array"
|
||||
version = "0.4.14"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "707114b52a152fa7bdb290cd7cd5912d9467273b6d74e21b8d81aca1f8533f6b"
|
||||
dependencies = [
|
||||
"typenum",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "id-arena"
|
||||
version = "2.3.0"
|
||||
@@ -1400,13 +1347,13 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "sha1"
|
||||
version = "0.11.0"
|
||||
version = "0.10.7"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "aacc4cc499359472b4abe1bf11d0b12e688af9a805fa5e3016f9a386dc2d0214"
|
||||
checksum = "a978451301f4db1d02937a4ab3ccce137717b81826e79b7d49ffe3244a13c3b8"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"cpufeatures 0.3.0",
|
||||
"digest 0.11.3",
|
||||
"cpufeatures",
|
||||
"digest",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -1416,19 +1363,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"cpufeatures 0.2.17",
|
||||
"digest 0.10.7",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "sha2"
|
||||
version = "0.11.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "446ba717509524cb3f22f17ecc096f10f4822d76ab5c0b9822c5f9c284e825f4"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"cpufeatures 0.3.0",
|
||||
"digest 0.11.3",
|
||||
"cpufeatures",
|
||||
"digest",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -1653,7 +1589,7 @@ checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
|
||||
|
||||
[[package]]
|
||||
name = "wafer"
|
||||
version = "0.2.1"
|
||||
version = "0.2.4"
|
||||
dependencies = [
|
||||
"anyhow",
|
||||
"clap",
|
||||
@@ -1664,13 +1600,13 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "wafer-core"
|
||||
version = "0.2.1"
|
||||
version = "0.2.4"
|
||||
dependencies = [
|
||||
"anyhow",
|
||||
"insta",
|
||||
"proptest",
|
||||
"sha1",
|
||||
"sha2 0.11.0",
|
||||
"sha2",
|
||||
"thiserror 2.0.19",
|
||||
"wasm-encoder 0.255.0",
|
||||
"wasmparser 0.255.0",
|
||||
@@ -1679,7 +1615,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "wafer-web"
|
||||
version = "0.2.1"
|
||||
version = "0.2.4"
|
||||
dependencies = [
|
||||
"anyhow",
|
||||
"js-sys",
|
||||
@@ -1966,7 +1902,7 @@ dependencies = [
|
||||
"semver",
|
||||
"serde",
|
||||
"serde_derive",
|
||||
"sha2 0.10.9",
|
||||
"sha2",
|
||||
"smallvec",
|
||||
"target-lexicon",
|
||||
"wasm-encoder 0.252.0",
|
||||
@@ -1989,7 +1925,7 @@ dependencies = [
|
||||
"rustix",
|
||||
"serde",
|
||||
"serde_derive",
|
||||
"sha2 0.10.9",
|
||||
"sha2",
|
||||
"toml",
|
||||
"wasmtime-environ",
|
||||
"windows-sys",
|
||||
@@ -2239,18 +2175,18 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "zerocopy"
|
||||
version = "0.8.55"
|
||||
version = "0.8.56"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b5a105cd7b140f6eeec8acff2ea38135d3cab283ada58540f629fe51e46696eb"
|
||||
checksum = "556764e583adb45a9f8d413c2a147fa7e8d821e48e12b14fd560b607998b75eb"
|
||||
dependencies = [
|
||||
"zerocopy-derive",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zerocopy-derive"
|
||||
version = "0.8.55"
|
||||
version = "0.8.56"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "0fe976fb70c78cd64cccfe3a6fc142244e8a77b70959b30faf9d0ac37ee228eb"
|
||||
checksum = "f2ab42fc20575779bd240faa45f94a74256f755c0fa9e89f0ede20d91d0cdfc1"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
|
||||
+11
-3
@@ -3,7 +3,7 @@ members = ["crates/*"]
|
||||
resolver = "2"
|
||||
|
||||
[workspace.package]
|
||||
version = "0.2.1"
|
||||
version = "0.2.4"
|
||||
edition = "2024"
|
||||
license = "MIT OR Apache-2.0"
|
||||
repository = "https://github.com/ok2/wafer"
|
||||
@@ -48,6 +48,14 @@ anyhow = "1"
|
||||
thiserror = "2"
|
||||
proptest = "1"
|
||||
insta = "1"
|
||||
sha1 = "0.11"
|
||||
sha2 = "0.11"
|
||||
sha1 = "0.10"
|
||||
sha2 = "0.10"
|
||||
send_wrapper = "0.6"
|
||||
|
||||
# Cargo strips debuginfo from release artifacts by default, and on macOS that
|
||||
# also strips the metadata proc-macro dylibs need to be loadable — release
|
||||
# builds then fail with "can't find crate" for every proc-macro (rustversion,
|
||||
# thiserror_impl, ...). Build scripts and proc-macros gain nothing from
|
||||
# stripping, so exempt them; the release binaries stay stripped.
|
||||
[profile.release.build-override]
|
||||
strip = false
|
||||
|
||||
@@ -9,7 +9,7 @@ license.workspace = true
|
||||
workspace = true
|
||||
|
||||
[dependencies]
|
||||
wafer-core = { path = "../core", version = "0.2.1" }
|
||||
wafer-core = { path = "../core", version = "0.2.4" }
|
||||
wasmtime = { workspace = true }
|
||||
anyhow = { workspace = true }
|
||||
clap = { version = "4", features = ["derive"] }
|
||||
|
||||
@@ -108,6 +108,23 @@ pub const SYSVAR_HLD: u32 = SYSVAR_BASE + 28;
|
||||
pub const SYSVAR_LEAVE_FLAG: u32 = SYSVAR_BASE + 32;
|
||||
/// Throw code left by a compiled stack-guard fault for `_STACK_FAULT_`.
|
||||
pub const SYSVAR_FAULT_CODE: u32 = SYSVAR_BASE + 36;
|
||||
/// DPL: digits right of the rightmost punctuation in the last converted
|
||||
/// number; negative when the token carried no punctuation.
|
||||
pub const SYSVAR_DPL: u32 = SYSVAR_BASE + 40;
|
||||
/// NH: high-order cell of the last single-cell conversion, so an
|
||||
/// out-of-range token can be recovered as a double.
|
||||
pub const SYSVAR_NH: u32 = SYSVAR_BASE + 44;
|
||||
|
||||
/// Seed for [`SYSVAR_DPL`] before conversion starts.
|
||||
///
|
||||
/// `SwiftForth` seeds DPL with a negative value and bumps it once per digit,
|
||||
/// so an unpunctuated token still ends up negative. Punctuation resets the
|
||||
/// counter to zero, which makes the final value the digit count right of the
|
||||
/// rightmost punctuation character.
|
||||
///
|
||||
/// The exact seed is observable: `sf64` reports DPL as -1020 after `1234`
|
||||
/// and -1023 after `-1`, both of which pin it to -1024.
|
||||
pub const DPL_INIT: i32 = -1024;
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
@@ -149,6 +166,9 @@ mod tests {
|
||||
SYSVAR_NUM_TIB,
|
||||
SYSVAR_HLD,
|
||||
SYSVAR_LEAVE_FLAG,
|
||||
SYSVAR_FAULT_CODE,
|
||||
SYSVAR_DPL,
|
||||
SYSVAR_NH,
|
||||
];
|
||||
for offset in all_offsets {
|
||||
assert!(offset + CELL_SIZE <= SYSVAR_BASE + SYSVAR_SIZE);
|
||||
|
||||
+281
-88
@@ -23,12 +23,64 @@ use crate::ir::IrOp;
|
||||
#[cfg(feature = "crypto")]
|
||||
use crate::memory::HASH_SCRATCH_BASE;
|
||||
use crate::memory::{
|
||||
CELL_SIZE, DATA_STACK_TOP, FLOAT_SIZE, FLOAT_STACK_BASE, FLOAT_STACK_TOP, INPUT_BUFFER_BASE,
|
||||
INPUT_BUFFER_SIZE, RETURN_STACK_TOP, SYSVAR_BASE_VAR, SYSVAR_FAULT_CODE, SYSVAR_HERE,
|
||||
SYSVAR_LEAVE_FLAG, SYSVAR_NUM_TIB, SYSVAR_STATE, SYSVAR_TO_IN,
|
||||
CELL_SIZE, DATA_STACK_TOP, DPL_INIT, FLOAT_SIZE, FLOAT_STACK_BASE, FLOAT_STACK_TOP,
|
||||
INPUT_BUFFER_BASE, INPUT_BUFFER_SIZE, RETURN_STACK_TOP, SYSVAR_BASE_VAR, SYSVAR_DPL,
|
||||
SYSVAR_FAULT_CODE, SYSVAR_HERE, SYSVAR_LEAVE_FLAG, SYSVAR_NH, SYSVAR_NUM_TIB, SYSVAR_STATE,
|
||||
SYSVAR_TO_IN,
|
||||
};
|
||||
use crate::optimizer::optimize;
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Number conversion
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Characters that force double-cell conversion, following `SwiftForth`'s
|
||||
/// input number conversion rules.
|
||||
///
|
||||
/// A leading `-` is the one exception: it binds as a sign, which keeps `-1`
|
||||
/// a single-cell number while `1-2` converts as a double.
|
||||
const DOUBLE_PUNCTUATION: [u8; 6] = *b",.+-/:";
|
||||
|
||||
/// Split a leading minus off a token, returning whether it was negative.
|
||||
///
|
||||
/// Only `-` is a sign. A leading `+` stays punctuation, matching `sf64`,
|
||||
/// where `+7` converts as the double 7 with `DPL` = 1.
|
||||
///
|
||||
/// The sign may sit between a base-override prefix and the digits (`$-FF`,
|
||||
/// the Forth 2012 spelling) or, as a WAFER extension, before the prefix
|
||||
/// (`-$FF`), so this runs at both positions.
|
||||
fn strip_sign(s: &str) -> (bool, &str) {
|
||||
match s.as_bytes().first() {
|
||||
Some(b'-') => (true, &s[1..]),
|
||||
_ => (false, s),
|
||||
}
|
||||
}
|
||||
|
||||
/// A numeric token that converted successfully.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
struct NumberLiteral {
|
||||
/// The accumulated 64-bit value, sign applied.
|
||||
value: i64,
|
||||
/// Digits right of the rightmost punctuation character. Negative when the
|
||||
/// token carried no punctuation, which is how `DPL` reports "single-cell".
|
||||
dpl: i32,
|
||||
/// Whether punctuation forced double-cell conversion.
|
||||
is_double: bool,
|
||||
}
|
||||
|
||||
impl NumberLiteral {
|
||||
/// Low-order cell — the value a single-cell conversion leaves on the stack.
|
||||
fn lo(self) -> i32 {
|
||||
self.value as i32
|
||||
}
|
||||
|
||||
/// High-order cell. For a single-cell conversion this is what `NH` holds,
|
||||
/// letting an out-of-range token be recovered as a double.
|
||||
fn hi(self) -> i32 {
|
||||
(self.value >> 32) as i32
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Control-flow compilation state
|
||||
// ---------------------------------------------------------------------------
|
||||
@@ -1194,22 +1246,18 @@ impl<R: Runtime> ForthVM<R> {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
// Try to parse as double-number (trailing dot)
|
||||
if let Some((lo, hi)) = self.parse_double_number(token) {
|
||||
self.push_data_stack(lo)?;
|
||||
self.push_data_stack(hi)?;
|
||||
// Try to convert as a number; punctuation makes it double-cell
|
||||
if let Some(lit) = self.parse_numeric_literal(token) {
|
||||
self.record_number_conversion(lit);
|
||||
self.push_data_stack(lit.lo())?;
|
||||
if self.recording_toplevel && self.state == 0 {
|
||||
self.toplevel_ir.push(IrOp::PushI32(lo));
|
||||
self.toplevel_ir.push(IrOp::PushI32(hi));
|
||||
self.toplevel_ir.push(IrOp::PushI32(lit.lo()));
|
||||
}
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
// Try to parse as number
|
||||
if let Some(n) = self.parse_number(token) {
|
||||
self.push_data_stack(n)?;
|
||||
if self.recording_toplevel && self.state == 0 {
|
||||
self.toplevel_ir.push(IrOp::PushI32(n));
|
||||
if lit.is_double {
|
||||
self.push_data_stack(lit.hi())?;
|
||||
if self.recording_toplevel && self.state == 0 {
|
||||
self.toplevel_ir.push(IrOp::PushI32(lit.hi()));
|
||||
}
|
||||
}
|
||||
return Ok(());
|
||||
}
|
||||
@@ -1571,16 +1619,13 @@ impl<R: Runtime> ForthVM<R> {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
// Try to parse as double-number (trailing dot)
|
||||
if let Some((lo, hi)) = self.parse_double_number(token) {
|
||||
self.push_ir(IrOp::PushI32(lo));
|
||||
self.push_ir(IrOp::PushI32(hi));
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
// Try to parse as number
|
||||
if let Some(n) = self.parse_number(token) {
|
||||
self.push_ir(IrOp::PushI32(n));
|
||||
// Try to convert as a number; punctuation makes it double-cell
|
||||
if let Some(lit) = self.parse_numeric_literal(token) {
|
||||
self.record_number_conversion(lit);
|
||||
self.push_ir(IrOp::PushI32(lit.lo()));
|
||||
if lit.is_double {
|
||||
self.push_ir(IrOp::PushI32(lit.hi()));
|
||||
}
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
@@ -2731,83 +2776,109 @@ impl<R: Runtime> ForthVM<R> {
|
||||
// Number parsing
|
||||
// -----------------------------------------------------------------------
|
||||
|
||||
/// Try to parse a token as a number.
|
||||
fn parse_number(&self, token: &str) -> Option<i32> {
|
||||
/// Try to convert a token to a number, following `SwiftForth`'s input
|
||||
/// number conversion rules.
|
||||
///
|
||||
/// Punctuation (`,` `.` `+` `-` `/` `:`) forces double-cell conversion, so
|
||||
/// `12.34`, `1,234`, `12:30:45` and `2026-08-06` all convert as doubles.
|
||||
/// Only a leading `-` escapes this and binds as a sign, which keeps `-1`
|
||||
/// single-cell; a leading `+` stays punctuation, so `+7` is the double 7.
|
||||
///
|
||||
/// `DPL` counts up once per digit from [`DPL_INIT`] and resets to zero at
|
||||
/// every punctuation character, so it ends up holding the digit count right
|
||||
/// of the rightmost punctuation, and stays negative for unpunctuated tokens.
|
||||
fn parse_numeric_literal(&self, token: &str) -> Option<NumberLiteral> {
|
||||
let token = token.trim();
|
||||
if token.is_empty() {
|
||||
return None;
|
||||
}
|
||||
|
||||
// Check for negative prefix
|
||||
let (negative, rest) = if let Some(stripped) = token.strip_prefix('-') {
|
||||
(true, stripped)
|
||||
} else {
|
||||
(false, token)
|
||||
};
|
||||
// A leading sign binds to the number; it is not double punctuation.
|
||||
let (neg_outer, rest) = strip_sign(token);
|
||||
|
||||
if rest.is_empty() {
|
||||
return None;
|
||||
}
|
||||
|
||||
// Parse based on prefix
|
||||
let result = if let Some(hex) = rest.strip_prefix('$') {
|
||||
i64::from_str_radix(hex, 16).ok()
|
||||
} else if let Some(dec) = rest.strip_prefix('#') {
|
||||
dec.parse::<i64>().ok()
|
||||
} else if let Some(bin) = rest.strip_prefix('%') {
|
||||
i64::from_str_radix(bin, 2).ok()
|
||||
} else if rest.len() == 3 && rest.as_bytes()[0] == b'\'' && rest.as_bytes()[2] == b'\'' {
|
||||
// Character literal: 'x' → ASCII value of x
|
||||
Some(rest.as_bytes()[1] as i64)
|
||||
} else {
|
||||
i64::from_str_radix(rest, self.base).ok()
|
||||
// Character literal: 'x' → ASCII value of x. No digits, so DPL stays
|
||||
// at its seed and the result is always single-cell.
|
||||
if rest.len() == 3 && rest.as_bytes()[0] == b'\'' && rest.as_bytes()[2] == b'\'' {
|
||||
let value = i64::from(rest.as_bytes()[1]);
|
||||
return Some(NumberLiteral {
|
||||
value: if neg_outer { -value } else { value },
|
||||
dpl: DPL_INIT,
|
||||
is_double: false,
|
||||
});
|
||||
}
|
||||
|
||||
// A base-override prefix sits before the leftmost digit.
|
||||
let (radix, after_prefix) = match rest.as_bytes()[0] {
|
||||
b'$' => (16, &rest[1..]),
|
||||
b'#' => (10, &rest[1..]),
|
||||
b'%' => (2, &rest[1..]),
|
||||
_ => (self.base, rest),
|
||||
};
|
||||
|
||||
result.map(|n| if negative { -(n as i32) } else { n as i32 })
|
||||
// Forth 2012 spells a signed based number `#-1289`, so the sign can
|
||||
// also follow the prefix. Either way it precedes the leftmost digit
|
||||
// and so is a sign rather than double punctuation.
|
||||
let (neg_inner, digits) = strip_sign(after_prefix);
|
||||
let negative = neg_outer ^ neg_inner;
|
||||
|
||||
if digits.is_empty() {
|
||||
return None;
|
||||
}
|
||||
|
||||
// Walk the digit string, stripping punctuation and tracking DPL.
|
||||
let mut buf = String::with_capacity(digits.len());
|
||||
let mut dpl = DPL_INIT;
|
||||
let mut is_double = false;
|
||||
for &b in digits.as_bytes() {
|
||||
if DOUBLE_PUNCTUATION.contains(&b) {
|
||||
is_double = true;
|
||||
dpl = 0;
|
||||
} else {
|
||||
buf.push(char::from(b));
|
||||
dpl += 1;
|
||||
}
|
||||
}
|
||||
|
||||
if buf.is_empty() {
|
||||
return None;
|
||||
}
|
||||
|
||||
// i128 accumulation so the full u64 range survives conversion.
|
||||
let magnitude = i128::from_str_radix(&buf, radix).ok()?;
|
||||
let value = if negative {
|
||||
-(magnitude as i64)
|
||||
} else {
|
||||
magnitude as i64
|
||||
};
|
||||
|
||||
Some(NumberLiteral {
|
||||
value,
|
||||
dpl,
|
||||
is_double,
|
||||
})
|
||||
}
|
||||
|
||||
/// Try to parse a token as a double-number (token ends with `.`).
|
||||
/// Returns (lo, hi) where the double-cell value is (hi << 32) | lo.
|
||||
fn parse_double_number(&self, token: &str) -> Option<(i32, i32)> {
|
||||
let token = token.trim();
|
||||
if token.is_empty() {
|
||||
return None;
|
||||
/// Publish the outcome of a conversion in `DPL` and `NH`.
|
||||
///
|
||||
/// `NH` only carries meaning after a single-cell conversion, where it holds
|
||||
/// the high-order cell that the stack result dropped.
|
||||
fn record_number_conversion(&mut self, lit: NumberLiteral) {
|
||||
self.rt.mem_write_i32(SYSVAR_DPL, lit.dpl);
|
||||
if !lit.is_double {
|
||||
self.rt.mem_write_i32(SYSVAR_NH, lit.hi());
|
||||
}
|
||||
}
|
||||
|
||||
// Check for trailing dot (double-number indicator)
|
||||
let without_dot = token.strip_suffix('.')?;
|
||||
if without_dot.is_empty() {
|
||||
return None;
|
||||
}
|
||||
|
||||
// Check for negative prefix
|
||||
let (negative, rest) = if let Some(stripped) = without_dot.strip_prefix('-') {
|
||||
(true, stripped)
|
||||
} else {
|
||||
(false, without_dot)
|
||||
};
|
||||
|
||||
if rest.is_empty() {
|
||||
return None;
|
||||
}
|
||||
|
||||
// Parse based on prefix -- use i128 to handle the full u64 range
|
||||
let result: Option<i128> = if let Some(hex) = rest.strip_prefix('$') {
|
||||
i128::from_str_radix(hex, 16).ok()
|
||||
} else if let Some(dec) = rest.strip_prefix('#') {
|
||||
dec.parse::<i128>().ok()
|
||||
} else if let Some(bin) = rest.strip_prefix('%') {
|
||||
i128::from_str_radix(bin, 2).ok()
|
||||
} else {
|
||||
i128::from_str_radix(rest, self.base).ok()
|
||||
};
|
||||
|
||||
result.map(|n| {
|
||||
let val: i64 = if negative { -(n as i64) } else { n as i64 };
|
||||
let lo = val as i32;
|
||||
let hi = (val >> 32) as i32;
|
||||
(lo, hi)
|
||||
})
|
||||
/// Try to parse a token as a single-cell number, ignoring `DPL`/`NH`.
|
||||
/// Used where only a plain cell value is meaningful.
|
||||
fn parse_number(&self, token: &str) -> Option<i32> {
|
||||
self.parse_numeric_literal(token)
|
||||
.filter(|lit| !lit.is_double)
|
||||
.map(NumberLiteral::lo)
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------
|
||||
@@ -3092,6 +3163,7 @@ impl<R: Runtime> ForthVM<R> {
|
||||
self.register_to_in()?;
|
||||
self.register_state_var()?;
|
||||
self.register_base_var()?;
|
||||
self.register_number_conversion_vars()?;
|
||||
|
||||
// Double-cell arithmetic
|
||||
self.register_m_star()?;
|
||||
@@ -5151,6 +5223,22 @@ impl<R: Runtime> ForthVM<R> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// DPL ( -- addr ) and NH ( -- addr ): input number conversion results.
|
||||
///
|
||||
/// `DPL` holds the digit count right of the rightmost punctuation
|
||||
/// character in the last converted number, or a negative value when the
|
||||
/// token carried none. `NH` holds the high-order cell dropped by a
|
||||
/// single-cell conversion, so an out-of-range token can be recovered as a
|
||||
/// double.
|
||||
fn register_number_conversion_vars(&mut self) -> anyhow::Result<()> {
|
||||
self.rt.mem_write_i32(SYSVAR_DPL, DPL_INIT);
|
||||
self.rt.mem_write_i32(SYSVAR_NH, 0);
|
||||
|
||||
self.register_primitive("DPL", false, vec![IrOp::PushI32(SYSVAR_DPL as i32)])?;
|
||||
self.register_primitive("NH", false, vec![IrOp::PushI32(SYSVAR_NH as i32)])?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// M* ( n1 n2 -- d ) signed multiply producing double-cell result.
|
||||
fn register_m_star(&mut self) -> anyhow::Result<()> {
|
||||
let func: HostFn = Box::new(move |ctx: &mut dyn HostAccess| {
|
||||
@@ -10828,6 +10916,111 @@ mod tests {
|
||||
assert_eq!(eval_stack("1E 2.5E 1E F~"), vec![0]); // |1-2.5| = 1.5 >= 1
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn punctuation_anywhere_converts_as_double() {
|
||||
// The punctuation is a double-cell marker, not a fractional point:
|
||||
// every form below carries the same digits, so the value is the same.
|
||||
// eval_stack reports top-first, so a double reads as [hi, lo].
|
||||
for token in ["1234.", "123.4", "12.34", "1.234", ".1234"] {
|
||||
assert_eq!(eval_stack(token), vec![0, 1234], "token {token}");
|
||||
}
|
||||
// SwiftForth accepts comma, colon, slash, plus and dash too, which is
|
||||
// what makes dates and times convert without a custom parser.
|
||||
assert_eq!(eval_stack("1,234"), vec![0, 1234]);
|
||||
assert_eq!(eval_stack("12:30:45"), vec![0, 123045]);
|
||||
assert_eq!(eval_stack("2026-08-06"), vec![0, 20260806]);
|
||||
assert_eq!(eval_stack("12/34"), vec![0, 1234]);
|
||||
assert_eq!(eval_stack("1+234"), vec![0, 1234]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dpl_counts_digits_right_of_last_punctuation() {
|
||||
for (token, dpl) in [("1234.", 0), ("123.4", 1), ("12.34", 2), (".1234", 4)] {
|
||||
assert_eq!(eval_stack(&format!("{token} 2DROP DPL @")), vec![dpl]);
|
||||
}
|
||||
// Only the rightmost punctuation counts.
|
||||
assert_eq!(eval_stack("12:30:45 2DROP DPL @"), vec![2]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dpl_stays_negative_for_unpunctuated_numbers() {
|
||||
// A leading minus is a sign, not punctuation, so these stay single-cell.
|
||||
for token in ["1234", "-1", "$FF"] {
|
||||
let dpl = eval_stack(&format!("{token} DROP DPL @"))[0];
|
||||
assert!(dpl < 0, "token {token} left DPL = {dpl}");
|
||||
}
|
||||
assert_eq!(eval_stack("-1"), vec![-1]);
|
||||
// DPL counts up from its seed once per digit.
|
||||
assert_eq!(eval_stack("1234 DROP DPL @"), vec![DPL_INIT + 4]);
|
||||
assert_eq!(eval_stack("-1 DROP DPL @"), vec![DPL_INIT + 1]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn leading_plus_is_punctuation_not_a_sign() {
|
||||
// sf64 converts `+7` as the double 7 with DPL = 1: unlike `-`, a
|
||||
// leading `+` does not bind to the number.
|
||||
assert_eq!(eval_stack("+7"), vec![0, 7]);
|
||||
assert_eq!(eval_stack("+7 2DROP DPL @"), vec![1]);
|
||||
// Same after a base prefix.
|
||||
assert_eq!(eval_stack("#+7"), vec![0, 7]);
|
||||
assert_eq!(eval_stack("$+F"), vec![0, 15]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn repeated_punctuation_only_counts_from_the_last_one() {
|
||||
// sf64: `12..34` is 1234 with DPL 2, `1-2-3` is 123 with DPL 1.
|
||||
assert_eq!(eval_stack("12..34"), vec![0, 1234]);
|
||||
assert_eq!(eval_stack("12..34 2DROP DPL @"), vec![2]);
|
||||
assert_eq!(eval_stack("1-2-3"), vec![0, 123]);
|
||||
assert_eq!(eval_stack("1-2-3 2DROP DPL @"), vec![1]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn nh_recovers_an_out_of_range_single_number() {
|
||||
// 4000000000 overflows a signed cell, so the stack value is truncated.
|
||||
assert_eq!(eval_stack("4000000000"), vec![-294967296]);
|
||||
// NH carries the high cell, making the true value recoverable.
|
||||
assert_eq!(eval_stack("4000000000 NH @"), vec![0, -294967296]);
|
||||
assert_eq!(eval_output("4000000000 NH @ D."), "4000000000 ");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn float_literals_still_win_over_double_punctuation() {
|
||||
// `1.5E0` has an embedded dot, but "15E0" is not a decimal number,
|
||||
// so conversion falls through to the float parser.
|
||||
assert_eq!(eval_output("1.5E0 F."), "1.500000 ");
|
||||
assert_eq!(eval_output("-3.25E0 F."), "-3.250000 ");
|
||||
assert_eq!(eval_output("1E-3 F."), "0.001000 ");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn double_punctuation_respects_base_prefixes() {
|
||||
assert_eq!(eval_stack("$FF."), vec![0, 255]);
|
||||
assert_eq!(eval_stack("$F.F"), vec![0, 255]);
|
||||
assert_eq!(eval_stack("%1010."), vec![0, 10]);
|
||||
assert_eq!(eval_stack("#12.34"), vec![0, 1234]);
|
||||
assert_eq!(eval_stack("-$FF."), vec![-1, -255]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sign_after_a_base_prefix_is_a_sign_not_punctuation() {
|
||||
// Forth 2012 spells signed based numbers with the sign after the
|
||||
// prefix. The dash precedes the leftmost digit, so it must not
|
||||
// trigger double-cell conversion.
|
||||
assert_eq!(eval_stack("#-1289"), vec![-1289]);
|
||||
assert_eq!(eval_stack("$-12eF"), vec![-4847]);
|
||||
assert_eq!(eval_stack("%-10010110"), vec![-150]);
|
||||
// The sign may also precede the prefix, and both spellings cancel.
|
||||
assert_eq!(eval_stack("-$FF"), vec![-255]);
|
||||
assert_eq!(eval_stack("-$-FF"), vec![255]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn punctuated_numbers_compile_into_definitions() {
|
||||
assert_eq!(eval_stack(": D1 12.34 ; D1"), vec![0, 1234]);
|
||||
assert_eq!(eval_output(": STAMP 2026-08-06 D. ; STAMP"), "20260806 ");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn optimizer_doesnt_break_basic_arithmetic() {
|
||||
assert_eq!(eval_stack("5 3 +"), vec![8]);
|
||||
|
||||
@@ -350,6 +350,16 @@ pub const WORD_DOCS: &[(&str, &str, &str)] = &[
|
||||
"Convert digits, accumulating into ud.",
|
||||
),
|
||||
("BASE", "( -- addr )", "Variable holding the number base."),
|
||||
(
|
||||
"DPL",
|
||||
"( -- addr )",
|
||||
"Variable: digits right of the last punctuation; negative if none.",
|
||||
),
|
||||
(
|
||||
"NH",
|
||||
"( -- addr )",
|
||||
"Variable: high cell dropped by the last single-cell conversion.",
|
||||
),
|
||||
("HEX", "( -- )", "Set BASE to sixteen."),
|
||||
("DECIMAL", "( -- )", "Set BASE to ten."),
|
||||
// -- Core: strings --
|
||||
|
||||
@@ -12,7 +12,7 @@ workspace = true
|
||||
crate-type = ["cdylib", "rlib"]
|
||||
|
||||
[dependencies]
|
||||
wafer-core = { path = "../core", version = "0.2.1", default-features = false, features = ["crypto"] }
|
||||
wafer-core = { path = "../core", version = "0.2.4", default-features = false, features = ["crypto"] }
|
||||
wasm-bindgen = "0.2"
|
||||
js-sys = "0.3"
|
||||
send_wrapper = { workspace = true }
|
||||
|
||||
@@ -38,6 +38,23 @@ impl WebHostAccess {
|
||||
}
|
||||
}
|
||||
|
||||
/// An exception on its way back out of compiled code. Host words rethrow the
|
||||
/// Forth message (`Stack underflow`, an `ABORT"` text, a `THROW` description),
|
||||
/// so surface exactly that and nothing else — the JS `Error` carries the whole
|
||||
/// engine stack in its message, which is noise to a Forth programmer. Anything
|
||||
/// without a message is a genuine runtime fault and keeps the call context.
|
||||
fn call_error(fn_index: u32, e: &JsValue) -> anyhow::Error {
|
||||
match Reflect::get(e, &"message".into())
|
||||
.ok()
|
||||
.and_then(|m| m.as_string())
|
||||
.and_then(|m| m.lines().next().map(str::trim).map(str::to_string))
|
||||
.filter(|m| !m.is_empty())
|
||||
{
|
||||
Some(msg) => anyhow::anyhow!("{msg}"),
|
||||
None => anyhow::anyhow!("call_func({fn_index}) failed: {e:?}"),
|
||||
}
|
||||
}
|
||||
|
||||
impl HostAccess for WebHostAccess {
|
||||
fn mem_read_i32(&mut self, addr: u32) -> i32 {
|
||||
let view = js_sys::Int32Array::new(&self.buffer());
|
||||
@@ -134,7 +151,7 @@ impl HostAccess for WebHostAccess {
|
||||
.dyn_into()
|
||||
.map_err(|_| anyhow::anyhow!("table entry {fn_index} is not a function"))?;
|
||||
func.call0(&JsValue::NULL)
|
||||
.map_err(|e| anyhow::anyhow!("call_func({fn_index}) failed: {e:?}"))?;
|
||||
.map_err(|e| call_error(fn_index, &e))?;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
@@ -406,7 +423,7 @@ impl Runtime for WebRuntime {
|
||||
.dyn_into()
|
||||
.map_err(|_| anyhow::anyhow!("table entry {fn_index} is not callable"))?;
|
||||
func.call0(&JsValue::NULL)
|
||||
.map_err(|e| anyhow::anyhow!("call_func({fn_index}) failed: {e:?}"))?;
|
||||
.map_err(|e| call_error(fn_index, &e))?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
|
||||
@@ -18,11 +18,11 @@ confidence-threshold = 0.8
|
||||
[bans]
|
||||
multiple-versions = "deny"
|
||||
wildcards = "deny"
|
||||
# Transitive duplicates from wasmtime v31 -- will resolve when upgrading
|
||||
# Transitive duplicates from wasmtime v47 dependencies
|
||||
skip = [
|
||||
"getrandom",
|
||||
"syn",
|
||||
"hashbrown",
|
||||
"r-efi",
|
||||
"thiserror",
|
||||
"thiserror-impl",
|
||||
"wasm-encoder",
|
||||
|
||||
Reference in New Issue
Block a user