forked from AbleScript/ablescript
Use impl Value
rather than trait BfWriter
It probably makes more sense to be writing values with `Value::bf_write` than to go for the complexity of using a trait to allow `Writer::write_value` (which also looks ambiguous because it's not immediately clear that a generic name like "write_value" relates to BF or AbleScript).
This commit is contained in:
parent
2c35691ec4
commit
d80f47716d
|
@ -205,10 +205,9 @@ impl ExecEnv {
|
|||
Value::Functio(func) => {
|
||||
match func {
|
||||
Functio::BfFunctio(body) => {
|
||||
use crate::variables::BfWriter;
|
||||
let mut input: Vec<u8> = vec![];
|
||||
for arg in args {
|
||||
input.write_value(&self.eval_expr(arg)?);
|
||||
self.eval_expr(arg)?.bf_write(&mut input);
|
||||
}
|
||||
println!("input = {:?}", input);
|
||||
let mut output = vec![];
|
||||
|
|
121
src/variables.rs
121
src/variables.rs
|
@ -50,6 +50,63 @@ pub enum Value {
|
|||
Functio(Functio),
|
||||
}
|
||||
|
||||
impl Value {
|
||||
/// Writes an AbleScript value to a Brainfuck input stream. This
|
||||
/// should generally only be called on `Write`rs that cannot fail,
|
||||
/// e.g., `Vec<u8>`, because any IO errors will cause a panic.
|
||||
///
|
||||
/// The mapping from values to encodings is as follows, where all
|
||||
/// multi-byte integers are little-endian:
|
||||
///
|
||||
/// | AbleScript representation | Brainfuck representation |
|
||||
/// |---------------------------|-------------------------------------------------------------|
|
||||
/// | Nul | `00` |
|
||||
/// | Str | `01` [length, 4 bytes] [string, \[LENGTH\] bytes, as UTF-8] |
|
||||
/// | Int | `02` [value, 4 bytes] |
|
||||
/// | Bool | `03` `00` false, `03` `01` true. |
|
||||
/// | Abool | `04` `00` never, `04` `01` always, `04` `02` sometimes. |
|
||||
/// | Brainfuck Functio | `05` `00` [length, 4 bytes] [source code, \[LENGTH\] bytes] |
|
||||
/// | AbleScript Functio | `05` `01` (todo, not yet finalized or implemented) |
|
||||
///
|
||||
/// The existing mappings should never change, as they are
|
||||
/// directly visible from Brainfuck code and modifying them would
|
||||
/// break a significant amount of AbleScript code. If more types
|
||||
/// are added in the future, they should be assigned the remaining
|
||||
/// discriminant bytes from 06..FF.
|
||||
pub fn bf_write(&mut self, stream: &mut impl Write) {
|
||||
match self {
|
||||
Value::Nul => stream.write_all(&[0]),
|
||||
Value::Str(s) => stream
|
||||
.write_all(&[1])
|
||||
.and_then(|_| stream.write_all(&(s.len() as u32).to_le_bytes()))
|
||||
.and_then(|_| stream.write_all(&s.as_bytes())),
|
||||
Value::Int(v) => stream
|
||||
.write_all(&[2])
|
||||
.and_then(|_| stream.write_all(&v.to_le_bytes())),
|
||||
Value::Bool(b) => stream
|
||||
.write_all(&[3])
|
||||
.and_then(|_| stream.write_all(&[*b as _])),
|
||||
Value::Abool(a) => stream.write_all(&[4]).and_then(|_| {
|
||||
stream.write_all(&[match *a {
|
||||
Abool::Never => 0,
|
||||
Abool::Sometimes => 2,
|
||||
Abool::Always => 1,
|
||||
}])
|
||||
}),
|
||||
Value::Functio(f) => stream.write_all(&[5]).and_then(|_| match f {
|
||||
Functio::BfFunctio(f) => stream
|
||||
.write_all(&[0])
|
||||
.and_then(|_| stream.write_all(&(f.len() as u32).to_le_bytes()))
|
||||
.and_then(|_| stream.write_all(&f)),
|
||||
Functio::AbleFunctio(_) => {
|
||||
todo!()
|
||||
}
|
||||
}),
|
||||
}
|
||||
.expect("Failed to write to Brainfuck input");
|
||||
}
|
||||
}
|
||||
|
||||
impl Display for Value {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
match self {
|
||||
|
@ -119,70 +176,6 @@ impl From<Value> for bool {
|
|||
}
|
||||
}
|
||||
|
||||
/// Allows writing AbleScript values to Brainfuck.
|
||||
///
|
||||
/// This trait is blanket implemented for all `Write`rs, but should
|
||||
/// typically only be used for `Write`rs that cannot fail, e.g.,
|
||||
/// `Vec<u8>`, because any IO errors will cause a panic.
|
||||
///
|
||||
/// The mapping from values to encodings is as follows, where all
|
||||
/// multi-byte integers are little-endian:
|
||||
///
|
||||
/// | AbleScript representation | Brainfuck representation |
|
||||
/// |---------------------------|-----------------------------------------------------------|
|
||||
/// | Nul | 00 |
|
||||
/// | Str | 01 [length, 4 bytes] [string, \[LENGTH\] bytes, as UTF-8] |
|
||||
/// | Int | 02 [value, 4 bytes] |
|
||||
/// | Bool | 03 00 false, 03 01 true. |
|
||||
/// | Abool | 04 00 never, 04 01 always, 04 02 sometimes. |
|
||||
/// | Brainfuck Functio | 05 00 [length, 4 bytes] [source code, \[LENGTH\] bytes] |
|
||||
/// | AbleScript Functio | 05 01 (todo, not yet finalized or implemented) |
|
||||
///
|
||||
/// The existing mappings should never change, as they are directly
|
||||
/// visible from Brainfuck code and modifying them would break a
|
||||
/// significant amount of AbleScript code. If more types are added in
|
||||
/// the future, they should be assigned the remaining discriminant
|
||||
/// bytes from 06..FF.
|
||||
pub trait BfWriter {
|
||||
/// Write a value. Panic if writing fails for any reason.
|
||||
fn write_value(&mut self, value: &Value);
|
||||
}
|
||||
|
||||
impl<T: Write> BfWriter for T {
|
||||
fn write_value(&mut self, value: &Value) {
|
||||
match value {
|
||||
Value::Nul => self.write_all(&[0]),
|
||||
Value::Str(s) => self
|
||||
.write_all(&[1])
|
||||
.and_then(|_| self.write_all(&(s.len() as u32).to_le_bytes()))
|
||||
.and_then(|_| self.write_all(&s.as_bytes())),
|
||||
Value::Int(v) => self
|
||||
.write_all(&[2])
|
||||
.and_then(|_| self.write_all(&v.to_le_bytes())),
|
||||
Value::Bool(b) => self
|
||||
.write_all(&[3])
|
||||
.and_then(|_| self.write_all(&[*b as _])),
|
||||
Value::Abool(a) => self.write_all(&[4]).and_then(|_| {
|
||||
self.write_all(&[match *a {
|
||||
Abool::Never => 0,
|
||||
Abool::Sometimes => 2,
|
||||
Abool::Always => 1,
|
||||
}])
|
||||
}),
|
||||
Value::Functio(f) => self.write_all(&[5]).and_then(|_| match f {
|
||||
Functio::BfFunctio(f) => self
|
||||
.write_all(&[0])
|
||||
.and_then(|_| self.write_all(&(f.len() as u32).to_le_bytes()))
|
||||
.and_then(|_| self.write_all(&f)),
|
||||
Functio::AbleFunctio(_) => {
|
||||
todo!()
|
||||
}
|
||||
}),
|
||||
}
|
||||
.expect("Failed to write to Brainfuck input");
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct Variable {
|
||||
pub melo: bool,
|
||||
|
|
Loading…
Reference in a new issue