Reorganize repository
This commit is contained in:
282
crates/forth/src/compiler.rs
Normal file
282
crates/forth/src/compiler.rs
Normal file
@@ -0,0 +1,282 @@
|
||||
use super::ops::Op;
|
||||
use super::types::{Dictionary, SourceSpan};
|
||||
use super::words::{compile_word, simple_op};
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
enum Token {
|
||||
Int(i64, SourceSpan),
|
||||
Float(f64, SourceSpan),
|
||||
Str(String, SourceSpan),
|
||||
Word(String, SourceSpan),
|
||||
QuoteStart(usize),
|
||||
QuoteEnd(usize),
|
||||
}
|
||||
|
||||
pub(super) fn compile_script(input: &str, dict: &Dictionary) -> Result<Vec<Op>, String> {
|
||||
let tokens = tokenize(input);
|
||||
compile(&tokens, dict)
|
||||
}
|
||||
|
||||
fn tokenize(input: &str) -> Vec<Token> {
|
||||
let mut tokens = Vec::new();
|
||||
let mut chars = input.char_indices().peekable();
|
||||
|
||||
while let Some(&(pos, c)) = chars.peek() {
|
||||
if c.is_whitespace() {
|
||||
chars.next();
|
||||
continue;
|
||||
}
|
||||
|
||||
if c == '"' {
|
||||
let start = pos;
|
||||
chars.next();
|
||||
let mut s = String::new();
|
||||
let mut end = start + 1;
|
||||
while let Some(&(i, ch)) = chars.peek() {
|
||||
end = i + ch.len_utf8();
|
||||
chars.next();
|
||||
if ch == '"' {
|
||||
break;
|
||||
}
|
||||
s.push(ch);
|
||||
}
|
||||
tokens.push(Token::Str(s, SourceSpan { start, end }));
|
||||
continue;
|
||||
}
|
||||
|
||||
if c == '(' {
|
||||
while let Some(&(_, ch)) = chars.peek() {
|
||||
chars.next();
|
||||
if ch == ')' {
|
||||
break;
|
||||
}
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
if c == '{' {
|
||||
chars.next();
|
||||
tokens.push(Token::QuoteStart(pos));
|
||||
continue;
|
||||
}
|
||||
|
||||
if c == '}' {
|
||||
chars.next();
|
||||
tokens.push(Token::QuoteEnd(pos));
|
||||
continue;
|
||||
}
|
||||
|
||||
let start = pos;
|
||||
let mut word = String::new();
|
||||
let mut end = start;
|
||||
while let Some(&(i, ch)) = chars.peek() {
|
||||
if ch.is_whitespace() || ch == '{' || ch == '}' {
|
||||
break;
|
||||
}
|
||||
end = i + ch.len_utf8();
|
||||
word.push(ch);
|
||||
chars.next();
|
||||
}
|
||||
|
||||
let span = SourceSpan { start, end };
|
||||
if let Ok(i) = word.parse::<i64>() {
|
||||
tokens.push(Token::Int(i, span));
|
||||
} else if let Ok(f) = word.parse::<f64>() {
|
||||
tokens.push(Token::Float(f, span));
|
||||
} else {
|
||||
tokens.push(Token::Word(word, span));
|
||||
}
|
||||
}
|
||||
|
||||
tokens
|
||||
}
|
||||
|
||||
fn compile(tokens: &[Token], dict: &Dictionary) -> Result<Vec<Op>, String> {
|
||||
let mut ops = Vec::new();
|
||||
let mut i = 0;
|
||||
let mut pipe_parity = false;
|
||||
let mut list_depth: usize = 0;
|
||||
|
||||
while i < tokens.len() {
|
||||
match &tokens[i] {
|
||||
Token::Int(n, span) => ops.push(Op::PushInt(*n, Some(*span))),
|
||||
Token::Float(f, span) => ops.push(Op::PushFloat(*f, Some(*span))),
|
||||
Token::Str(s, span) => ops.push(Op::PushStr(s.clone(), Some(*span))),
|
||||
Token::QuoteStart(start_pos) => {
|
||||
let (quote_ops, consumed, end_pos) = compile_quotation(&tokens[i + 1..], dict)?;
|
||||
i += consumed;
|
||||
let body_span = SourceSpan { start: *start_pos, end: end_pos + 1 };
|
||||
ops.push(Op::Quotation(quote_ops, Some(body_span)));
|
||||
}
|
||||
Token::QuoteEnd(_) => {
|
||||
return Err("unexpected }".into());
|
||||
}
|
||||
Token::Word(w, span) => {
|
||||
let word = w.as_str();
|
||||
if word == ":" {
|
||||
let (consumed, name, body) = compile_colon_def(&tokens[i + 1..], dict)?;
|
||||
i += consumed;
|
||||
dict.lock().unwrap().insert(name, body);
|
||||
} else if word == ";" {
|
||||
return Err("unexpected ;".into());
|
||||
} else if word == "|" {
|
||||
if pipe_parity {
|
||||
ops.push(Op::LocalCycleEnd);
|
||||
list_depth = list_depth.saturating_sub(1);
|
||||
} else {
|
||||
ops.push(Op::ListStart);
|
||||
list_depth += 1;
|
||||
}
|
||||
pipe_parity = !pipe_parity;
|
||||
} else if word == "if" {
|
||||
let (then_ops, else_ops, consumed, then_span, else_span) = compile_if(&tokens[i + 1..], dict)?;
|
||||
i += consumed;
|
||||
if else_ops.is_empty() {
|
||||
ops.push(Op::BranchIfZero(then_ops.len(), then_span, None));
|
||||
ops.extend(then_ops);
|
||||
} else {
|
||||
ops.push(Op::BranchIfZero(then_ops.len() + 1, then_span, else_span));
|
||||
ops.extend(then_ops);
|
||||
ops.push(Op::Branch(else_ops.len()));
|
||||
ops.extend(else_ops);
|
||||
}
|
||||
} else if is_list_start(word) {
|
||||
ops.push(Op::ListStart);
|
||||
list_depth += 1;
|
||||
} else if is_list_end(word) {
|
||||
list_depth = list_depth.saturating_sub(1);
|
||||
if let Some(op) = simple_op(word) {
|
||||
ops.push(op);
|
||||
}
|
||||
} else if list_depth > 0 {
|
||||
let mut word_ops = Vec::new();
|
||||
if !compile_word(word, Some(*span), &mut word_ops, dict) {
|
||||
return Err(format!("unknown word: {word}"));
|
||||
}
|
||||
ops.push(Op::Quotation(word_ops, Some(*span)));
|
||||
} else if !compile_word(word, Some(*span), &mut ops, dict) {
|
||||
return Err(format!("unknown word: {word}"));
|
||||
}
|
||||
}
|
||||
}
|
||||
i += 1;
|
||||
}
|
||||
|
||||
Ok(ops)
|
||||
}
|
||||
|
||||
fn is_list_start(word: &str) -> bool {
|
||||
matches!(word, "[" | "<" | "<<")
|
||||
}
|
||||
|
||||
fn is_list_end(word: &str) -> bool {
|
||||
matches!(word, "]" | ">" | ">>")
|
||||
}
|
||||
|
||||
fn compile_quotation(tokens: &[Token], dict: &Dictionary) -> Result<(Vec<Op>, usize, usize), String> {
|
||||
let mut depth = 1;
|
||||
let mut end_idx = None;
|
||||
|
||||
for (i, tok) in tokens.iter().enumerate() {
|
||||
match tok {
|
||||
Token::QuoteStart(_) => depth += 1,
|
||||
Token::QuoteEnd(_) => {
|
||||
depth -= 1;
|
||||
if depth == 0 {
|
||||
end_idx = Some(i);
|
||||
break;
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
|
||||
let end_idx = end_idx.ok_or("missing }")?;
|
||||
let byte_pos = match &tokens[end_idx] {
|
||||
Token::QuoteEnd(pos) => *pos,
|
||||
_ => unreachable!(),
|
||||
};
|
||||
let quote_ops = compile(&tokens[..end_idx], dict)?;
|
||||
Ok((quote_ops, end_idx + 1, byte_pos))
|
||||
}
|
||||
|
||||
fn token_span(tok: &Token) -> Option<SourceSpan> {
|
||||
match tok {
|
||||
Token::Int(_, s) | Token::Float(_, s) | Token::Str(_, s) | Token::Word(_, s) => Some(*s),
|
||||
Token::QuoteStart(p) => Some(SourceSpan { start: *p, end: *p + 1 }),
|
||||
Token::QuoteEnd(p) => Some(SourceSpan { start: *p, end: *p + 1 }),
|
||||
}
|
||||
}
|
||||
|
||||
fn compile_colon_def(tokens: &[Token], dict: &Dictionary) -> Result<(usize, String, Vec<Op>), String> {
|
||||
if tokens.is_empty() {
|
||||
return Err("expected word name after ':'".into());
|
||||
}
|
||||
let name = match &tokens[0] {
|
||||
Token::Word(w, _) => w.clone(),
|
||||
_ => return Err("expected word name after ':'".into()),
|
||||
};
|
||||
let mut semi_pos = None;
|
||||
for (i, tok) in tokens[1..].iter().enumerate() {
|
||||
if let Token::Word(w, _) = tok {
|
||||
if w == ";" {
|
||||
semi_pos = Some(i + 1);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
let semi_pos = semi_pos.ok_or("missing ';' in word definition")?;
|
||||
let body_tokens = &tokens[1..semi_pos];
|
||||
let body_ops = compile(body_tokens, dict)?;
|
||||
// consumed = name + body + semicolon
|
||||
Ok((semi_pos + 1, name, body_ops))
|
||||
}
|
||||
|
||||
fn tokens_span(tokens: &[Token]) -> Option<SourceSpan> {
|
||||
let first = tokens.first().and_then(token_span)?;
|
||||
let last = tokens.last().and_then(token_span)?;
|
||||
Some(SourceSpan { start: first.start, end: last.end })
|
||||
}
|
||||
|
||||
#[allow(clippy::type_complexity)]
|
||||
fn compile_if(tokens: &[Token], dict: &Dictionary) -> Result<(Vec<Op>, Vec<Op>, usize, Option<SourceSpan>, Option<SourceSpan>), String> {
|
||||
let mut depth = 1;
|
||||
let mut else_pos = None;
|
||||
let mut then_pos = None;
|
||||
|
||||
for (i, tok) in tokens.iter().enumerate() {
|
||||
if let Token::Word(w, _) = tok {
|
||||
match w.as_str() {
|
||||
"if" => depth += 1,
|
||||
"else" if depth == 1 => else_pos = Some(i),
|
||||
"then" => {
|
||||
depth -= 1;
|
||||
if depth == 0 {
|
||||
then_pos = Some(i);
|
||||
break;
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let then_pos = then_pos.ok_or("missing 'then'")?;
|
||||
|
||||
let (then_ops, else_ops, then_span, else_span) = if let Some(ep) = else_pos {
|
||||
let then_slice = &tokens[..ep];
|
||||
let else_slice = &tokens[ep + 1..then_pos];
|
||||
let then_span = tokens_span(then_slice);
|
||||
let else_span = tokens_span(else_slice);
|
||||
let then_ops = compile(then_slice, dict)?;
|
||||
let else_ops = compile(else_slice, dict)?;
|
||||
(then_ops, else_ops, then_span, else_span)
|
||||
} else {
|
||||
let then_slice = &tokens[..then_pos];
|
||||
let then_span = tokens_span(then_slice);
|
||||
let then_ops = compile(then_slice, dict)?;
|
||||
(then_ops, Vec::new(), then_span, None)
|
||||
};
|
||||
|
||||
Ok((then_ops, else_ops, then_pos + 1, then_span, else_span))
|
||||
}
|
||||
9
crates/forth/src/lib.rs
Normal file
9
crates/forth/src/lib.rs
Normal file
@@ -0,0 +1,9 @@
|
||||
mod compiler;
|
||||
mod ops;
|
||||
mod types;
|
||||
mod vm;
|
||||
mod words;
|
||||
|
||||
pub use types::{Dictionary, ExecutionTrace, Rng, SourceSpan, StepContext, Value, Variables};
|
||||
pub use vm::Forth;
|
||||
pub use words::{Word, WordCompile, WORDS};
|
||||
82
crates/forth/src/ops.rs
Normal file
82
crates/forth/src/ops.rs
Normal file
@@ -0,0 +1,82 @@
|
||||
use super::types::SourceSpan;
|
||||
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub enum Op {
|
||||
PushInt(i64, Option<SourceSpan>),
|
||||
PushFloat(f64, Option<SourceSpan>),
|
||||
PushStr(String, Option<SourceSpan>),
|
||||
Dup,
|
||||
Dupn,
|
||||
Drop,
|
||||
Swap,
|
||||
Over,
|
||||
Rot,
|
||||
Nip,
|
||||
Tuck,
|
||||
Add,
|
||||
Sub,
|
||||
Mul,
|
||||
Div,
|
||||
Mod,
|
||||
Neg,
|
||||
Abs,
|
||||
Floor,
|
||||
Ceil,
|
||||
Round,
|
||||
Min,
|
||||
Max,
|
||||
Eq,
|
||||
Ne,
|
||||
Lt,
|
||||
Gt,
|
||||
Le,
|
||||
Ge,
|
||||
And,
|
||||
Or,
|
||||
Not,
|
||||
BranchIfZero(usize, Option<SourceSpan>, Option<SourceSpan>),
|
||||
Branch(usize),
|
||||
NewCmd,
|
||||
SetParam(String),
|
||||
Emit,
|
||||
Get,
|
||||
Set,
|
||||
GetContext(String),
|
||||
Rand,
|
||||
Rrand,
|
||||
Seed,
|
||||
Cycle,
|
||||
Choose,
|
||||
ChanceExec,
|
||||
ProbExec,
|
||||
Coin,
|
||||
Mtof,
|
||||
Ftom,
|
||||
ListStart,
|
||||
ListEnd,
|
||||
ListEndCycle,
|
||||
PCycle,
|
||||
ListEndPCycle,
|
||||
At,
|
||||
Window,
|
||||
Scale,
|
||||
Pop,
|
||||
Subdivide,
|
||||
SetTempo,
|
||||
Each,
|
||||
Every,
|
||||
Quotation(Vec<Op>, Option<SourceSpan>),
|
||||
When,
|
||||
Unless,
|
||||
Adsr,
|
||||
Ad,
|
||||
Stack,
|
||||
For,
|
||||
LocalCycleEnd,
|
||||
Echo,
|
||||
Necho,
|
||||
Apply,
|
||||
Ramp,
|
||||
Range,
|
||||
Noise,
|
||||
}
|
||||
141
crates/forth/src/types.rs
Normal file
141
crates/forth/src/types.rs
Normal file
@@ -0,0 +1,141 @@
|
||||
use rand::rngs::StdRng;
|
||||
use std::collections::HashMap;
|
||||
use std::sync::{Arc, Mutex};
|
||||
|
||||
use super::ops::Op;
|
||||
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
|
||||
pub struct SourceSpan {
|
||||
pub start: usize,
|
||||
pub end: usize,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Default)]
|
||||
pub struct ExecutionTrace {
|
||||
pub executed_spans: Vec<SourceSpan>,
|
||||
pub selected_spans: Vec<SourceSpan>,
|
||||
}
|
||||
|
||||
pub struct StepContext {
|
||||
pub step: usize,
|
||||
pub beat: f64,
|
||||
pub pattern: usize,
|
||||
pub tempo: f64,
|
||||
pub phase: f64,
|
||||
pub slot: usize,
|
||||
pub runs: usize,
|
||||
pub iter: usize,
|
||||
pub speed: f64,
|
||||
pub fill: bool,
|
||||
}
|
||||
|
||||
impl StepContext {
|
||||
pub fn step_duration(&self) -> f64 {
|
||||
60.0 / self.tempo / 4.0 / self.speed
|
||||
}
|
||||
}
|
||||
|
||||
pub type Variables = Arc<Mutex<HashMap<String, Value>>>;
|
||||
pub type Dictionary = Arc<Mutex<HashMap<String, Vec<Op>>>>;
|
||||
pub type Rng = Arc<Mutex<StdRng>>;
|
||||
pub type Stack = Arc<Mutex<Vec<Value>>>;
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub enum Value {
|
||||
Int(i64, Option<SourceSpan>),
|
||||
Float(f64, Option<SourceSpan>),
|
||||
Str(String, Option<SourceSpan>),
|
||||
Marker,
|
||||
Quotation(Vec<Op>, Option<SourceSpan>),
|
||||
}
|
||||
|
||||
impl PartialEq for Value {
|
||||
fn eq(&self, other: &Self) -> bool {
|
||||
match (self, other) {
|
||||
(Value::Int(a, _), Value::Int(b, _)) => a == b,
|
||||
(Value::Float(a, _), Value::Float(b, _)) => a == b,
|
||||
(Value::Str(a, _), Value::Str(b, _)) => a == b,
|
||||
(Value::Marker, Value::Marker) => true,
|
||||
(Value::Quotation(a, _), Value::Quotation(b, _)) => a == b,
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Value {
|
||||
pub fn as_float(&self) -> Result<f64, String> {
|
||||
match self {
|
||||
Value::Float(f, _) => Ok(*f),
|
||||
Value::Int(i, _) => Ok(*i as f64),
|
||||
_ => Err("expected number".into()),
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn as_int(&self) -> Result<i64, String> {
|
||||
match self {
|
||||
Value::Int(i, _) => Ok(*i),
|
||||
Value::Float(f, _) => Ok(*f as i64),
|
||||
_ => Err("expected number".into()),
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn as_str(&self) -> Result<&str, String> {
|
||||
match self {
|
||||
Value::Str(s, _) => Ok(s),
|
||||
_ => Err("expected string".into()),
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn is_truthy(&self) -> bool {
|
||||
match self {
|
||||
Value::Int(i, _) => *i != 0,
|
||||
Value::Float(f, _) => *f != 0.0,
|
||||
Value::Str(s, _) => !s.is_empty(),
|
||||
Value::Marker => false,
|
||||
Value::Quotation(..) => true,
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn is_marker(&self) -> bool {
|
||||
matches!(self, Value::Marker)
|
||||
}
|
||||
|
||||
pub(super) fn to_param_string(&self) -> String {
|
||||
match self {
|
||||
Value::Int(i, _) => i.to_string(),
|
||||
Value::Float(f, _) => f.to_string(),
|
||||
Value::Str(s, _) => s.clone(),
|
||||
Value::Marker => String::new(),
|
||||
Value::Quotation(..) => String::new(),
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn span(&self) -> Option<SourceSpan> {
|
||||
match self {
|
||||
Value::Int(_, s) | Value::Float(_, s) | Value::Str(_, s) => *s,
|
||||
Value::Marker | Value::Quotation(..) => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Default)]
|
||||
pub(super) struct CmdRegister {
|
||||
sound: Option<String>,
|
||||
params: Vec<(String, String)>,
|
||||
}
|
||||
|
||||
impl CmdRegister {
|
||||
pub(super) fn set_sound(&mut self, name: String) {
|
||||
self.sound = Some(name);
|
||||
}
|
||||
|
||||
pub(super) fn set_param(&mut self, key: String, value: String) {
|
||||
self.params.push((key, value));
|
||||
}
|
||||
|
||||
pub(super) fn take(&mut self) -> Option<(String, Vec<(String, String)>)> {
|
||||
let sound = self.sound.take()?;
|
||||
let params = std::mem::take(&mut self.params);
|
||||
Some((sound, params))
|
||||
}
|
||||
}
|
||||
956
crates/forth/src/vm.rs
Normal file
956
crates/forth/src/vm.rs
Normal file
@@ -0,0 +1,956 @@
|
||||
use rand::rngs::StdRng;
|
||||
use rand::{Rng as RngTrait, SeedableRng};
|
||||
|
||||
use super::compiler::compile_script;
|
||||
use super::ops::Op;
|
||||
use super::types::{
|
||||
CmdRegister, Dictionary, ExecutionTrace, Rng, Stack, StepContext, Value, Variables,
|
||||
};
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
struct TimeContext {
|
||||
start: f64,
|
||||
duration: f64,
|
||||
subdivisions: Option<Vec<(f64, f64)>>,
|
||||
iteration_index: Option<usize>,
|
||||
}
|
||||
|
||||
pub struct Forth {
|
||||
stack: Stack,
|
||||
vars: Variables,
|
||||
dict: Dictionary,
|
||||
rng: Rng,
|
||||
}
|
||||
|
||||
impl Forth {
|
||||
pub fn new(vars: Variables, dict: Dictionary, rng: Rng) -> Self {
|
||||
Self {
|
||||
stack: std::sync::Arc::new(std::sync::Mutex::new(Vec::new())),
|
||||
vars,
|
||||
dict,
|
||||
rng,
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(dead_code)]
|
||||
pub fn stack(&self) -> Vec<Value> {
|
||||
self.stack.lock().unwrap().clone()
|
||||
}
|
||||
|
||||
#[allow(dead_code)]
|
||||
pub fn clear_stack(&self) {
|
||||
self.stack.lock().unwrap().clear();
|
||||
}
|
||||
|
||||
pub fn evaluate(&self, script: &str, ctx: &StepContext) -> Result<Vec<String>, String> {
|
||||
self.evaluate_impl(script, ctx, None)
|
||||
}
|
||||
|
||||
pub fn evaluate_with_trace(
|
||||
&self,
|
||||
script: &str,
|
||||
ctx: &StepContext,
|
||||
trace: &mut ExecutionTrace,
|
||||
) -> Result<Vec<String>, String> {
|
||||
self.evaluate_impl(script, ctx, Some(trace))
|
||||
}
|
||||
|
||||
fn evaluate_impl(
|
||||
&self,
|
||||
script: &str,
|
||||
ctx: &StepContext,
|
||||
trace: Option<&mut ExecutionTrace>,
|
||||
) -> Result<Vec<String>, String> {
|
||||
if script.trim().is_empty() {
|
||||
return Err("empty script".into());
|
||||
}
|
||||
|
||||
let ops = compile_script(script, &self.dict)?;
|
||||
self.execute(&ops, ctx, trace)
|
||||
}
|
||||
|
||||
fn execute(
|
||||
&self,
|
||||
ops: &[Op],
|
||||
ctx: &StepContext,
|
||||
trace: Option<&mut ExecutionTrace>,
|
||||
) -> Result<Vec<String>, String> {
|
||||
let mut stack = self.stack.lock().unwrap();
|
||||
let mut outputs: Vec<String> = Vec::new();
|
||||
let mut time_stack: Vec<TimeContext> = vec![TimeContext {
|
||||
start: 0.0,
|
||||
duration: ctx.step_duration() * 4.0,
|
||||
subdivisions: None,
|
||||
iteration_index: None,
|
||||
}];
|
||||
let mut cmd = CmdRegister::default();
|
||||
|
||||
self.execute_ops(
|
||||
ops,
|
||||
ctx,
|
||||
&mut stack,
|
||||
&mut outputs,
|
||||
&mut time_stack,
|
||||
&mut cmd,
|
||||
trace,
|
||||
)?;
|
||||
|
||||
Ok(outputs)
|
||||
}
|
||||
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
fn execute_ops(
|
||||
&self,
|
||||
ops: &[Op],
|
||||
ctx: &StepContext,
|
||||
stack: &mut Vec<Value>,
|
||||
outputs: &mut Vec<String>,
|
||||
time_stack: &mut Vec<TimeContext>,
|
||||
cmd: &mut CmdRegister,
|
||||
trace: Option<&mut ExecutionTrace>,
|
||||
) -> Result<(), String> {
|
||||
let mut pc = 0;
|
||||
let trace_cell = std::cell::RefCell::new(trace);
|
||||
|
||||
while pc < ops.len() {
|
||||
match &ops[pc] {
|
||||
Op::PushInt(n, span) => stack.push(Value::Int(*n, *span)),
|
||||
Op::PushFloat(f, span) => stack.push(Value::Float(*f, *span)),
|
||||
Op::PushStr(s, span) => stack.push(Value::Str(s.clone(), *span)),
|
||||
|
||||
Op::Dup => {
|
||||
let v = stack.last().ok_or("stack underflow")?.clone();
|
||||
stack.push(v);
|
||||
}
|
||||
Op::Dupn => {
|
||||
let n = stack.pop().ok_or("stack underflow")?.as_int()?;
|
||||
let v = stack.pop().ok_or("stack underflow")?;
|
||||
for _ in 0..n {
|
||||
stack.push(v.clone());
|
||||
}
|
||||
}
|
||||
Op::Drop => {
|
||||
stack.pop().ok_or("stack underflow")?;
|
||||
}
|
||||
Op::Swap => {
|
||||
let len = stack.len();
|
||||
if len < 2 {
|
||||
return Err("stack underflow".into());
|
||||
}
|
||||
stack.swap(len - 1, len - 2);
|
||||
}
|
||||
Op::Over => {
|
||||
let len = stack.len();
|
||||
if len < 2 {
|
||||
return Err("stack underflow".into());
|
||||
}
|
||||
let v = stack[len - 2].clone();
|
||||
stack.push(v);
|
||||
}
|
||||
Op::Rot => {
|
||||
let len = stack.len();
|
||||
if len < 3 {
|
||||
return Err("stack underflow".into());
|
||||
}
|
||||
let v = stack.remove(len - 3);
|
||||
stack.push(v);
|
||||
}
|
||||
Op::Nip => {
|
||||
let len = stack.len();
|
||||
if len < 2 {
|
||||
return Err("stack underflow".into());
|
||||
}
|
||||
stack.remove(len - 2);
|
||||
}
|
||||
Op::Tuck => {
|
||||
let len = stack.len();
|
||||
if len < 2 {
|
||||
return Err("stack underflow".into());
|
||||
}
|
||||
let v = stack[len - 1].clone();
|
||||
stack.insert(len - 2, v);
|
||||
}
|
||||
|
||||
Op::Add => binary_op(stack, |a, b| a + b)?,
|
||||
Op::Sub => binary_op(stack, |a, b| a - b)?,
|
||||
Op::Mul => binary_op(stack, |a, b| a * b)?,
|
||||
Op::Div => binary_op(stack, |a, b| a / b)?,
|
||||
Op::Mod => {
|
||||
let b = stack.pop().ok_or("stack underflow")?.as_int()?;
|
||||
let a = stack.pop().ok_or("stack underflow")?.as_int()?;
|
||||
stack.push(Value::Int(a % b, None));
|
||||
}
|
||||
Op::Neg => {
|
||||
let v = stack.pop().ok_or("stack underflow")?;
|
||||
match v {
|
||||
Value::Int(i, s) => stack.push(Value::Int(-i, s)),
|
||||
Value::Float(f, s) => stack.push(Value::Float(-f, s)),
|
||||
_ => return Err("expected number".into()),
|
||||
}
|
||||
}
|
||||
Op::Abs => {
|
||||
let v = stack.pop().ok_or("stack underflow")?;
|
||||
match v {
|
||||
Value::Int(i, s) => stack.push(Value::Int(i.abs(), s)),
|
||||
Value::Float(f, s) => stack.push(Value::Float(f.abs(), s)),
|
||||
_ => return Err("expected number".into()),
|
||||
}
|
||||
}
|
||||
Op::Floor => {
|
||||
let v = stack.pop().ok_or("stack underflow")?.as_float()?;
|
||||
stack.push(Value::Int(v.floor() as i64, None));
|
||||
}
|
||||
Op::Ceil => {
|
||||
let v = stack.pop().ok_or("stack underflow")?.as_float()?;
|
||||
stack.push(Value::Int(v.ceil() as i64, None));
|
||||
}
|
||||
Op::Round => {
|
||||
let v = stack.pop().ok_or("stack underflow")?.as_float()?;
|
||||
stack.push(Value::Int(v.round() as i64, None));
|
||||
}
|
||||
Op::Min => binary_op(stack, |a, b| a.min(b))?,
|
||||
Op::Max => binary_op(stack, |a, b| a.max(b))?,
|
||||
|
||||
Op::Eq => cmp_op(stack, |a, b| (a - b).abs() < f64::EPSILON)?,
|
||||
Op::Ne => cmp_op(stack, |a, b| (a - b).abs() >= f64::EPSILON)?,
|
||||
Op::Lt => cmp_op(stack, |a, b| a < b)?,
|
||||
Op::Gt => cmp_op(stack, |a, b| a > b)?,
|
||||
Op::Le => cmp_op(stack, |a, b| a <= b)?,
|
||||
Op::Ge => cmp_op(stack, |a, b| a >= b)?,
|
||||
|
||||
Op::And => {
|
||||
let b = stack.pop().ok_or("stack underflow")?.is_truthy();
|
||||
let a = stack.pop().ok_or("stack underflow")?.is_truthy();
|
||||
stack.push(Value::Int(if a && b { 1 } else { 0 }, None));
|
||||
}
|
||||
Op::Or => {
|
||||
let b = stack.pop().ok_or("stack underflow")?.is_truthy();
|
||||
let a = stack.pop().ok_or("stack underflow")?.is_truthy();
|
||||
stack.push(Value::Int(if a || b { 1 } else { 0 }, None));
|
||||
}
|
||||
Op::Not => {
|
||||
let v = stack.pop().ok_or("stack underflow")?.is_truthy();
|
||||
stack.push(Value::Int(if v { 0 } else { 1 }, None));
|
||||
}
|
||||
|
||||
Op::BranchIfZero(offset, then_span, else_span) => {
|
||||
let v = stack.pop().ok_or("stack underflow")?;
|
||||
if !v.is_truthy() {
|
||||
if let Some(span) = else_span {
|
||||
if let Some(trace) = trace_cell.borrow_mut().as_mut() {
|
||||
trace.executed_spans.push(*span);
|
||||
}
|
||||
}
|
||||
pc += offset;
|
||||
} else if let Some(span) = then_span {
|
||||
if let Some(trace) = trace_cell.borrow_mut().as_mut() {
|
||||
trace.executed_spans.push(*span);
|
||||
}
|
||||
}
|
||||
}
|
||||
Op::Branch(offset) => {
|
||||
pc += offset;
|
||||
}
|
||||
|
||||
Op::NewCmd => {
|
||||
let name = stack.pop().ok_or("stack underflow")?;
|
||||
let name = name.as_str()?;
|
||||
cmd.set_sound(name.to_string());
|
||||
}
|
||||
Op::SetParam(param) => {
|
||||
let val = stack.pop().ok_or("stack underflow")?;
|
||||
cmd.set_param(param.clone(), val.to_param_string());
|
||||
}
|
||||
Op::Emit => {
|
||||
let (sound, mut params) = cmd.take().ok_or("no sound set")?;
|
||||
let mut pairs = vec![("sound".into(), sound)];
|
||||
pairs.append(&mut params);
|
||||
let time_ctx = time_stack.last().ok_or("time stack underflow")?;
|
||||
if time_ctx.start > 0.0 {
|
||||
pairs.push(("delta".into(), time_ctx.start.to_string()));
|
||||
}
|
||||
if !pairs.iter().any(|(k, _)| k == "dur") {
|
||||
pairs.push(("dur".into(), time_ctx.duration.to_string()));
|
||||
}
|
||||
if let Some(idx) = pairs.iter().position(|(k, _)| k == "delaytime") {
|
||||
let ratio: f64 = pairs[idx].1.parse().unwrap_or(1.0);
|
||||
pairs[idx].1 = (ratio * time_ctx.duration).to_string();
|
||||
} else {
|
||||
pairs.push(("delaytime".into(), time_ctx.duration.to_string()));
|
||||
}
|
||||
outputs.push(format_cmd(&pairs));
|
||||
}
|
||||
|
||||
Op::Get => {
|
||||
let name = stack.pop().ok_or("stack underflow")?;
|
||||
let name = name.as_str()?;
|
||||
let vars = self.vars.lock().unwrap();
|
||||
let val = vars.get(name).cloned().unwrap_or(Value::Int(0, None));
|
||||
stack.push(val);
|
||||
}
|
||||
Op::Set => {
|
||||
let name = stack.pop().ok_or("stack underflow")?;
|
||||
let name = name.as_str()?.to_string();
|
||||
let val = stack.pop().ok_or("stack underflow")?;
|
||||
self.vars.lock().unwrap().insert(name, val);
|
||||
}
|
||||
|
||||
Op::GetContext(name) => {
|
||||
let val = match name.as_str() {
|
||||
"step" => Value::Int(ctx.step as i64, None),
|
||||
"beat" => Value::Float(ctx.beat, None),
|
||||
"pattern" => Value::Int(ctx.pattern as i64, None),
|
||||
"tempo" => Value::Float(ctx.tempo, None),
|
||||
"phase" => Value::Float(ctx.phase, None),
|
||||
"slot" => Value::Int(ctx.slot as i64, None),
|
||||
"runs" => Value::Int(ctx.runs as i64, None),
|
||||
"iter" => Value::Int(ctx.iter as i64, None),
|
||||
"speed" => Value::Float(ctx.speed, None),
|
||||
"stepdur" => Value::Float(ctx.step_duration(), None),
|
||||
"fill" => Value::Int(if ctx.fill { 1 } else { 0 }, None),
|
||||
_ => Value::Int(0, None),
|
||||
};
|
||||
stack.push(val);
|
||||
}
|
||||
|
||||
Op::Rand => {
|
||||
let max = stack.pop().ok_or("stack underflow")?.as_float()?;
|
||||
let min = stack.pop().ok_or("stack underflow")?.as_float()?;
|
||||
let val = self.rng.lock().unwrap().gen_range(min..max);
|
||||
stack.push(Value::Float(val, None));
|
||||
}
|
||||
Op::Rrand => {
|
||||
let max = stack.pop().ok_or("stack underflow")?.as_int()?;
|
||||
let min = stack.pop().ok_or("stack underflow")?.as_int()?;
|
||||
let val = self.rng.lock().unwrap().gen_range(min..=max);
|
||||
stack.push(Value::Int(val, None));
|
||||
}
|
||||
Op::Seed => {
|
||||
let s = stack.pop().ok_or("stack underflow")?.as_int()?;
|
||||
*self.rng.lock().unwrap() = StdRng::seed_from_u64(s as u64);
|
||||
}
|
||||
|
||||
Op::Cycle => {
|
||||
let count = stack.pop().ok_or("stack underflow")?.as_int()? as usize;
|
||||
if count == 0 {
|
||||
return Err("cycle count must be > 0".into());
|
||||
}
|
||||
if stack.len() < count {
|
||||
return Err("stack underflow".into());
|
||||
}
|
||||
let start = stack.len() - count;
|
||||
let values: Vec<Value> = stack.drain(start..).collect();
|
||||
let idx = ctx.runs % count;
|
||||
let selected = values[idx].clone();
|
||||
if let Some(span) = selected.span() {
|
||||
if let Some(trace) = trace_cell.borrow_mut().as_mut() {
|
||||
trace.selected_spans.push(span);
|
||||
}
|
||||
}
|
||||
if let Value::Quotation(quot_ops, body_span) = selected {
|
||||
if let Some(span) = body_span {
|
||||
if let Some(trace) = trace_cell.borrow_mut().as_mut() {
|
||||
trace.executed_spans.push(span);
|
||||
}
|
||||
}
|
||||
let mut trace_opt = trace_cell.borrow_mut().take();
|
||||
self.execute_ops("_ops, ctx, stack, outputs, time_stack, cmd, trace_opt.as_deref_mut())?;
|
||||
*trace_cell.borrow_mut() = trace_opt;
|
||||
} else {
|
||||
stack.push(selected);
|
||||
}
|
||||
}
|
||||
|
||||
Op::PCycle => {
|
||||
let count = stack.pop().ok_or("stack underflow")?.as_int()? as usize;
|
||||
if count == 0 {
|
||||
return Err("pcycle count must be > 0".into());
|
||||
}
|
||||
if stack.len() < count {
|
||||
return Err("stack underflow".into());
|
||||
}
|
||||
let start = stack.len() - count;
|
||||
let values: Vec<Value> = stack.drain(start..).collect();
|
||||
let idx = ctx.iter % count;
|
||||
let selected = values[idx].clone();
|
||||
if let Some(span) = selected.span() {
|
||||
if let Some(trace) = trace_cell.borrow_mut().as_mut() {
|
||||
trace.selected_spans.push(span);
|
||||
}
|
||||
}
|
||||
if let Value::Quotation(quot_ops, body_span) = selected {
|
||||
if let Some(span) = body_span {
|
||||
if let Some(trace) = trace_cell.borrow_mut().as_mut() {
|
||||
trace.executed_spans.push(span);
|
||||
}
|
||||
}
|
||||
let mut trace_opt = trace_cell.borrow_mut().take();
|
||||
self.execute_ops("_ops, ctx, stack, outputs, time_stack, cmd, trace_opt.as_deref_mut())?;
|
||||
*trace_cell.borrow_mut() = trace_opt;
|
||||
} else {
|
||||
stack.push(selected);
|
||||
}
|
||||
}
|
||||
|
||||
Op::Choose => {
|
||||
let count = stack.pop().ok_or("stack underflow")?.as_int()? as usize;
|
||||
if count == 0 {
|
||||
return Err("choose count must be > 0".into());
|
||||
}
|
||||
if stack.len() < count {
|
||||
return Err("stack underflow".into());
|
||||
}
|
||||
let start = stack.len() - count;
|
||||
let values: Vec<Value> = stack.drain(start..).collect();
|
||||
let idx = self.rng.lock().unwrap().gen_range(0..count);
|
||||
let selected = values[idx].clone();
|
||||
if let Some(span) = selected.span() {
|
||||
if let Some(trace) = trace_cell.borrow_mut().as_mut() {
|
||||
trace.selected_spans.push(span);
|
||||
}
|
||||
}
|
||||
if let Value::Quotation(quot_ops, body_span) = selected {
|
||||
if let Some(span) = body_span {
|
||||
if let Some(trace) = trace_cell.borrow_mut().as_mut() {
|
||||
trace.executed_spans.push(span);
|
||||
}
|
||||
}
|
||||
let mut trace_opt = trace_cell.borrow_mut().take();
|
||||
self.execute_ops("_ops, ctx, stack, outputs, time_stack, cmd, trace_opt.as_deref_mut())?;
|
||||
*trace_cell.borrow_mut() = trace_opt;
|
||||
} else {
|
||||
stack.push(selected);
|
||||
}
|
||||
}
|
||||
|
||||
Op::ChanceExec => {
|
||||
let prob = stack.pop().ok_or("stack underflow")?.as_float()?;
|
||||
let quot = stack.pop().ok_or("stack underflow")?;
|
||||
let val: f64 = self.rng.lock().unwrap().gen();
|
||||
if val < prob {
|
||||
match quot {
|
||||
Value::Quotation(quot_ops, body_span) => {
|
||||
if let Some(span) = body_span {
|
||||
if let Some(trace) = trace_cell.borrow_mut().as_mut() {
|
||||
trace.executed_spans.push(span);
|
||||
}
|
||||
}
|
||||
let mut trace_opt = trace_cell.borrow_mut().take();
|
||||
self.execute_ops("_ops, ctx, stack, outputs, time_stack, cmd, trace_opt.as_deref_mut())?;
|
||||
*trace_cell.borrow_mut() = trace_opt;
|
||||
}
|
||||
_ => return Err("expected quotation".into()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Op::ProbExec => {
|
||||
let pct = stack.pop().ok_or("stack underflow")?.as_float()?;
|
||||
let quot = stack.pop().ok_or("stack underflow")?;
|
||||
let val: f64 = self.rng.lock().unwrap().gen();
|
||||
if val < pct / 100.0 {
|
||||
match quot {
|
||||
Value::Quotation(quot_ops, body_span) => {
|
||||
if let Some(span) = body_span {
|
||||
if let Some(trace) = trace_cell.borrow_mut().as_mut() {
|
||||
trace.executed_spans.push(span);
|
||||
}
|
||||
}
|
||||
let mut trace_opt = trace_cell.borrow_mut().take();
|
||||
self.execute_ops("_ops, ctx, stack, outputs, time_stack, cmd, trace_opt.as_deref_mut())?;
|
||||
*trace_cell.borrow_mut() = trace_opt;
|
||||
}
|
||||
_ => return Err("expected quotation".into()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Op::Coin => {
|
||||
let val: f64 = self.rng.lock().unwrap().gen();
|
||||
stack.push(Value::Int(if val < 0.5 { 1 } else { 0 }, None));
|
||||
}
|
||||
|
||||
Op::Every => {
|
||||
let n = stack.pop().ok_or("stack underflow")?.as_int()?;
|
||||
if n <= 0 {
|
||||
return Err("every count must be > 0".into());
|
||||
}
|
||||
let result = ctx.iter as i64 % n == 0;
|
||||
stack.push(Value::Int(if result { 1 } else { 0 }, None));
|
||||
}
|
||||
|
||||
Op::Quotation(quote_ops, body_span) => {
|
||||
stack.push(Value::Quotation(quote_ops.clone(), *body_span));
|
||||
}
|
||||
|
||||
Op::When => {
|
||||
let cond = stack.pop().ok_or("stack underflow")?;
|
||||
let quot = stack.pop().ok_or("stack underflow")?;
|
||||
if cond.is_truthy() {
|
||||
match quot {
|
||||
Value::Quotation(quot_ops, body_span) => {
|
||||
if let Some(span) = body_span {
|
||||
if let Some(trace) = trace_cell.borrow_mut().as_mut() {
|
||||
trace.executed_spans.push(span);
|
||||
}
|
||||
}
|
||||
let mut trace_opt = trace_cell.borrow_mut().take();
|
||||
self.execute_ops("_ops, ctx, stack, outputs, time_stack, cmd, trace_opt.as_deref_mut())?;
|
||||
*trace_cell.borrow_mut() = trace_opt;
|
||||
}
|
||||
_ => return Err("expected quotation".into()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Op::Unless => {
|
||||
let cond = stack.pop().ok_or("stack underflow")?;
|
||||
let quot = stack.pop().ok_or("stack underflow")?;
|
||||
if !cond.is_truthy() {
|
||||
match quot {
|
||||
Value::Quotation(quot_ops, body_span) => {
|
||||
if let Some(span) = body_span {
|
||||
if let Some(trace) = trace_cell.borrow_mut().as_mut() {
|
||||
trace.executed_spans.push(span);
|
||||
}
|
||||
}
|
||||
let mut trace_opt = trace_cell.borrow_mut().take();
|
||||
self.execute_ops("_ops, ctx, stack, outputs, time_stack, cmd, trace_opt.as_deref_mut())?;
|
||||
*trace_cell.borrow_mut() = trace_opt;
|
||||
}
|
||||
_ => return Err("expected quotation".into()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Op::Mtof => {
|
||||
let note = stack.pop().ok_or("stack underflow")?.as_float()?;
|
||||
let freq = 440.0 * 2.0_f64.powf((note - 69.0) / 12.0);
|
||||
stack.push(Value::Float(freq, None));
|
||||
}
|
||||
|
||||
Op::Ftom => {
|
||||
let freq = stack.pop().ok_or("stack underflow")?.as_float()?;
|
||||
let note = 69.0 + 12.0 * (freq / 440.0).log2();
|
||||
stack.push(Value::Float(note, None));
|
||||
}
|
||||
|
||||
Op::At => {
|
||||
let pos = stack.pop().ok_or("stack underflow")?.as_float()?;
|
||||
let parent = time_stack.last().ok_or("time stack underflow")?;
|
||||
let new_start = parent.start + parent.duration * pos;
|
||||
time_stack.push(TimeContext {
|
||||
start: new_start,
|
||||
duration: parent.duration * (1.0 - pos),
|
||||
subdivisions: None,
|
||||
iteration_index: parent.iteration_index,
|
||||
});
|
||||
}
|
||||
|
||||
Op::Window => {
|
||||
let end = stack.pop().ok_or("stack underflow")?.as_float()?;
|
||||
let start_pos = stack.pop().ok_or("stack underflow")?.as_float()?;
|
||||
let parent = time_stack.last().ok_or("time stack underflow")?;
|
||||
let new_start = parent.start + parent.duration * start_pos;
|
||||
let new_duration = parent.duration * (end - start_pos);
|
||||
time_stack.push(TimeContext {
|
||||
start: new_start,
|
||||
duration: new_duration,
|
||||
subdivisions: None,
|
||||
iteration_index: parent.iteration_index,
|
||||
});
|
||||
}
|
||||
|
||||
Op::Scale => {
|
||||
let factor = stack.pop().ok_or("stack underflow")?.as_float()?;
|
||||
let parent = time_stack.last().ok_or("time stack underflow")?;
|
||||
time_stack.push(TimeContext {
|
||||
start: parent.start,
|
||||
duration: parent.duration * factor,
|
||||
subdivisions: None,
|
||||
iteration_index: parent.iteration_index,
|
||||
});
|
||||
}
|
||||
|
||||
Op::Pop => {
|
||||
if time_stack.len() <= 1 {
|
||||
return Err("cannot pop root time context".into());
|
||||
}
|
||||
time_stack.pop();
|
||||
}
|
||||
|
||||
Op::Subdivide => {
|
||||
let n = stack.pop().ok_or("stack underflow")?.as_int()? as usize;
|
||||
if n == 0 {
|
||||
return Err("subdivide count must be > 0".into());
|
||||
}
|
||||
let time_ctx = time_stack.last_mut().ok_or("time stack underflow")?;
|
||||
let sub_duration = time_ctx.duration / n as f64;
|
||||
let mut subs = Vec::with_capacity(n);
|
||||
for i in 0..n {
|
||||
subs.push((time_ctx.start + sub_duration * i as f64, sub_duration));
|
||||
}
|
||||
time_ctx.subdivisions = Some(subs);
|
||||
}
|
||||
|
||||
Op::Each => {
|
||||
let (sound, params) = cmd.take().ok_or("no sound set")?;
|
||||
let time_ctx = time_stack.last().ok_or("time stack underflow")?;
|
||||
let subs = time_ctx
|
||||
.subdivisions
|
||||
.as_ref()
|
||||
.ok_or("each requires subdivide first")?;
|
||||
for (sub_start, sub_dur) in subs {
|
||||
let mut pairs = vec![("sound".into(), sound.clone())];
|
||||
pairs.extend(params.iter().cloned());
|
||||
if *sub_start > 0.0 {
|
||||
pairs.push(("delta".into(), sub_start.to_string()));
|
||||
}
|
||||
if !pairs.iter().any(|(k, _)| k == "dur") {
|
||||
pairs.push(("dur".into(), sub_dur.to_string()));
|
||||
}
|
||||
if let Some(idx) = pairs.iter().position(|(k, _)| k == "delaytime") {
|
||||
let ratio: f64 = pairs[idx].1.parse().unwrap_or(1.0);
|
||||
pairs[idx].1 = (ratio * sub_dur).to_string();
|
||||
} else {
|
||||
pairs.push(("delaytime".into(), sub_dur.to_string()));
|
||||
}
|
||||
outputs.push(format_cmd(&pairs));
|
||||
}
|
||||
}
|
||||
|
||||
Op::SetTempo => {
|
||||
let tempo = stack.pop().ok_or("stack underflow")?.as_float()?;
|
||||
let clamped = tempo.clamp(20.0, 300.0);
|
||||
self.vars
|
||||
.lock()
|
||||
.unwrap()
|
||||
.insert("__tempo__".to_string(), Value::Float(clamped, None));
|
||||
}
|
||||
|
||||
Op::ListStart => {
|
||||
stack.push(Value::Marker);
|
||||
}
|
||||
|
||||
Op::ListEnd => {
|
||||
let mut count = 0;
|
||||
let mut values = Vec::new();
|
||||
while let Some(v) = stack.pop() {
|
||||
if v.is_marker() {
|
||||
break;
|
||||
}
|
||||
values.push(v);
|
||||
count += 1;
|
||||
}
|
||||
values.reverse();
|
||||
for v in values {
|
||||
stack.push(v);
|
||||
}
|
||||
stack.push(Value::Int(count, None));
|
||||
}
|
||||
|
||||
Op::ListEndCycle => {
|
||||
let mut values = Vec::new();
|
||||
while let Some(v) = stack.pop() {
|
||||
if v.is_marker() {
|
||||
break;
|
||||
}
|
||||
values.push(v);
|
||||
}
|
||||
if values.is_empty() {
|
||||
return Err("empty cycle list".into());
|
||||
}
|
||||
values.reverse();
|
||||
let idx = ctx.runs % values.len();
|
||||
let selected = values[idx].clone();
|
||||
if let Some(span) = selected.span() {
|
||||
if let Some(trace) = trace_cell.borrow_mut().as_mut() {
|
||||
trace.selected_spans.push(span);
|
||||
}
|
||||
}
|
||||
if let Value::Quotation(quot_ops, body_span) = selected {
|
||||
if let Some(span) = body_span {
|
||||
if let Some(trace) = trace_cell.borrow_mut().as_mut() {
|
||||
trace.executed_spans.push(span);
|
||||
}
|
||||
}
|
||||
let mut trace_opt = trace_cell.borrow_mut().take();
|
||||
self.execute_ops("_ops, ctx, stack, outputs, time_stack, cmd, trace_opt.as_deref_mut())?;
|
||||
*trace_cell.borrow_mut() = trace_opt;
|
||||
} else {
|
||||
stack.push(selected);
|
||||
}
|
||||
}
|
||||
|
||||
Op::ListEndPCycle => {
|
||||
let mut values = Vec::new();
|
||||
while let Some(v) = stack.pop() {
|
||||
if v.is_marker() {
|
||||
break;
|
||||
}
|
||||
values.push(v);
|
||||
}
|
||||
if values.is_empty() {
|
||||
return Err("empty pattern cycle list".into());
|
||||
}
|
||||
values.reverse();
|
||||
let idx = ctx.iter % values.len();
|
||||
let selected = values[idx].clone();
|
||||
if let Some(span) = selected.span() {
|
||||
if let Some(trace) = trace_cell.borrow_mut().as_mut() {
|
||||
trace.selected_spans.push(span);
|
||||
}
|
||||
}
|
||||
if let Value::Quotation(quot_ops, body_span) = selected {
|
||||
if let Some(span) = body_span {
|
||||
if let Some(trace) = trace_cell.borrow_mut().as_mut() {
|
||||
trace.executed_spans.push(span);
|
||||
}
|
||||
}
|
||||
let mut trace_opt = trace_cell.borrow_mut().take();
|
||||
self.execute_ops("_ops, ctx, stack, outputs, time_stack, cmd, trace_opt.as_deref_mut())?;
|
||||
*trace_cell.borrow_mut() = trace_opt;
|
||||
} else {
|
||||
stack.push(selected);
|
||||
}
|
||||
}
|
||||
|
||||
Op::Adsr => {
|
||||
let r = stack.pop().ok_or("stack underflow")?;
|
||||
let s = stack.pop().ok_or("stack underflow")?;
|
||||
let d = stack.pop().ok_or("stack underflow")?;
|
||||
let a = stack.pop().ok_or("stack underflow")?;
|
||||
cmd.set_param("attack".into(), a.to_param_string());
|
||||
cmd.set_param("decay".into(), d.to_param_string());
|
||||
cmd.set_param("sustain".into(), s.to_param_string());
|
||||
cmd.set_param("release".into(), r.to_param_string());
|
||||
}
|
||||
|
||||
Op::Ad => {
|
||||
let d = stack.pop().ok_or("stack underflow")?;
|
||||
let a = stack.pop().ok_or("stack underflow")?;
|
||||
cmd.set_param("attack".into(), a.to_param_string());
|
||||
cmd.set_param("decay".into(), d.to_param_string());
|
||||
cmd.set_param("sustain".into(), "0".into());
|
||||
}
|
||||
|
||||
Op::Stack => {
|
||||
let n = stack.pop().ok_or("stack underflow")?.as_int()? as usize;
|
||||
if n == 0 {
|
||||
return Err("stack count must be > 0".into());
|
||||
}
|
||||
let time_ctx = time_stack.last_mut().ok_or("time stack underflow")?;
|
||||
let sub_duration = time_ctx.duration / n as f64;
|
||||
let mut subs = Vec::with_capacity(n);
|
||||
for _ in 0..n {
|
||||
subs.push((time_ctx.start, sub_duration));
|
||||
}
|
||||
time_ctx.subdivisions = Some(subs);
|
||||
}
|
||||
|
||||
Op::Echo => {
|
||||
let n = stack.pop().ok_or("stack underflow")?.as_int()? as usize;
|
||||
if n == 0 {
|
||||
return Err("echo count must be > 0".into());
|
||||
}
|
||||
let time_ctx = time_stack.last_mut().ok_or("time stack underflow")?;
|
||||
// Geometric series: d1 * (2 - 2^(1-n)) = total
|
||||
let d1 = time_ctx.duration / (2.0 - 2.0_f64.powi(1 - n as i32));
|
||||
let mut subs = Vec::with_capacity(n);
|
||||
for i in 0..n {
|
||||
let dur = d1 / 2.0_f64.powi(i as i32);
|
||||
let start = if i == 0 {
|
||||
time_ctx.start
|
||||
} else {
|
||||
time_ctx.start + d1 * (2.0 - 2.0_f64.powi(1 - i as i32))
|
||||
};
|
||||
subs.push((start, dur));
|
||||
}
|
||||
time_ctx.subdivisions = Some(subs);
|
||||
}
|
||||
|
||||
Op::Necho => {
|
||||
let n = stack.pop().ok_or("stack underflow")?.as_int()? as usize;
|
||||
if n == 0 {
|
||||
return Err("necho count must be > 0".into());
|
||||
}
|
||||
let time_ctx = time_stack.last_mut().ok_or("time stack underflow")?;
|
||||
// Reverse geometric: d1 + 2*d1 + 4*d1 + ... = d1 * (2^n - 1) = total
|
||||
let d1 = time_ctx.duration / (2.0_f64.powi(n as i32) - 1.0);
|
||||
let mut subs = Vec::with_capacity(n);
|
||||
for i in 0..n {
|
||||
let dur = d1 * 2.0_f64.powi(i as i32);
|
||||
let start = if i == 0 {
|
||||
time_ctx.start
|
||||
} else {
|
||||
// Sum of previous durations: d1 * (2^i - 1)
|
||||
time_ctx.start + d1 * (2.0_f64.powi(i as i32) - 1.0)
|
||||
};
|
||||
subs.push((start, dur));
|
||||
}
|
||||
time_ctx.subdivisions = Some(subs);
|
||||
}
|
||||
|
||||
Op::For => {
|
||||
let quot = stack.pop().ok_or("stack underflow")?;
|
||||
let time_ctx = time_stack.last().ok_or("time stack underflow")?;
|
||||
let subs = time_ctx
|
||||
.subdivisions
|
||||
.clone()
|
||||
.ok_or("for requires subdivide first")?;
|
||||
|
||||
match quot {
|
||||
Value::Quotation(quot_ops, body_span) => {
|
||||
if let Some(span) = body_span {
|
||||
if let Some(trace) = trace_cell.borrow_mut().as_mut() {
|
||||
trace.executed_spans.push(span);
|
||||
}
|
||||
}
|
||||
for (i, (sub_start, sub_dur)) in subs.iter().enumerate() {
|
||||
time_stack.push(TimeContext {
|
||||
start: *sub_start,
|
||||
duration: *sub_dur,
|
||||
subdivisions: None,
|
||||
iteration_index: Some(i),
|
||||
});
|
||||
let mut trace_opt = trace_cell.borrow_mut().take();
|
||||
self.execute_ops(
|
||||
"_ops,
|
||||
ctx,
|
||||
stack,
|
||||
outputs,
|
||||
time_stack,
|
||||
cmd,
|
||||
trace_opt.as_deref_mut(),
|
||||
)?;
|
||||
*trace_cell.borrow_mut() = trace_opt;
|
||||
time_stack.pop();
|
||||
}
|
||||
}
|
||||
_ => return Err("expected quotation".into()),
|
||||
}
|
||||
}
|
||||
|
||||
Op::LocalCycleEnd => {
|
||||
let mut values = Vec::new();
|
||||
while let Some(v) = stack.pop() {
|
||||
if v.is_marker() {
|
||||
break;
|
||||
}
|
||||
values.push(v);
|
||||
}
|
||||
if values.is_empty() {
|
||||
return Err("empty local cycle list".into());
|
||||
}
|
||||
values.reverse();
|
||||
let time_ctx = time_stack.last().ok_or("time stack underflow")?;
|
||||
let idx = time_ctx.iteration_index.unwrap_or(0) % values.len();
|
||||
let selected = values[idx].clone();
|
||||
if let Some(span) = selected.span() {
|
||||
if let Some(trace) = trace_cell.borrow_mut().as_mut() {
|
||||
trace.selected_spans.push(span);
|
||||
}
|
||||
}
|
||||
if let Value::Quotation(quot_ops, body_span) = selected {
|
||||
if let Some(span) = body_span {
|
||||
if let Some(trace) = trace_cell.borrow_mut().as_mut() {
|
||||
trace.executed_spans.push(span);
|
||||
}
|
||||
}
|
||||
let mut trace_opt = trace_cell.borrow_mut().take();
|
||||
self.execute_ops("_ops, ctx, stack, outputs, time_stack, cmd, trace_opt.as_deref_mut())?;
|
||||
*trace_cell.borrow_mut() = trace_opt;
|
||||
} else {
|
||||
stack.push(selected);
|
||||
}
|
||||
}
|
||||
|
||||
Op::Apply => {
|
||||
let quot = stack.pop().ok_or("stack underflow")?;
|
||||
match quot {
|
||||
Value::Quotation(quot_ops, body_span) => {
|
||||
if let Some(span) = body_span {
|
||||
if let Some(trace) = trace_cell.borrow_mut().as_mut() {
|
||||
trace.executed_spans.push(span);
|
||||
}
|
||||
}
|
||||
let mut trace_opt = trace_cell.borrow_mut().take();
|
||||
self.execute_ops("_ops, ctx, stack, outputs, time_stack, cmd, trace_opt.as_deref_mut())?;
|
||||
*trace_cell.borrow_mut() = trace_opt;
|
||||
}
|
||||
_ => return Err("expected quotation".into()),
|
||||
}
|
||||
}
|
||||
Op::Ramp => {
|
||||
let curve = stack.pop().ok_or("stack underflow")?.as_float()?;
|
||||
let freq = stack.pop().ok_or("stack underflow")?.as_float()?;
|
||||
let phase = (freq * ctx.beat).fract();
|
||||
let phase = if phase < 0.0 { phase + 1.0 } else { phase };
|
||||
let val = phase.powf(curve);
|
||||
stack.push(Value::Float(val, None));
|
||||
}
|
||||
Op::Range => {
|
||||
let max = stack.pop().ok_or("stack underflow")?.as_float()?;
|
||||
let min = stack.pop().ok_or("stack underflow")?.as_float()?;
|
||||
let val = stack.pop().ok_or("stack underflow")?.as_float()?;
|
||||
stack.push(Value::Float(min + val * (max - min), None));
|
||||
}
|
||||
Op::Noise => {
|
||||
let freq = stack.pop().ok_or("stack underflow")?.as_float()?;
|
||||
let val = perlin_noise_1d(freq * ctx.beat);
|
||||
stack.push(Value::Float(val, None));
|
||||
}
|
||||
}
|
||||
pc += 1;
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
fn perlin_grad(hash_input: i64) -> f64 {
|
||||
let mut h = (hash_input as u64).wrapping_mul(6364136223846793005).wrapping_add(1442695040888963407);
|
||||
h ^= h >> 33;
|
||||
h = h.wrapping_mul(0xff51afd7ed558ccd);
|
||||
h ^= h >> 33;
|
||||
if h & 1 == 0 { 1.0 } else { -1.0 }
|
||||
}
|
||||
|
||||
fn perlin_noise_1d(x: f64) -> f64 {
|
||||
let x0 = x.floor() as i64;
|
||||
let t = x - x0 as f64;
|
||||
let s = t * t * (3.0 - 2.0 * t);
|
||||
let d0 = perlin_grad(x0) * t;
|
||||
let d1 = perlin_grad(x0 + 1) * (t - 1.0);
|
||||
(d0 + s * (d1 - d0)) * 0.5 + 0.5
|
||||
}
|
||||
|
||||
fn binary_op<F>(stack: &mut Vec<Value>, f: F) -> Result<(), String>
|
||||
where
|
||||
F: Fn(f64, f64) -> f64,
|
||||
{
|
||||
let b = stack.pop().ok_or("stack underflow")?.as_float()?;
|
||||
let a = stack.pop().ok_or("stack underflow")?.as_float()?;
|
||||
let result = f(a, b);
|
||||
if result.fract() == 0.0 && result.abs() < i64::MAX as f64 {
|
||||
stack.push(Value::Int(result as i64, None));
|
||||
} else {
|
||||
stack.push(Value::Float(result, None));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn cmp_op<F>(stack: &mut Vec<Value>, f: F) -> Result<(), String>
|
||||
where
|
||||
F: Fn(f64, f64) -> bool,
|
||||
{
|
||||
let b = stack.pop().ok_or("stack underflow")?.as_float()?;
|
||||
let a = stack.pop().ok_or("stack underflow")?.as_float()?;
|
||||
stack.push(Value::Int(if f(a, b) { 1 } else { 0 }, None));
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn format_cmd(pairs: &[(String, String)]) -> String {
|
||||
let parts: Vec<String> = pairs.iter().map(|(k, v)| format!("{k}/{v}")).collect();
|
||||
format!("/{}", parts.join("/"))
|
||||
}
|
||||
1705
crates/forth/src/words.rs
Normal file
1705
crates/forth/src/words.rs
Normal file
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user