multi-base output/programmer edit mode/operator changes
This commit is contained in:
parent
bb967e54e8
commit
51b63b4fb8
GPG key ID:
A7B62D657EF764F8
12 changed files with 544 additions and 100 deletions
|
|
@ -148,19 +148,26 @@ Precedence table (low -> high):
|
|||
|
||||
| Level | Operators |
|
||||
|-------|-----------|
|
||||
| 1 | `\|` (bitwise OR) |
|
||||
| 2 | `^` (bitwise XOR) - context-dependent, see below |
|
||||
| 3 | `&` (bitwise AND) |
|
||||
| 1 | `\|` (OR), `or` |
|
||||
| 2 | `xor` (XOR keyword) |
|
||||
| 3 | `&` (AND), `and` |
|
||||
| 4 | `<<`, `>>`, `>>>`, `rol`, `ror` |
|
||||
| 5 | `+`, `-` |
|
||||
| 6 | `*`, `/`, `%` |
|
||||
| 7 | `**` or `^` (exponentiation - standard mode) |
|
||||
| 8 | Unary `-`, `~` (bitwise NOT) |
|
||||
| 7 | `^`, `**` (exponentiation, always) |
|
||||
| 8 | Unary `-`, `~` (NOT), `not` |
|
||||
| 9 | Function calls, parentheses |
|
||||
|
||||
**Context-dependent `^`**: In standard mode, `^` means exponentiation. In programmer mode, `^` means XOR. The parser accepts a mode parameter to resolve this. Programmer mode uses `**` for exponentiation if needed.
|
||||
**`^` is always exponentiation.** There is no mode-dependent operator
|
||||
overloading. XOR is a keyword (`xor`), consistent with the existing
|
||||
`rol`/`ror` keyword operators. Bitwise ops have both symbolic and
|
||||
keyword forms: `&`/`and`, `|`/`or`, `~`/`not`. XOR is keyword-only
|
||||
(`xor`) since `^` is reserved for power. Every operator means the same
|
||||
thing in standard and programmer modes.
|
||||
|
||||
**Implicit multiplication**: The tokenizer detects adjacency patterns (number-identifier, number-paren, paren-paren) and inserts a synthetic `*` token.
|
||||
**No implicit multiplication**: adjacency (e.g. `2pi`) is an error;
|
||||
use explicit `*`. Spaces within hex/oct/bin literals are separators
|
||||
(e.g. `0xFF FF`).
|
||||
|
||||
### 2.5 Evaluation
|
||||
|
||||
|
|
@ -1045,7 +1052,7 @@ All engine functions return `CalcError!Result`. Frontends translate these into u
|
|||
| 4 | Separate parser for struct DSL | Struct grammar is different enough from expressions; keeps both parsers simple |
|
||||
| 5 | ABI as interface/vtable | Adding Windows x64 or ARM is implementing one struct; no changes to layout algorithm |
|
||||
| 6 | libvaxis for TUI | Most mature Zig TUI; supports Windows/Mac/Linux; active development; used by Ghostty |
|
||||
| 7 | Mode as parser parameter | Resolves `^` ambiguity (power vs XOR) at parse time rather than eval time |
|
||||
| 7 | `^` always means power; XOR is the `xor` keyword | Avoids mode-dependent operator overloading; every operator means the same thing in both modes; consistent with existing `rol`/`ror` keyword operators |
|
||||
| 8 | Statically-linked desktop binaries | Zero dependencies for end user; Zig makes this trivial |
|
||||
| 9 | Unit conversion via base-unit normalization | Simple to implement, easy to extend; only temperature needs special case (offset) |
|
||||
| 10 | Android: button grids, not text prompts | Touch-first UX; no keyboard needed for basic use; purpose-built surfaces per mode beat a generic expression prompt |
|
||||
|
|
|
|||
|
|
@ -18,13 +18,15 @@ A calculator application with three frontends (CLI, TUI, Android) sharing a comm
|
|||
- **FR-1.6**: Support variable storage (Ans for last result, named variables A-F, X, Y, Z).
|
||||
- **FR-1.7**: Maintain calculation history with replay capability.
|
||||
- **FR-1.8**: Commas accepted as digit separators in input (e.g., `1,000 * 2` = 2000). Spaces in hex literals treated as byte separators (e.g., `0xFF FF` = 0xFFFF).
|
||||
- **FR-1.9**: When a standard-mode expression contains any non-decimal literal (hex `0x`, octal `0o`, or binary `0b`) and the result is a non-negative integer, enrich the result display with hex/octal/binary representations inline (without leaving standard mode). Uses the smallest standard bit width (8/16/32/64/128) that holds the value. This does not change the evaluation semantics (still f64 arithmetic, `^` is still power); it only augments the display. Fractional or negative results show decimal only.
|
||||
|
||||
### FR-2: Programmer Mode
|
||||
|
||||
- **FR-2.1**: Accept input in decimal, hexadecimal (`0x`), octal (`0o`), and binary (`0b`) formats.
|
||||
- **FR-2.2**: Simultaneously display results in all four bases (dec, hex, oct, bin).
|
||||
- **FR-2.3**: Support configurable bit widths: 8, 16, 32, 64, 128-bit.
|
||||
- **FR-2.4**: Support bitwise operators: AND (`&`), OR (`|`), XOR (`^`), NOT (`~`), left shift (`<<`), right shift (logical `>>>`), arithmetic right shift (`>>`), rotate left (`rol`), rotate right (`ror`).
|
||||
- **FR-2.4**: Support bitwise operators: AND (`&` or `and`), OR (`|` or `or`), XOR (`xor` keyword), NOT (`~` or `not`), left shift (`<<`), right shift (logical `>>>`), arithmetic right shift (`>>`), rotate left (`rol`), rotate right (`ror`). Note: `^` is always exponentiation (never XOR) - see FR-2.12.
|
||||
- **FR-2.12**: The `^` operator means exponentiation in all modes (never XOR). This avoids mode-dependent operator overloading. XOR is available only via the `xor` keyword. Power is also available via `**`. This keeps every operator's meaning identical across standard and programmer modes.
|
||||
- **FR-2.5**: Display both signed (two's complement) and unsigned interpretations of the current value.
|
||||
- **FR-2.6**: Visualize the bit pattern as a grid (integer.exposed style) - bits individually addressable/toggleable in TUI and Android.
|
||||
- **FR-2.7**: Quick toggle between base display formats via dedicated keyboard shortcuts (TUI).
|
||||
|
|
|
|||
|
|
@ -231,6 +231,19 @@ Subcommands deferred until Phase 2 engine work is done.
|
|||
- Variables persist across expressions (assignment + Ans)
|
||||
- Verify: can type expressions, see results, browse history
|
||||
|
||||
### Task 5.2.1: Inline multi-base result in standard mode [DONE]
|
||||
- Engine: added `evalStringInfo` returning value + `has_nondecimal_literal` flag
|
||||
(walks AST via `hasNonDecimalLiteral` to detect any hex/oct/bin number literal)
|
||||
- Added `BitWidth.smallestFor(value)` helper
|
||||
- CLI: when flag is true and result is a non-negative integer, shows hex/oct/bin below decimal
|
||||
- TUI: history entries carry optional `details` lines; drawHistory reworked to
|
||||
render variable-height entries (flat line list, newest anchored at bottom)
|
||||
- Uses smallest standard bit width that holds the value
|
||||
- Does NOT change evaluation (still f64, `^` still power) - display only
|
||||
- Fractional/negative results show decimal only
|
||||
- Verify: `0o777 - 0x0f` shows 496 plus hex/oct/bin; `3.14` decimal only;
|
||||
`2 + 2` decimal only; `0xFF / 2` = 127.5 decimal only
|
||||
|
||||
### Task 5.3: Implement programmer mode TUI view - expression & base display [PARTIAL]
|
||||
- Programmer mode accessible via Tab key
|
||||
- Multi-base result display (dec signed, unsigned, hex, oct, bin)
|
||||
|
|
@ -402,18 +415,23 @@ Subcommands deferred until Phase 2 engine work is done.
|
|||
|
||||
## Phase 7: Testing & Release
|
||||
|
||||
### Task 7.1: Comprehensive engine test suite [IN PROGRESS]
|
||||
- **Target: >= 80% line coverage on engine code** -- ACHIEVED: 97.71%
|
||||
- 187 unit tests passing across engine + CLI modules
|
||||
- Property-based tests for parser (roundtrip: parse -> format -> parse)
|
||||
- Known-answer tests for all financial functions (textbook values)
|
||||
- Unit conversion round-trip tests (convert A->B->A, verify precision)
|
||||
- Struct layout verification against `pahole` output for 20+ test structs
|
||||
- Fuzz testing for parser (random input shouldn't crash, should return error)
|
||||
- Edge cases: max values, min values, NaN, infinity, division by zero
|
||||
### Task 7.1: Comprehensive engine test suite [DONE]
|
||||
- **Target: >= 80% line coverage on engine code** -- ACHIEVED: 99.69% (1607/1612 lines)
|
||||
- 222 unit tests passing across engine + CLI modules (208 in the engine coverage run)
|
||||
- Tokenizer tests: all bases, underscores/commas/spaces separators, string literals,
|
||||
invalid/unrecognized characters, bare `<`/`>`, lone dot, huge-decimal float fallback
|
||||
- Parser tests: precedence/associativity, unary ops, function calls (incl. unmatched
|
||||
paren in args), keyword operators, assignment, error paths, infix-position identifier
|
||||
- Evaluator tests: arithmetic, precedence, functions, variables/Ans, string literals in
|
||||
standard mode (ASCII packing + non-ASCII rejection), zero/two/three-arg unknown fns, rand()
|
||||
- Programmer tests: bitwise/shift/rotate at all widths, two's-complement negation, ASCII
|
||||
literal packing + overflow, float-literal truncation, shift-amount >= width clamping
|
||||
- Formatter tests: all bases, all bit widths, scientific notation threshold boundaries
|
||||
- Coverage measured via `zig build coverage` (kcov-based)
|
||||
- Verify: coverage report shows >= 80% on engine modules
|
||||
- Remaining 5 uncovered lines are unreachable defensive branches (parser `tokenToBinaryOp`/
|
||||
`keywordBinaryOp` fallbacks, gated by `infixPrecedence`) and `or` short-circuits inside
|
||||
test assertions -- not worth contorting the code to reach
|
||||
- Verify: coverage report shows 99.69% on engine modules (well above the >= 80% gate)
|
||||
|
||||
### Task 7.2: Integration tests
|
||||
- CLI end-to-end tests (run binary, check stdout/stderr/exit code)
|
||||
|
|
|
|||
|
|
@ -21,6 +21,8 @@ pub const Parser = parser.Parser;
|
|||
pub const Expr = ast.Expr;
|
||||
pub const Environment = evaluator.Environment;
|
||||
pub const evalString = evaluator.evalString;
|
||||
pub const evalStringInfo = evaluator.evalStringInfo;
|
||||
pub const EvalInfo = evaluator.EvalInfo;
|
||||
pub const evalProgrammerString = programmer.evalProgrammerString;
|
||||
|
||||
test {
|
||||
|
|
|
|||
|
|
@ -237,15 +237,50 @@ fn factorial(n: u64) f64 {
|
|||
return result;
|
||||
}
|
||||
|
||||
/// Result of evaluation with metadata for display decisions.
|
||||
pub const EvalInfo = struct {
|
||||
value: f64,
|
||||
/// True if the expression contained any non-decimal literal (hex/oct/bin).
|
||||
has_nondecimal_literal: bool,
|
||||
};
|
||||
|
||||
/// High-level evaluate: parse a string and evaluate it.
|
||||
/// Updates env.ans on success.
|
||||
pub fn evalString(env: *Environment, allocator: Allocator, source: []const u8) CalcError!f64 {
|
||||
const info = try evalStringInfo(env, allocator, source);
|
||||
return info.value;
|
||||
}
|
||||
|
||||
/// Like evalString but returns metadata (whether the expression used
|
||||
/// non-decimal literals) so frontends can decide to show a multi-base view.
|
||||
pub fn evalStringInfo(env: *Environment, allocator: Allocator, source: []const u8) CalcError!EvalInfo {
|
||||
var p = Parser.init(allocator, source, env.mode);
|
||||
const expr = try p.parse();
|
||||
const result = try evaluate(env, expr);
|
||||
env.ans = result;
|
||||
env.history_len += 1;
|
||||
return result;
|
||||
return .{
|
||||
.value = result,
|
||||
.has_nondecimal_literal = hasNonDecimalLiteral(expr),
|
||||
};
|
||||
}
|
||||
|
||||
/// Walk an AST and report whether any number literal is non-decimal.
|
||||
fn hasNonDecimalLiteral(expr: *const Expr) bool {
|
||||
return switch (expr.*) {
|
||||
.number => |n| n.base != .decimal,
|
||||
.string_literal => false,
|
||||
.variable => false,
|
||||
.unary => |u| hasNonDecimalLiteral(u.operand),
|
||||
.binary => |b| hasNonDecimalLiteral(b.left) or hasNonDecimalLiteral(b.right),
|
||||
.call => |c| blk: {
|
||||
for (c.args) |arg| {
|
||||
if (hasNonDecimalLiteral(arg)) break :blk true;
|
||||
}
|
||||
break :blk false;
|
||||
},
|
||||
.assignment => |a| hasNonDecimalLiteral(a.value),
|
||||
};
|
||||
}
|
||||
|
||||
// -- Tests --
|
||||
|
|
@ -467,7 +502,7 @@ test "eval 2^32 - 1" {
|
|||
}
|
||||
|
||||
test "eval programmer XOR" {
|
||||
const result = try testEvalProgrammer("0xF ^ 0x3");
|
||||
const result = try testEvalProgrammer("0xF xor 0x3");
|
||||
try testing.expectEqual(@as(f64, 12.0), result);
|
||||
}
|
||||
|
||||
|
|
@ -548,3 +583,73 @@ test "eval acos" {
|
|||
const result = try testEval("acos(1)");
|
||||
try testing.expectApproxEqAbs(@as(f64, 0.0), result, 1e-10);
|
||||
}
|
||||
|
||||
test "evalStringInfo: detects hex literal" {
|
||||
var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
|
||||
defer _ = arena.deinit();
|
||||
const alloc = arena.allocator();
|
||||
var env = Environment.init(alloc, .standard);
|
||||
defer env.deinit();
|
||||
const info = try evalStringInfo(&env, alloc, "0o777 - 0x0f");
|
||||
try testing.expectEqual(@as(f64, 496.0), info.value);
|
||||
try testing.expect(info.has_nondecimal_literal);
|
||||
}
|
||||
|
||||
test "evalStringInfo: pure decimal has no nondecimal literal" {
|
||||
var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
|
||||
defer _ = arena.deinit();
|
||||
const alloc = arena.allocator();
|
||||
var env = Environment.init(alloc, .standard);
|
||||
defer env.deinit();
|
||||
const info = try evalStringInfo(&env, alloc, "2 + 2");
|
||||
try testing.expectEqual(@as(f64, 4.0), info.value);
|
||||
try testing.expect(!info.has_nondecimal_literal);
|
||||
}
|
||||
|
||||
test "evalStringInfo: binary literal detected in nested expr" {
|
||||
var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
|
||||
defer _ = arena.deinit();
|
||||
const alloc = arena.allocator();
|
||||
var env = Environment.init(alloc, .standard);
|
||||
defer env.deinit();
|
||||
const info = try evalStringInfo(&env, alloc, "sqrt(0b100) + 1");
|
||||
try testing.expect(info.has_nondecimal_literal);
|
||||
}
|
||||
|
||||
test "eval string literal in standard mode packs ASCII" {
|
||||
// 'A' -> 0x41 -> 65
|
||||
const result = try testEval("'A'");
|
||||
try testing.expectEqual(@as(f64, 65.0), result);
|
||||
}
|
||||
|
||||
test "eval string literal multi-char in standard mode" {
|
||||
// 'AB' -> 0x4142 -> 16706
|
||||
const result = try testEval("'AB'");
|
||||
try testing.expectEqual(@as(f64, 16706.0), result);
|
||||
}
|
||||
|
||||
test "eval string literal with non-ASCII byte errors" {
|
||||
// byte > 0x7F is rejected
|
||||
const result = testEval("'\x80'");
|
||||
try testing.expectError(CalcError.InvalidNumber, result);
|
||||
}
|
||||
|
||||
test "eval rand zero-arg function returns 0" {
|
||||
const result = try testEval("rand()");
|
||||
try testing.expectEqual(@as(f64, 0.0), result);
|
||||
}
|
||||
|
||||
test "eval unknown zero-arg function" {
|
||||
const result = testEval("bogus()");
|
||||
try testing.expectError(CalcError.UnknownFunction, result);
|
||||
}
|
||||
|
||||
test "eval unknown three-arg function" {
|
||||
const result = testEval("bogus(1, 2, 3)");
|
||||
try testing.expectError(CalcError.UnknownFunction, result);
|
||||
}
|
||||
|
||||
test "eval unknown two-arg function" {
|
||||
const result = testEval("bogus(1, 2)");
|
||||
try testing.expectError(CalcError.UnknownFunction, result);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3,10 +3,10 @@
|
|||
//! Uses top-down operator precedence (Pratt parsing) to convert a token
|
||||
//! stream into an AST. Handles:
|
||||
//! - Operator precedence and associativity
|
||||
//! - Unary prefix operators (-, ~)
|
||||
//! - Unary prefix operators (-, ~, not)
|
||||
//! - Function calls: identifier(args...)
|
||||
//! - Implicit multiplication: 2pi, 3(4+5), (2)(3)
|
||||
//! - Mode-dependent ^ (power in standard, XOR in programmer)
|
||||
//! - Keyword operators: and, or, xor, rol, ror
|
||||
//! - ^ and ** are always exponentiation (XOR is the `xor` keyword)
|
||||
//! - Variable assignment: X = expr
|
||||
|
||||
const std = @import("std");
|
||||
|
|
@ -28,15 +28,15 @@ const CalcError = types.CalcError;
|
|||
const Prec = enum(u8) {
|
||||
none = 0,
|
||||
assignment = 1, // =
|
||||
bit_or = 2, // |
|
||||
bit_xor = 3, // ^ (programmer mode)
|
||||
bit_and = 4, // &
|
||||
bit_or = 2, // | or
|
||||
bit_xor = 3, // xor
|
||||
bit_and = 4, // & and
|
||||
shift = 5, // << >> >>> rol ror
|
||||
additive = 6, // + -
|
||||
multiplicative = 7, // * / %
|
||||
power = 8, // ^ (standard mode) or **
|
||||
unary = 9, // - ~ (prefix)
|
||||
call = 10, // function calls, implicit mul
|
||||
power = 8, // ^ ** (always exponentiation)
|
||||
unary = 9, // - ~ not (prefix)
|
||||
call = 10, // function calls
|
||||
};
|
||||
|
||||
pub const Parser = struct {
|
||||
|
|
@ -115,6 +115,15 @@ pub const Parser = struct {
|
|||
self.advance();
|
||||
const name = tok.text(self.source);
|
||||
|
||||
// "not" prefix keyword = bitwise NOT
|
||||
if (std.mem.eql(u8, name, "not")) {
|
||||
const operand = try self.parseExpr(.unary);
|
||||
return self.makeNode(.{ .unary = .{
|
||||
.op = .bitwise_not,
|
||||
.operand = operand,
|
||||
} });
|
||||
}
|
||||
|
||||
// Check for assignment: identifier = expr
|
||||
if (self.current.kind == .equals) {
|
||||
self.advance();
|
||||
|
|
@ -207,12 +216,11 @@ pub const Parser = struct {
|
|||
fn parseInfix(self: *Parser, left: *Expr, prec: Prec) CalcError!*Expr {
|
||||
const tok = self.current;
|
||||
|
||||
// Handle keyword operators (rol, ror)
|
||||
// Handle keyword operators (rol, ror, and, or, xor)
|
||||
if (tok.kind == .identifier) {
|
||||
const name = tok.text(self.source);
|
||||
if (std.mem.eql(u8, name, "rol") or std.mem.eql(u8, name, "ror")) {
|
||||
if (keywordBinaryOp(name)) |op| {
|
||||
self.advance();
|
||||
const op: BinaryOp = if (std.mem.eql(u8, name, "rol")) .rotate_left else .rotate_right;
|
||||
const right = try self.parseExpr(prec);
|
||||
return self.makeNode(.{ .binary = .{
|
||||
.op = op,
|
||||
|
|
@ -243,46 +251,50 @@ pub const Parser = struct {
|
|||
} });
|
||||
}
|
||||
|
||||
/// Map a keyword identifier to a binary operator, if it is one.
|
||||
fn keywordBinaryOp(name: []const u8) ?BinaryOp {
|
||||
if (std.mem.eql(u8, name, "rol")) return .rotate_left;
|
||||
if (std.mem.eql(u8, name, "ror")) return .rotate_right;
|
||||
if (std.mem.eql(u8, name, "and")) return .bit_and;
|
||||
if (std.mem.eql(u8, name, "or")) return .bit_or;
|
||||
if (std.mem.eql(u8, name, "xor")) return .bit_xor;
|
||||
return null;
|
||||
}
|
||||
|
||||
/// Precedence of a keyword infix operator, if the name is one.
|
||||
fn keywordPrec(name: []const u8) ?Prec {
|
||||
if (std.mem.eql(u8, name, "rol") or std.mem.eql(u8, name, "ror")) return .shift;
|
||||
if (std.mem.eql(u8, name, "and")) return .bit_and;
|
||||
if (std.mem.eql(u8, name, "or")) return .bit_or;
|
||||
if (std.mem.eql(u8, name, "xor")) return .bit_xor;
|
||||
return null;
|
||||
}
|
||||
|
||||
/// Get the infix precedence of a token kind.
|
||||
fn infixPrecedence(self: *Parser, kind: TokenKind) Prec {
|
||||
return switch (kind) {
|
||||
.pipe => .bit_or,
|
||||
.caret => if (self.mode == .programmer) .bit_xor else .power,
|
||||
.caret => .power, // always exponentiation
|
||||
.ampersand => .bit_and,
|
||||
.shift_left, .shift_right, .shift_right_logical => .shift,
|
||||
.plus, .minus => .additive,
|
||||
.star, .slash, .percent => .multiplicative,
|
||||
.star_star => .power,
|
||||
.identifier => blk: {
|
||||
// "rol" and "ror" are infix keyword operators at shift precedence
|
||||
const name = self.currentText(kind);
|
||||
if (name != null) {
|
||||
if (std.mem.eql(u8, name.?, "rol") or std.mem.eql(u8, name.?, "ror")) {
|
||||
break :blk .shift;
|
||||
}
|
||||
}
|
||||
break :blk .none;
|
||||
},
|
||||
.identifier => keywordPrec(self.current.text(self.source)) orelse .none,
|
||||
else => .none,
|
||||
};
|
||||
}
|
||||
|
||||
fn currentText(self: *Parser, kind: TokenKind) ?[]const u8 {
|
||||
if (kind == .identifier) {
|
||||
return self.current.text(self.source);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/// Map a token kind to a binary operator.
|
||||
fn tokenToBinaryOp(self: *Parser, kind: TokenKind) ?BinaryOp {
|
||||
_ = self;
|
||||
return switch (kind) {
|
||||
.plus => .add,
|
||||
.minus => .sub,
|
||||
.star => .mul,
|
||||
.slash => .div,
|
||||
.percent => .mod,
|
||||
.caret => if (self.mode == .programmer) .bit_xor else .pow,
|
||||
.caret => .pow, // always exponentiation
|
||||
.star_star => .pow,
|
||||
.ampersand => .bit_and,
|
||||
.pipe => .bit_or,
|
||||
|
|
@ -453,12 +465,36 @@ test "parse adjacent paren paren is an error (no implicit mul)" {
|
|||
try testing.expectError(CalcError.UnexpectedToken, result);
|
||||
}
|
||||
|
||||
test "parse caret as XOR in programmer mode" {
|
||||
test "parse caret is power in programmer mode (not XOR)" {
|
||||
const expr = try testParse("0xF ^ 0x3", .programmer);
|
||||
defer freeExpr(testing.allocator, expr);
|
||||
try testing.expectEqual(BinaryOp.pow, expr.binary.op);
|
||||
}
|
||||
|
||||
test "parse xor keyword is XOR" {
|
||||
const expr = try testParse("0xF xor 0x3", .programmer);
|
||||
defer freeExpr(testing.allocator, expr);
|
||||
try testing.expectEqual(BinaryOp.bit_xor, expr.binary.op);
|
||||
}
|
||||
|
||||
test "parse and keyword" {
|
||||
const expr = try testParse("0xF and 0x3", .programmer);
|
||||
defer freeExpr(testing.allocator, expr);
|
||||
try testing.expectEqual(BinaryOp.bit_and, expr.binary.op);
|
||||
}
|
||||
|
||||
test "parse or keyword" {
|
||||
const expr = try testParse("0xF or 0x3", .programmer);
|
||||
defer freeExpr(testing.allocator, expr);
|
||||
try testing.expectEqual(BinaryOp.bit_or, expr.binary.op);
|
||||
}
|
||||
|
||||
test "parse not prefix keyword" {
|
||||
const expr = try testParse("not 0xFF", .programmer);
|
||||
defer freeExpr(testing.allocator, expr);
|
||||
try testing.expectEqual(UnaryOp.bitwise_not, expr.unary.op);
|
||||
}
|
||||
|
||||
test "parse caret as power in standard mode" {
|
||||
const expr = try testParse("2 ^ 10", .standard);
|
||||
defer freeExpr(testing.allocator, expr);
|
||||
|
|
@ -526,3 +562,18 @@ test "parse nested function calls" {
|
|||
try testing.expectEqualStrings("sin", expr.call.args[0].call.name);
|
||||
try testing.expectEqualStrings("cos", expr.call.args[1].call.name);
|
||||
}
|
||||
|
||||
test "parse error: unmatched paren in function call args" {
|
||||
defer _ = test_arena_instance.reset(.retain_capacity);
|
||||
const result = testParseArena("max(1, 2", .standard);
|
||||
try testing.expectError(CalcError.UnmatchedParen, result);
|
||||
}
|
||||
|
||||
test "parse error: identifier in infix position (not a keyword op)" {
|
||||
// "5 foo": 5 parses as prefix, then foo is an identifier that is not
|
||||
// a keyword operator, so it has .none precedence. The loop stops and
|
||||
// parse() reports the leftover token as unexpected.
|
||||
defer _ = test_arena_instance.reset(.retain_capacity);
|
||||
const result = testParseArena("5 foo", .standard);
|
||||
try testing.expectError(CalcError.UnexpectedToken, result);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -33,11 +33,9 @@ fn evalExpr(config: ProgrammerConfig, expr: *const Expr) CalcError!u128 {
|
|||
if (n.int_value) |int_val| {
|
||||
return int_val & config.bit_width.mask();
|
||||
}
|
||||
// Float in programmer mode: truncate to integer
|
||||
if (n.float_value < 0) {
|
||||
const neg: i128 = @intFromFloat(n.float_value);
|
||||
return @as(u128, @bitCast(neg)) & config.bit_width.mask();
|
||||
}
|
||||
// Float literal in programmer mode: truncate to integer.
|
||||
// (Number literals are always non-negative; unary minus is a
|
||||
// separate operator handled below.)
|
||||
const val: u128 = @intFromFloat(n.float_value);
|
||||
return val & config.bit_width.mask();
|
||||
},
|
||||
|
|
@ -251,10 +249,25 @@ test "prog: bitwise OR" {
|
|||
}
|
||||
|
||||
test "prog: bitwise XOR" {
|
||||
const result = try testProg("0xFF ^ 0x0F");
|
||||
const result = try testProg("0xFF xor 0x0F");
|
||||
try testing.expectEqual(@as(u128, 0xF0), result.unsignedValue());
|
||||
}
|
||||
|
||||
test "prog: caret is power not XOR" {
|
||||
// 0x2 ^ 0x3 = 2^3 = 8 (power), NOT 1 (XOR)
|
||||
const result = try testProg("0x2 ^ 0x3");
|
||||
try testing.expectEqual(@as(u128, 8), result.unsignedValue());
|
||||
}
|
||||
|
||||
test "prog: and/or/not keywords" {
|
||||
const a = try testProg("0xFF and 0x0F");
|
||||
try testing.expectEqual(@as(u128, 0x0F), a.unsignedValue());
|
||||
const o = try testProg("0xF0 or 0x0F");
|
||||
try testing.expectEqual(@as(u128, 0xFF), o.unsignedValue());
|
||||
const n = try testProgWith("not 0x0F", .{ .bit_width = .bits8 });
|
||||
try testing.expectEqual(@as(u128, 0xF0), n.unsignedValue());
|
||||
}
|
||||
|
||||
test "prog: bitwise NOT 8-bit" {
|
||||
const result = try testProgWith("~0x0F", .{ .bit_width = .bits8 });
|
||||
try testing.expectEqual(@as(u128, 0xF0), result.unsignedValue());
|
||||
|
|
@ -410,3 +423,28 @@ test "prog: ASCII literal overflow 8-bit" {
|
|||
const result = evalProgrammerString(arena.allocator(), "'AB'", .{ .bit_width = .bits8 });
|
||||
try testing.expectError(CalcError.Overflow, result);
|
||||
}
|
||||
|
||||
test "prog: float literal truncates to integer" {
|
||||
// 3.14 has no int_value, so the float branch truncates to 3
|
||||
const result = try testProg("3.14");
|
||||
try testing.expectEqual(@as(u128, 3), result.unsignedValue());
|
||||
}
|
||||
|
||||
test "prog: arithmetic shift right amount >= width clamps" {
|
||||
// 0xFF in 8-bit is negative; >> 20 clamps shift to width-1 (7),
|
||||
// arithmetic shift fills with sign bit -> stays 0xFF
|
||||
const result = try testProgWith("0xFF >> 20", .{ .bit_width = .bits8 });
|
||||
try testing.expectEqual(@as(u128, 0xFF), result.unsignedValue());
|
||||
}
|
||||
|
||||
test "prog: logical shift right amount >= width clamps" {
|
||||
// 0xFF in 8-bit; >>> 20 clamps shift to width-1 (7) -> 0x01
|
||||
const result = try testProgWith("0xFF >>> 20", .{ .bit_width = .bits8 });
|
||||
try testing.expectEqual(@as(u128, 0x01), result.unsignedValue());
|
||||
}
|
||||
|
||||
test "prog: arithmetic shift right amount >= width positive value" {
|
||||
// 0x40 in 8-bit is positive; >> 20 clamps to 7 -> 0
|
||||
const result = try testProgWith("0x40 >> 20", .{ .bit_width = .bits8 });
|
||||
try testing.expectEqual(@as(u128, 0), result.unsignedValue());
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2,10 +2,8 @@
|
|||
//!
|
||||
//! Converts an input string into a sequence of tokens for the parser.
|
||||
//! Supports multiple number bases (decimal, hex 0x, octal 0o, binary 0b),
|
||||
//! operators, identifiers (functions/variables), and implicit multiplication.
|
||||
//!
|
||||
//! The `TokenStream` wraps the raw `Tokenizer` and inserts synthetic `star`
|
||||
//! tokens for implicit multiplication (e.g. `2pi`, `3(4+5)`, `)(` ).
|
||||
//! operators, identifiers (functions/variables), single-quoted ASCII string
|
||||
//! literals, and space/comma/underscore digit separators.
|
||||
|
||||
const std = @import("std");
|
||||
const types = @import("types.zig");
|
||||
|
|
@ -243,12 +241,12 @@ pub const Tokenizer = struct {
|
|||
switch (next_ch) {
|
||||
'x', 'X' => {
|
||||
self.pos += 2;
|
||||
self.consumeHexDigits();
|
||||
self.consumeBaseDigits(isHexDigit);
|
||||
return .{ .kind = .number, .start = start, .len = self.pos - start };
|
||||
},
|
||||
'o', 'O' => {
|
||||
self.pos += 2;
|
||||
self.consumeDigits(isOctalDigit);
|
||||
self.consumeBaseDigits(isOctalDigit);
|
||||
return .{ .kind = .number, .start = start, .len = self.pos - start };
|
||||
},
|
||||
'b', 'B' => {
|
||||
|
|
@ -257,7 +255,7 @@ pub const Tokenizer = struct {
|
|||
(self.source[self.pos + 2] == '0' or self.source[self.pos + 2] == '1'))
|
||||
{
|
||||
self.pos += 2;
|
||||
self.consumeDigits(isBinaryDigit);
|
||||
self.consumeBaseDigits(isBinaryDigit);
|
||||
return .{ .kind = .number, .start = start, .len = self.pos - start };
|
||||
}
|
||||
// Otherwise fall through to decimal
|
||||
|
|
@ -276,10 +274,6 @@ pub const Tokenizer = struct {
|
|||
{
|
||||
self.pos += 1; // consume '.'
|
||||
self.consumeDigits(isDecDigit);
|
||||
} else if (self.source[start] == '.') {
|
||||
// Number started with '.', e.g. ".5"
|
||||
self.pos += 1;
|
||||
self.consumeDigits(isDecDigit);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -321,19 +315,25 @@ pub const Tokenizer = struct {
|
|||
}
|
||||
}
|
||||
|
||||
/// Like consumeDigits but also treats spaces as byte separators.
|
||||
/// Only used for hex literals (0x...) where "FF FF FF" is valid input.
|
||||
fn consumeHexDigits(self: *Tokenizer) void {
|
||||
/// Like consumeDigits but also treats spaces as separators (only when the
|
||||
/// space is followed by a run of valid digits, so "0xFF + 1" stops at the
|
||||
/// space and "0xFF and 1" is not swallowed - "and" has a non-hex letter).
|
||||
/// Used for hex/oct/bin literals which display with space grouping.
|
||||
fn consumeBaseDigits(self: *Tokenizer, predicate: *const fn (u8) bool) void {
|
||||
while (self.pos < self.source.len) {
|
||||
const ch = self.source[self.pos];
|
||||
if (isHexDigit(ch)) {
|
||||
if (predicate(ch)) {
|
||||
self.pos += 1;
|
||||
} else if (ch == '_') {
|
||||
self.pos += 1;
|
||||
} else if (ch == ' ') {
|
||||
// Space in hex: only consume if followed by a hex digit
|
||||
// (to avoid eating the space before an operator like "0xFF + 1")
|
||||
if (self.pos + 1 < self.source.len and isHexDigit(self.source[self.pos + 1])) {
|
||||
if (self.spaceContinuesNumber(predicate)) {
|
||||
self.pos += 1;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
} else if (ch == ',') {
|
||||
if (self.pos + 1 < self.source.len and predicate(self.source[self.pos + 1])) {
|
||||
self.pos += 1;
|
||||
} else {
|
||||
break;
|
||||
|
|
@ -344,6 +344,25 @@ pub const Tokenizer = struct {
|
|||
}
|
||||
}
|
||||
|
||||
/// After a space inside a base literal, decide whether the following text
|
||||
/// is another digit group (continue the number) or a word like a keyword
|
||||
/// operator (stop the number). Returns true only if the maximal
|
||||
/// identifier-run right after the space consists entirely of valid digits.
|
||||
fn spaceContinuesNumber(self: *Tokenizer, predicate: *const fn (u8) bool) bool {
|
||||
var j = self.pos + 1;
|
||||
var saw_any = false;
|
||||
while (j < self.source.len and isIdentChar(self.source[j])) : (j += 1) {
|
||||
if (!predicate(self.source[j])) return false;
|
||||
saw_any = true;
|
||||
}
|
||||
return saw_any;
|
||||
}
|
||||
|
||||
fn isIdentChar(c: u8) bool {
|
||||
return (c >= 'a' and c <= 'z') or (c >= 'A' and c <= 'Z') or
|
||||
(c >= '0' and c <= '9') or c == '_';
|
||||
}
|
||||
|
||||
fn readStringLiteral(self: *Tokenizer, start: usize) Token {
|
||||
self.pos += 1; // consume opening quote
|
||||
while (self.pos < self.source.len and self.source[self.pos] != '\'') {
|
||||
|
|
@ -464,6 +483,38 @@ test "tokenize number with commas" {
|
|||
try testing.expectEqual(TokenKind.eof, tok.next().kind);
|
||||
}
|
||||
|
||||
test "tokenize hex with spaces" {
|
||||
var tok = Tokenizer.init("0xFF FF FF FF", .programmer);
|
||||
const t = tok.next();
|
||||
try testing.expectEqual(TokenKind.number, t.kind);
|
||||
try testing.expectEqualStrings("0xFF FF FF FF", t.text("0xFF FF FF FF"));
|
||||
try testing.expectEqual(TokenKind.eof, tok.next().kind);
|
||||
}
|
||||
|
||||
test "tokenize binary with spaces" {
|
||||
var tok = Tokenizer.init("0b1111 0000", .programmer);
|
||||
const t = tok.next();
|
||||
try testing.expectEqual(TokenKind.number, t.kind);
|
||||
try testing.expectEqualStrings("0b1111 0000", t.text("0b1111 0000"));
|
||||
try testing.expectEqual(TokenKind.eof, tok.next().kind);
|
||||
}
|
||||
|
||||
test "tokenize octal with spaces" {
|
||||
var tok = Tokenizer.init("0o777 111", .programmer);
|
||||
const t = tok.next();
|
||||
try testing.expectEqual(TokenKind.number, t.kind);
|
||||
try testing.expectEqualStrings("0o777 111", t.text("0o777 111"));
|
||||
try testing.expectEqual(TokenKind.eof, tok.next().kind);
|
||||
}
|
||||
|
||||
test "tokenize base literal space before operator stops" {
|
||||
var tok = Tokenizer.init("0b1010 + 1", .programmer);
|
||||
try testing.expectEqual(TokenKind.number, tok.next().kind);
|
||||
try testing.expectEqual(TokenKind.plus, tok.next().kind);
|
||||
try testing.expectEqual(TokenKind.number, tok.next().kind);
|
||||
try testing.expectEqual(TokenKind.eof, tok.next().kind);
|
||||
}
|
||||
|
||||
test "tokenize comma not eaten in function args" {
|
||||
var tok = Tokenizer.init("max(1, 2)", .standard);
|
||||
try testing.expectEqual(TokenKind.identifier, tok.next().kind); // max
|
||||
|
|
@ -533,6 +584,49 @@ test "tokenize whitespace only" {
|
|||
try testing.expectEqual(TokenKind.eof, tok.next().kind);
|
||||
}
|
||||
|
||||
test "tokenize semicolon" {
|
||||
var tok = Tokenizer.init(";", .standard);
|
||||
try testing.expectEqual(TokenKind.semicolon, tok.next().kind);
|
||||
}
|
||||
|
||||
test "tokenize bare less-than is invalid" {
|
||||
var tok = Tokenizer.init("<", .programmer);
|
||||
try testing.expectEqual(TokenKind.invalid, tok.next().kind);
|
||||
}
|
||||
|
||||
test "tokenize bare greater-than is invalid" {
|
||||
var tok = Tokenizer.init(">", .programmer);
|
||||
try testing.expectEqual(TokenKind.invalid, tok.next().kind);
|
||||
}
|
||||
|
||||
test "tokenize lone dot is invalid" {
|
||||
var tok = Tokenizer.init(".x", .standard);
|
||||
try testing.expectEqual(TokenKind.invalid, tok.next().kind);
|
||||
}
|
||||
|
||||
test "tokenize unrecognized character is invalid" {
|
||||
// '@' is not handled by any dispatch case, so it hits the else branch
|
||||
var tok = Tokenizer.init("@", .standard);
|
||||
const t = tok.next();
|
||||
try testing.expectEqual(TokenKind.invalid, t.kind);
|
||||
try testing.expectEqual(@as(usize, 1), t.len);
|
||||
}
|
||||
|
||||
test "tokenize base literal with comma separator" {
|
||||
var tok = Tokenizer.init("0xFF,FF", .programmer);
|
||||
const t = tok.next();
|
||||
try testing.expectEqual(TokenKind.number, t.kind);
|
||||
try testing.expectEqualStrings("0xFF,FF", t.text("0xFF,FF"));
|
||||
try testing.expectEqual(TokenKind.eof, tok.next().kind);
|
||||
}
|
||||
|
||||
test "parseNumber huge decimal falls back to float" {
|
||||
const result = try parseNumber("99999999999999999999999999");
|
||||
try testing.expectEqual(@as(?u64, null), result.int_value);
|
||||
try testing.expectEqual(Base.decimal, result.base);
|
||||
try testing.expect(result.float > 1e25);
|
||||
}
|
||||
|
||||
// -- parseNumber tests --
|
||||
|
||||
test "parseNumber decimal integer" {
|
||||
|
|
|
|||
|
|
@ -32,6 +32,15 @@ pub const BitWidth = enum(u8) {
|
|||
pub fn bits(self: BitWidth) u8 {
|
||||
return @intFromEnum(self);
|
||||
}
|
||||
|
||||
/// Returns the smallest standard width that can hold the given value.
|
||||
pub fn smallestFor(value: u128) BitWidth {
|
||||
if (value <= 0xFF) return .bits8;
|
||||
if (value <= 0xFFFF) return .bits16;
|
||||
if (value <= 0xFFFF_FFFF) return .bits32;
|
||||
if (value <= 0xFFFF_FFFF_FFFF_FFFF) return .bits64;
|
||||
return .bits128;
|
||||
}
|
||||
};
|
||||
|
||||
/// Signedness interpretation for programmer mode values.
|
||||
|
|
@ -173,3 +182,13 @@ test "Integer.unsignedValue masks correctly" {
|
|||
const val = Integer{ .raw = 0x1FF, .bit_width = .bits8, .signedness = .unsigned };
|
||||
try std.testing.expectEqual(@as(u128, 0xFF), val.unsignedValue());
|
||||
}
|
||||
|
||||
test "BitWidth.smallestFor" {
|
||||
try std.testing.expectEqual(BitWidth.bits8, BitWidth.smallestFor(0));
|
||||
try std.testing.expectEqual(BitWidth.bits8, BitWidth.smallestFor(255));
|
||||
try std.testing.expectEqual(BitWidth.bits16, BitWidth.smallestFor(256));
|
||||
try std.testing.expectEqual(BitWidth.bits16, BitWidth.smallestFor(65535));
|
||||
try std.testing.expectEqual(BitWidth.bits32, BitWidth.smallestFor(65536));
|
||||
try std.testing.expectEqual(BitWidth.bits64, BitWidth.smallestFor(0x1_0000_0000));
|
||||
try std.testing.expectEqual(BitWidth.bits128, BitWidth.smallestFor(0x1_0000_0000_0000_0000));
|
||||
}
|
||||
|
|
|
|||
46
src/main.zig
46
src/main.zig
|
|
@ -67,14 +67,56 @@ pub fn evaluate(allocator: std.mem.Allocator, expression: []const u8, mode: engi
|
|||
var env = engine.Environment.init(allocator, .standard);
|
||||
defer env.deinit();
|
||||
|
||||
const result = engine.evalString(&env, allocator, expression) catch |err| {
|
||||
const info = engine.evalStringInfo(&env, allocator, expression) catch |err| {
|
||||
return .{ .output = errorMessage(err), .is_error = true };
|
||||
};
|
||||
|
||||
const formatted = engine.formatter.formatFloat(buf, result);
|
||||
const formatted = engine.formatter.formatFloat(buf, info.value);
|
||||
|
||||
// Enrich with multi-base view when the expression used non-decimal
|
||||
// literals and the result is a non-negative integer.
|
||||
if (info.has_nondecimal_literal and isDisplayableInt(info.value)) {
|
||||
return formatStandardMultiBase(buf, formatted.display, info.value);
|
||||
}
|
||||
|
||||
return .{ .output = formatted.display, .is_error = false };
|
||||
}
|
||||
|
||||
/// True if the f64 is a non-negative integer within u128 range.
|
||||
fn isDisplayableInt(value: f64) bool {
|
||||
return value >= 0 and value == @trunc(value) and value < 340282366920938463463374607431768211456.0;
|
||||
}
|
||||
|
||||
/// Format a standard-mode result with an inline multi-base breakdown.
|
||||
/// The decimal display is already computed; append hex/oct/bin.
|
||||
fn formatStandardMultiBase(buf: []u8, dec_display: []const u8, value: f64) CliResult {
|
||||
const int_val: u128 = @intFromFloat(value);
|
||||
const bw = engine.types.BitWidth.smallestFor(int_val);
|
||||
|
||||
var hex_buf: [256]u8 = undefined;
|
||||
var oct_buf: [256]u8 = undefined;
|
||||
var bin_buf: [512]u8 = undefined;
|
||||
const hex = engine.formatter.formatHex(&hex_buf, int_val, bw);
|
||||
const oct = engine.formatter.formatOctal(&oct_buf, int_val, bw);
|
||||
const bin = engine.formatter.formatBinary(&bin_buf, int_val, bw);
|
||||
|
||||
// dec_display points into buf, so copy it out before we overwrite buf.
|
||||
var dec_copy: [128]u8 = undefined;
|
||||
const dec_len = @min(dec_display.len, dec_copy.len);
|
||||
@memcpy(dec_copy[0..dec_len], dec_display[0..dec_len]);
|
||||
|
||||
const output = std.fmt.bufPrint(buf,
|
||||
\\{s}
|
||||
\\ hex: {s}
|
||||
\\ oct: {s}
|
||||
\\ bin: {s}
|
||||
, .{ dec_copy[0..dec_len], hex.display, oct.display, bin.display }) catch {
|
||||
return .{ .output = "error: buffer overflow\n", .is_error = true };
|
||||
};
|
||||
|
||||
return .{ .output = output, .is_error = false };
|
||||
}
|
||||
|
||||
fn formatProgrammerResult(buf: []u8, result: engine.types.Integer, config: engine.types.ProgrammerConfig) CliResult {
|
||||
const value = result.unsignedValue();
|
||||
const signed = result.signedValue();
|
||||
|
|
|
|||
106
src/tui.zig
106
src/tui.zig
|
|
@ -85,6 +85,9 @@ pub const App = struct {
|
|||
expr: []const u8,
|
||||
result: []const u8,
|
||||
is_error: bool,
|
||||
/// Optional pre-labeled detail lines (e.g. "hex: 01 F0") for
|
||||
/// standard-mode results that used non-decimal literals.
|
||||
details: ?[3][]const u8 = null,
|
||||
};
|
||||
|
||||
pub fn init(allocator: Allocator, io: std.Io) App {
|
||||
|
|
@ -114,6 +117,9 @@ pub const App = struct {
|
|||
for (self.history.items) |entry| {
|
||||
self.allocator.free(entry.expr);
|
||||
self.allocator.free(entry.result);
|
||||
if (entry.details) |details| {
|
||||
for (details) |d| self.allocator.free(d);
|
||||
}
|
||||
}
|
||||
self.history.deinit(self.allocator);
|
||||
if (self.saved_input) |s| self.allocator.free(s);
|
||||
|
|
@ -216,6 +222,9 @@ pub const App = struct {
|
|||
for (self.history.items) |entry| {
|
||||
self.allocator.free(entry.expr);
|
||||
self.allocator.free(entry.result);
|
||||
if (entry.details) |details| {
|
||||
for (details) |d| self.allocator.free(d);
|
||||
}
|
||||
}
|
||||
self.history.clearRetainingCapacity();
|
||||
self.history_browse_idx = null;
|
||||
|
|
@ -426,15 +435,42 @@ pub const App = struct {
|
|||
}
|
||||
|
||||
fn submitStandard(self: *App, expr_text: []const u8) !void {
|
||||
const is_error, const display_text = if (engine.evalString(&self.env, self.allocator, expr_text)) |value| blk: {
|
||||
var fmt_buf: [4096]u8 = undefined;
|
||||
const formatted = engine.formatter.formatFloat(&fmt_buf, value);
|
||||
break :blk .{ false, try self.allocator.dupe(u8, formatted.display) };
|
||||
} else |err| blk: {
|
||||
break :blk .{ true, try self.allocator.dupe(u8, errorStr(err)) };
|
||||
const info = engine.evalStringInfo(&self.env, self.allocator, expr_text) catch |err| {
|
||||
const msg = try self.allocator.dupe(u8, errorStr(err));
|
||||
try self.history.append(self.allocator, .{ .expr = expr_text, .result = msg, .is_error = true });
|
||||
return;
|
||||
};
|
||||
|
||||
try self.history.append(self.allocator, .{ .expr = expr_text, .result = display_text, .is_error = is_error });
|
||||
var fmt_buf: [4096]u8 = undefined;
|
||||
const formatted = engine.formatter.formatFloat(&fmt_buf, info.value);
|
||||
const result_copy = try self.allocator.dupe(u8, formatted.display);
|
||||
|
||||
var details: ?[3][]const u8 = null;
|
||||
if (info.has_nondecimal_literal and info.value >= 0 and
|
||||
info.value == @trunc(info.value) and
|
||||
info.value < 340282366920938463463374607431768211456.0)
|
||||
{
|
||||
const int_val: u128 = @intFromFloat(info.value);
|
||||
const bw = engine.types.BitWidth.smallestFor(int_val);
|
||||
var hex_buf: [256]u8 = undefined;
|
||||
var oct_buf: [256]u8 = undefined;
|
||||
var bin_buf: [512]u8 = undefined;
|
||||
const hex = engine.formatter.formatHex(&hex_buf, int_val, bw);
|
||||
const oct = engine.formatter.formatOctal(&oct_buf, int_val, bw);
|
||||
const bin = engine.formatter.formatBinary(&bin_buf, int_val, bw);
|
||||
details = .{
|
||||
try std.fmt.allocPrint(self.allocator, "hex: {s}", .{hex.display}),
|
||||
try std.fmt.allocPrint(self.allocator, "oct: {s}", .{oct.display}),
|
||||
try std.fmt.allocPrint(self.allocator, "bin: {s}", .{bin.display}),
|
||||
};
|
||||
}
|
||||
|
||||
try self.history.append(self.allocator, .{
|
||||
.expr = expr_text,
|
||||
.result = result_copy,
|
||||
.is_error = false,
|
||||
.details = details,
|
||||
});
|
||||
}
|
||||
|
||||
fn submitProgrammer(self: *App, expr_text: []const u8) !void {
|
||||
|
|
@ -555,21 +591,51 @@ pub const App = struct {
|
|||
|
||||
pub fn drawHistory(items: []const App.HistoryEntry, surface: *vxfw.Surface, start: u16, end: u16) void {
|
||||
if (items.len == 0) return;
|
||||
const avail_rows = end -| start;
|
||||
const max_entries = avail_rows / 2;
|
||||
const start_idx = if (items.len > max_entries) items.len - max_entries else 0;
|
||||
if (end <= start) return;
|
||||
const capacity: usize = end - start;
|
||||
|
||||
const LineKind = enum { expr, result, result_err, detail };
|
||||
const Line = struct { text: []const u8, kind: LineKind };
|
||||
|
||||
// Flatten all entries into a line list (oldest first).
|
||||
var lines: [512]Line = undefined;
|
||||
var n: usize = 0;
|
||||
for (items) |entry| {
|
||||
if (n < lines.len) {
|
||||
lines[n] = .{ .text = entry.expr, .kind = .expr };
|
||||
n += 1;
|
||||
}
|
||||
if (n < lines.len) {
|
||||
lines[n] = .{ .text = entry.result, .kind = if (entry.is_error) .result_err else .result };
|
||||
n += 1;
|
||||
}
|
||||
if (entry.details) |details| {
|
||||
for (details) |d| {
|
||||
if (n < lines.len) {
|
||||
lines[n] = .{ .text = d, .kind = .detail };
|
||||
n += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Render only the last `capacity` lines (newest anchored at bottom).
|
||||
const first_visible = if (n > capacity) n - capacity else 0;
|
||||
var row: u16 = start;
|
||||
for (items[start_idx..]) |entry| {
|
||||
if (row + 1 >= end) break;
|
||||
draw.writeStr(surface, row, 2, entry.expr, .{ .fg = C.muted });
|
||||
row += 1;
|
||||
const res_style: vaxis.Style = if (entry.is_error)
|
||||
.{ .fg = C.pink }
|
||||
else
|
||||
.{ .fg = C.green, .bold = true };
|
||||
draw.writeStr(surface, row, 4, "= ", res_style);
|
||||
draw.writeStr(surface, row, 6, entry.result, res_style);
|
||||
for (lines[first_visible..n]) |line| {
|
||||
if (row >= end) break;
|
||||
switch (line.kind) {
|
||||
.expr => draw.writeStr(surface, row, 2, line.text, .{ .fg = C.muted }),
|
||||
.result => {
|
||||
draw.writeStr(surface, row, 4, "= ", .{ .fg = C.green, .bold = true });
|
||||
draw.writeStr(surface, row, 6, line.text, .{ .fg = C.green, .bold = true });
|
||||
},
|
||||
.result_err => {
|
||||
draw.writeStr(surface, row, 4, "= ", .{ .fg = C.pink });
|
||||
draw.writeStr(surface, row, 6, line.text, .{ .fg = C.pink });
|
||||
},
|
||||
.detail => draw.writeStr(surface, row, 6, line.text, .{ .fg = C.muted }),
|
||||
}
|
||||
row += 1;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -63,7 +63,7 @@ pub fn drawHelp(surface: *vxfw.Surface, width: u16, height: u16) void {
|
|||
row += 1;
|
||||
draw.writeStr(surface, row, 4, "Standard: + - * / % ^ (power)", .{ .fg = C.fg });
|
||||
row += 1;
|
||||
draw.writeStr(surface, row, 4, "Programmer: & | ^ (xor) ~ << >> >>> ** rol ror", .{ .fg = C.fg });
|
||||
draw.writeStr(surface, row, 4, "Programmer: & | ~ << >> >>> ^/** (pow) and or xor not rol ror", .{ .fg = C.fg });
|
||||
row += 1;
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue