Struct AudioInterpreter 

pub struct AudioInterpreter {

    pub sample_rate: u32,
    pub bpm: f32,
    pub function_registry: FunctionRegistry,
    pub events: AudioEventList,
    pub variables: HashMap<String, Value>,
    pub groups: HashMap<String, Vec<Statement>>,
    pub banks: BankRegistry,
    pub automation_registry: AutomationRegistry,
    pub note_automation_templates: HashMap<String, NoteAutomationContext>,
    pub cursor_time: f32,
    pub special_vars: SpecialVarContext,
    pub event_registry: EventRegistry,
    pub midi_manager: Option<Arc<Mutex<MidiManager>>>,
    pub suppress_beat_emit: bool,
    pub suppress_print: bool,
    pub break_flag: bool,
    pub background_event_tx: Option<Sender<AudioEventList>>,
    pub background_event_rx: Option<Receiver<AudioEventList>>,
    pub background_workers: Vec<JoinHandle<()>>,
    pub realtime_print_tx: Option<Sender<(f32, String)>>,
    pub function_call_depth: usize,
    pub returning_flag: bool,
    pub return_value: Option<Value>,
    pub routing: RoutingSetup,
    pub audio_graph: AudioGraph,
    pub schedule_deadline: Option<f32>,
    /* private fields */
}

Fields

sample_rate: u32

bpm: f32

function_registry: FunctionRegistry

events: AudioEventList

variables: HashMap<String, Value>

groups: HashMap<String, Vec<Statement>>

banks: BankRegistry

automation_registry: AutomationRegistry

Registered global automations

note_automation_templates: HashMap<String, NoteAutomationContext>

Per-target note-mode automation contexts (including templates and timing info)

cursor_time: f32

special_vars: SpecialVarContext

event_registry: EventRegistry

midi_manager: Option<Arc<Mutex<MidiManager>>>

suppress_beat_emit: bool

Internal guard to avoid re-entrant beat emission during handler execution

suppress_print: bool

Internal guard to suppress printing during simulated/local interpreter runs

break_flag: bool

Flag used by ‘break’ statement to request breaking out of loops

background_event_tx: Option<Sender<AudioEventList>>

Background worker channel sender/receiver (threads send AudioEventList here)

background_event_rx: Option<Receiver<AudioEventList>>

background_workers: Vec<JoinHandle<()>>

Holds join handles for background workers (optional, can be left running)

realtime_print_tx: Option<Sender<(f32, String)>>

Optional channel used to replay prints in realtime during offline rendering.

function_call_depth: usize

Depth of active function calls. Used to validate ‘return’ usage (only valid inside functions).

returning_flag: bool

Function return state: when executing a function, a return statement sets this flag and stores the returned value here so callers can inspect it.

return_value: Option<Value>

routing: RoutingSetup

Audio routing configuration

audio_graph: AudioGraph

Audio graph (built from routing configuration)

schedule_deadline: Option<f32>

Optional deadline for schedule “during” clause (cutoff time for parent loop)

Implementations

impl AudioInterpreter

pub fn new(sample_rate: u32) -> Self

pub fn interpret(&mut self, statements: &[Statement]) -> Result<Vec<f32>>

pub fn events(&self) -> &AudioEventList

Get reference to collected audio events (for MIDI export)

pub fn current_statement_location(&self) -> Option<(usize, usize)>

Get current statement location for error reporting

pub fn calculate_total_duration(&self, _statements: &[Statement]) -> Result<f32>

Calculate approximate total duration by scanning statements

pub fn collect_events(&mut self, statements: &[Statement]) -> Result<()>

pub fn handle_let(&mut self, name: &str, value: &Value) -> Result<()>

pub fn extract_audio_event( &mut self, target: &str, context: &FunctionContext, ) -> Result<()>

pub fn render_audio(&self) -> Result<Vec<f32>>

pub fn set_bpm(&mut self, bpm: f32)

pub fn samples_per_beat(&self) -> usize

pub fn beat_duration(&self) -> f32

Get duration of one beat in seconds

pub fn execute_print(&mut self, value: &Value) -> Result<()>

Execute print statement with variable interpolation Supports {variable_name} syntax

pub fn interpolate_string(&self, template: &str) -> String

Interpolate variables in a string Replaces {variable_name} with the variable’s value

pub fn execute_if( &mut self, condition: &Value, body: &[Statement], else_body: &Option<Vec<Statement>>, ) -> Result<()>

Execute if statement with condition evaluation

pub fn evaluate_condition(&mut self, condition: &Value) -> Result<bool>

Evaluate a condition to a boolean Supports: ==, !=, <, >, <=, >=

pub fn resolve_value(&mut self, value: &Value) -> Result<Value>

Resolve a value (replace identifiers with their values from variables)

pub fn execute_event_handlers(&mut self, event_name: &str) -> Result<()>

Execute event handlers matching the event name

pub fn values_equal(&self, left: &Value, right: &Value) -> bool

Check if two values are equal

pub fn compare_values( &self, left: &Value, right: &Value, ordering: Ordering, ) -> Result<bool>

Compare two values

pub fn handle_assign( &mut self, target: &str, property: &str, value: &Value, ) -> Result<()>

Handle property assignment: target.property = value

pub fn extract_synth_def_from_map( &self, map: &HashMap<String, Value>, ) -> Result<SynthDefinition>

Extract synth definition from a map

pub fn handle_load(&mut self, source: &str, alias: &str) -> Result<()>

Handle MIDI file loading: @load “path.mid” as alias

pub fn handle_bind( &mut self, source: &str, target: &str, options: &Value, ) -> Result<()>

Handle MIDI binding: bind source -> target { options }

pub fn extract_pattern_data( &self, value: &Value, ) -> (Option<String>, Option<HashMap<String, f32>>)

Extract pattern string and options from pattern value

pub fn execute_pattern( &mut self, target: &str, pattern: &str, options: Option<HashMap<String, f32>>, ) -> Result<()>

Execute a pattern with given target and pattern string

pub fn execute_pattern_with_source( &mut self, target: &str, pattern: &str, options: Option<HashMap<String, f32>>, source: Option<&str>, ) -> Result<()>

Execute a pattern with source tracking for routing

pub fn resolve_sample_uri(&self, target: &str) -> String

Resolve sample URI from bank.trigger notation (e.g., myBank.kick -> devalang://bank/devalang.808/kick)

pub fn duration_to_seconds(&self, duration: &DurationValue) -> Result<f32>

Convert a DurationValue to seconds based on current BPM

impl AudioInterpreter

pub fn execute_loop(&mut self, count: &Value, body: &[Statement]) -> Result<()>

pub fn execute_for( &mut self, variable: &str, iterable: &Value, body: &[Statement], ) -> Result<()>