@devaloop/devalang 0.0.1-alpha.2 → 0.0.1-alpha.4

package/rust/audio/engine.rs

@@ -0,0 +1,130 @@
+use std::{ collections::HashMap, fs::File, io::BufReader };
+use hound::{ SampleFormat, WavSpec, WavWriter };
+use rodio::{ Decoder, Source };
+
+use crate::core::{
+    parser::statement::Statement,
+    store::variable::VariableTable,
+    utils::path::normalize_path,
+};
+
+const SAMPLE_RATE: u32 = 44100;
+const CHANNELS: u16 = 2;
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct AudioEngine {
+    pub volume: f32,
+    pub variables: VariableTable,
+    pub buffer: Vec<i16>,
+}
+
+impl AudioEngine {
+    pub fn new() -> Self {
+        AudioEngine {
+            volume: 1.0,
+            buffer: vec![],
+            variables: VariableTable::new(),
+        }
+    }
+
+    pub fn mix(&mut self, other: &AudioEngine) {
+        let max_len = self.buffer.len().max(other.buffer.len());
+        self.buffer.resize(max_len, 0);
+
+        for (i, &sample) in other.buffer.iter().enumerate() {
+            self.buffer[i] = self.buffer[i].saturating_add(sample);
+        }
+    }
+
+    pub fn set_duration(&mut self, duration_secs: f32) {
+        let mut total_samples = (duration_secs * (SAMPLE_RATE as f32) * (CHANNELS as f32)) as usize;
+
+        if total_samples % (CHANNELS as usize) != 0 {
+            total_samples += 1;
+        }
+
+        self.buffer.resize(total_samples, 0);
+    }
+
+    pub fn set_variables(&mut self, variables: VariableTable) {
+        self.variables = variables;
+    }
+
+    pub fn generate_wav_file(&mut self, output_dir: &String) -> Result<(), String> {
+        if self.buffer.len() % (CHANNELS as usize) != 0 {
+            self.buffer.push(0);
+            println!("Completed buffer to respect stereo format.");
+        }
+
+        let spec = WavSpec {
+            channels: CHANNELS,
+            sample_rate: SAMPLE_RATE,
+            bits_per_sample: 16,
+            sample_format: SampleFormat::Int,
+        };
+
+        let mut writer = WavWriter::create(output_dir, spec).map_err(|e|
+            format!("Error creating WAV file: {}", e)
+        )?;
+
+        for sample in &self.buffer {
+            writer.write_sample(*sample).map_err(|e| format!("Error writing sample: {:?}", e))?;
+        }
+
+        writer.finalize().map_err(|e| format!("Error finalizing WAV: {:?}", e))?;
+
+        Ok(())
+    }
+
+    pub fn insert(
+        &mut self,
+        filepath: &str,
+        time_secs: f32,
+        dur_sec: f32,
+        effects: Option<HashMap<String, f32>>
+    ) {
+        let normalized_filepath = normalize_path(filepath);
+
+        let file = BufReader::new(
+            File::open(normalized_filepath).expect("Failed to open audio file")
+        );
+        let decoder = Decoder::new(file).expect("Failed to decode audio file");
+
+        // Mono or stereo reading possible here, we will duplicate in L/R
+        let max_mono_samples = (dur_sec * (SAMPLE_RATE as f32)) as usize;
+        let samples: Vec<i16> = decoder.convert_samples().take(max_mono_samples).collect();
+
+        if samples.is_empty() {
+            eprintln!("No samples found in the audio file: {}", filepath);
+            return;
+        }
+
+        // TODO Apply effects here if needed
+        let offset = (time_secs * (SAMPLE_RATE as f32) * (CHANNELS as f32)) as usize;
+        let required_len = offset + samples.len() * (CHANNELS as usize);
+        let padded_required_len = if required_len % 2 == 1 {
+            required_len + 1
+        } else {
+            required_len
+        };
+
+        self.buffer.resize(padded_required_len, 0);
+        self.pad_samples(&samples, time_secs);
+    }
+
+    fn pad_samples(&mut self, samples: &[i16], time_secs: f32) {
+        let offset = (time_secs * (SAMPLE_RATE as f32) * (CHANNELS as f32)) as usize;
+
+        for (i, &sample) in samples.iter().enumerate() {
+            let adjusted_sample = ((sample as f32) * self.volume).round() as i16;
+
+            let left_pos = offset + i * 2;
+            let right_pos = left_pos + 1;
+
+            if right_pos < self.buffer.len() {
+                self.buffer[left_pos] = self.buffer[left_pos].saturating_add(adjusted_sample); // gauche
+                self.buffer[right_pos] = self.buffer[right_pos].saturating_add(adjusted_sample); // droite
+            }
+        }
+    }
+}

package/rust/audio/interpreter.rs

@@ -0,0 +1,143 @@
+use crate::{
+    audio::{ engine::AudioEngine, loader::load_trigger },
+    core::{
+        parser::statement::{ Statement, StatementKind },
+        shared::value::Value,
+        store::variable::VariableTable,
+    },
+};
+
+pub fn interprete_statements(
+    statements: &Vec<Statement>,
+    audio_engine: AudioEngine,
+    entry: String,
+    output: String
+) -> (AudioEngine, f32, f32) {
+    let mut base_bpm = 120.0;
+    let mut base_duration = 60.0 / base_bpm;
+
+    let variable_table = audio_engine.variables.clone();
+
+    let (updated_audio_engine, base_bpm, max_end_time) = execute_audio_statements(
+        audio_engine.clone(),
+        variable_table.clone(),
+        statements.clone(),
+        base_bpm.clone(),
+        base_duration.clone(),
+        0.0,
+        0.0
+    );
+
+    (updated_audio_engine, base_bpm, max_end_time)
+}
+
+pub fn execute_audio_statements(
+    mut audio_engine: AudioEngine,
+    mut variable_table: VariableTable,
+    mut statements: Vec<Statement>,
+    mut base_bpm: f32,
+    mut base_duration: f32,
+    mut max_end_time: f32,
+    mut cursor_time: f32
+) -> (AudioEngine, f32, f32) {
+    for stmt in statements {
+        match &stmt.kind {
+            StatementKind::Load { source, alias } => {
+                variable_table.set(alias.to_string(), Value::String(source.clone()));
+            }
+
+            StatementKind::Let { name } => {
+                variable_table.set(name.to_string(), stmt.value.clone());
+            }
+
+            StatementKind::Tempo => {
+                if let Value::Number(bpm_) = &stmt.value {
+                    base_bpm = *bpm_ as f32;
+                    base_duration = 60.0 / base_bpm;
+                } else {
+                    eprintln!("❌ Invalid tempo value: {:?}", stmt.value);
+                }
+            }
+
+            StatementKind::Trigger { entity, duration } => {
+                if let Some(trigger_val) = variable_table.get(entity) {
+                    let (src, duration_secs) = load_trigger(
+                        trigger_val,
+                        duration,
+                        base_duration,
+                        variable_table.clone()
+                    );
+
+                    audio_engine.insert(&src, cursor_time, duration_secs, None);
+
+                    cursor_time += duration_secs;
+
+                    if cursor_time > max_end_time {
+                        max_end_time = cursor_time;
+                    }
+                } else {
+                    eprintln!("❌ Unknown trigger entity: {}", entity);
+                }
+            }
+
+            StatementKind::Loop => {
+                if let Value::Map(loop_value) = &stmt.value {
+                    let iterator = loop_value.get("iterator");
+                    let body = loop_value.get("body");
+
+                    let loop_count = if let Some(Value::Number(n)) = iterator {
+                        *n as usize
+                    } else {
+                        eprintln!("❌ Loop iterator must be a number: {:?}", iterator);
+                        continue;
+                    };
+
+                    let loop_body = if let Some(Value::Block(body)) = body {
+                        body.clone()
+                    } else {
+                        eprintln!("❌ Loop body must be a block: {:?}", body);
+                        continue;
+                    };
+
+                    for _ in 0..loop_count {
+                        let (loop_engine, _, loop_end_time) = execute_audio_statements(
+                            audio_engine.clone(),
+                            variable_table.clone(),
+                            loop_body.clone(),
+                            base_bpm,
+                            base_duration,
+                            max_end_time,
+                            cursor_time
+                        );
+
+                        audio_engine = loop_engine;
+
+                        // Update time and max_end_time after each loop iteration
+                        cursor_time = loop_end_time;
+                        if loop_end_time > max_end_time {
+                            max_end_time = loop_end_time;
+                        }
+                    }
+                }
+            }
+
+            StatementKind::Bank => {}
+
+            StatementKind::Import { names, source } => {}
+
+            StatementKind::Export { names, source } => {}
+
+            StatementKind::Unknown => {
+                // Ignore unknown statements
+            }
+
+            _ => {
+                eprintln!("Unsupported statement kind: {:?}", stmt);
+            }
+        }
+    }
+
+    audio_engine.set_variables(variable_table);
+
+    (audio_engine, base_bpm, max_end_time)
+}

package/rust/audio/loader.rs

@@ -0,0 +1,46 @@
+use crate::core::{ shared::{ duration::Duration, value::Value }, store::variable::VariableTable };
+
+pub fn load_trigger(
+    trigger: &Value,
+    duration: &Duration,
+    base_duration: f32,
+    variable_table: VariableTable
+) -> (String, f32) {
+    let mut trigger_path = String::new();
+    let mut duration_as_secs = 0.0;
+
+    match trigger {
+        Value::String(src) => {
+            trigger_path = src.to_string();
+        }
+        _ => {
+            eprintln!("❌ Invalid trigger type. Expected a text variable.");
+        }
+    }
+
+    match duration {
+        Duration::Identifier(duration_identifier) => {
+            if duration_identifier == "auto" {
+                duration_as_secs = base_duration;
+            } else if let Some(Value::Number(num)) = variable_table.get(duration_identifier) {
+                duration_as_secs = *num;
+            } else {
+                eprintln!("❌ Invalid duration identifier: {}", duration_identifier);
+            }
+        }
+
+        Duration::Number(num) => {
+            duration_as_secs = *num;
+        }
+
+        Duration::Auto => {
+            duration_as_secs = base_duration;
+        }
+
+        _ => {
+            eprintln!("❌ Invalid duration type. Expected an identifier.");
+        }
+    }
+
+    (trigger_path, duration_as_secs)
+}

package/rust/audio/mod.rs

@@ -1 +1,5 @@
-// TODO Audio engine
+pub mod engine;
+pub mod interpreter;
+pub mod loader;
+pub mod player;
+pub mod render;

package/rust/audio/player.rs

@@ -0,0 +1,54 @@
+use rodio::{ Decoder, OutputStream, OutputStreamHandle, Sink, Source };
+use std::{ fs::File, io::BufReader };
+
+pub struct AudioPlayer {
+    _stream: OutputStream,
+    handle: OutputStreamHandle,
+    sink: Sink,
+    last_path: Option<String>,
+}
+
+impl AudioPlayer {
+    pub fn new() -> Self {
+        let (stream, handle) = OutputStream::try_default().unwrap();
+        let sink = Sink::try_new(&handle).unwrap();
+
+        Self {
+            _stream: stream,
+            handle,
+            sink,
+            last_path: None,
+        }
+    }
+
+    fn load_source(&self, path: &str) -> impl Source<Item = f32> + Send + 'static {
+        let file = File::open(path).unwrap();
+        let reader = BufReader::new(file);
+
+        Decoder::new(reader).unwrap().convert_samples()
+    }
+
+    pub fn play_file_once(&mut self, path: &str) {
+        self.sink.stop();
+        self.sink = Sink::try_new(&self.handle).unwrap();
+
+        self.sink.set_volume(1.0);
+
+        let source = self.load_source(path);
+
+        self.sink.append(source);
+        self.last_path = Some(path.to_string());
+    }
+
+    pub fn replay_last(&mut self) {
+        if let Some(path) = self.last_path.clone() {
+            self.play_file_once(&path);
+        } else {
+            eprintln!("⚠️ No previous audio to replay.");
+        }
+    }
+
+    pub fn wait_until_end(&self) {
+        self.sink.sleep_until_end();
+    }
+}

package/rust/audio/render.rs

@@ -0,0 +1,57 @@
+use std::collections::HashMap;
+
+use crate::{
+    audio::{ engine::AudioEngine, interpreter::interprete_statements },
+    core::{
+        parser::statement::Statement,
+        store::global::GlobalStore,
+    },
+    utils::logger::{ LogLevel, Logger },
+};
+
+pub fn render_audio_with_modules(
+    modules: HashMap<String, Vec<Statement>>,
+    output_dir: &str,
+    global_store: &mut GlobalStore
+) -> HashMap<String, AudioEngine> {
+    let mut result = HashMap::new();
+
+    for (module_name, statements) in modules {
+        let mut global_max_end_time = 0.0;
+        let mut audio_engine = AudioEngine::new();
+
+        // Apply the module's variable table if it exists
+        if let Some(module) = global_store.get_module(&module_name) {
+            audio_engine.set_variables(module.variable_table.clone());
+        }
+
+        // Interpret the statements to fill the audio buffer
+        let (mut audio_engine, module_base_bpm, module_max_end_time) = interprete_statements(
+            &statements,
+            audio_engine,
+            module_name.clone(),
+            output_dir.to_string()
+        );
+
+        // Calculate the module's maximum duration
+        global_max_end_time = module_max_end_time.max(global_max_end_time);
+        audio_engine.set_duration(global_max_end_time);
+
+        // Check if the buffer contains at least one non-zero sample
+        if audio_engine.buffer.iter().all(|&s| s == 0) {
+            let logger = Logger::new();
+
+            logger.log_message(
+                LogLevel::Warning,
+                format!("Module '{}' ignored: silent buffer (no non-zero samples)", module_name).as_str()
+            );
+
+            continue;
+        }
+
+        // Insert only if the module produces sound
+        result.insert(module_name, audio_engine);
+    }
+
+    result
+}

package/rust/cli/build.rs

@@ -1,23 +1,19 @@
-use std::{ thread, time::Duration };
-
 use crate::{
+    audio::render::render_audio_with_modules,
+    config::Config,
     core::{
-        builder::{ build_ast, write_ast_to_file },
-        debugger::Debugger,
-        preprocessor::module::load_all_modules,
-        types::config::DevalangConfig,
-    },
-    runner::executer::execute_statements,
-    utils::{
-        loader::with_spinner,
-        logger::log_message,
-        path::{ find_entry_file, normalize_path },
-        watcher::watch_directory,
+        builder::Builder,
+        debugger::{ lexer::write_lexer_log_file, preprocessor::write_preprocessor_log_file },
+        preprocessor::loader::ModuleLoader,
+        store::global::GlobalStore,
+        utils::path::{ find_entry_file, normalize_path },
     },
+    utils::{ logger::{ LogLevel, Logger }, spinner::with_spinner, watcher::watch_directory },
 };
+use std::{ thread, time::Duration };
 
 pub fn handle_build_command(
-    config: Option<DevalangConfig>,
+    config: Option<Config>,
     entry: Option<String>,
     output: Option<String>,
     watch: bool
@@ -49,26 +45,51 @@ pub fn handle_build_command(
             .unwrap_or(false)
     };
 
+    let logger = Logger::new();
+
+    if fetched_entry.is_empty() {
+        logger.log_message(
+            LogLevel::Error,
+            "Entry path is not specified. Please provide a valid entry path."
+        );
+        std::process::exit(1);
+    }
+    if fetched_output.is_empty() {
+        logger.log_message(
+            LogLevel::Error,
+            "Output directory is not specified. Please provide a valid output directory."
+        );
+        std::process::exit(1);
+    }
+
     let entry_file = find_entry_file(&fetched_entry).unwrap_or_else(|| {
-        eprintln!("❌ index.deva not found in directory: {}", fetched_entry);
+        logger.log_message(
+            LogLevel::Error,
+            &format!("❌ index.deva not found in directory: {}", fetched_entry)
+        );
         std::process::exit(1);
     });
 
-    if watch == true {
-        log_message("Watch mode enabled, waiting for file changes...", "INFO");
+    // SECTION Begin build
+    if fetched_watch {
+        begin_build(entry_file.clone(), fetched_output.clone());
 
-        begin_build(entry_file.clone(), fetched_output.clone(), watch);
+        logger.log_message(
+            LogLevel::Watcher,
+            &format!("Watching for changes in '{}'...", fetched_entry)
+        );
 
         watch_directory(entry_file.clone(), move || {
-            log_message("File change detected, rebuilding...", "INFO");
-            begin_build(entry_file.clone(), fetched_output.clone(), watch);
+            logger.log_message(LogLevel::Watcher, "Detected changes, re-building...");
+
+            begin_build(entry_file.clone(), fetched_output.clone());
         }).unwrap();
     } else {
-        begin_build(entry_file.clone(), fetched_output.clone(), watch);
+        begin_build(entry_file.clone(), fetched_output.clone());
     }
 }
 
-fn begin_build(entry: String, output: String, watch: bool) {
+fn begin_build(entry: String, output: String) {
     let spinner = with_spinner("Building...", || {
         thread::sleep(Duration::from_millis(800));
     });
@@ -78,27 +99,34 @@ fn begin_build(entry: String, output: String, watch: bool) {
     let normalized_entry_file = normalize_path(&entry);
     let normalized_output_dir = normalize_path(&output);
 
-    let global_store = load_all_modules(&normalized_entry_file);
-
-    if let Some(module) = global_store.modules.get(&normalized_entry_file) {
-        let mut module_clone = module.clone();
-
-        let resolved_statements = execute_statements(&mut module_clone);
-
-        let ast = build_ast(&resolved_statements);
-
-        let ast_dir = format!("{}/json", normalized_output_dir.clone());
-        write_ast_to_file(&ast, &ast_dir);
-
-        let debugger = Debugger::new(&module_clone);
-        let debug_dir = format!("{}/debug/", normalized_output_dir.clone());
-        debugger.write_files(debug_dir.as_str(), resolved_statements);
-
-        let success_message = format!(
-            "Build completed successfully in {:.2?}. Output files written to: '{}'",
-            duration.elapsed(),
-            normalized_output_dir
-        );
-        log_message(&success_message, "SUCCESS");
-    }
+    let mut global_store = GlobalStore::new();
+    let module_loader = ModuleLoader::new(&normalized_entry_file, &normalized_output_dir);
+
+    // SECTION Load
+    // NOTE: We use modules in the build command, so we need to load them
+    let (modules_tokens, modules_statements) = module_loader.load_all(&mut global_store);
+
+    // SECTION Write logs
+    write_lexer_log_file(&normalized_output_dir, "lexer_tokens.log", modules_tokens.clone());
+    write_preprocessor_log_file(
+        &normalized_output_dir,
+        "resolved_statements.log",
+        modules_statements.clone()
+    );
+
+    // SECTION Building AST and Audio
+    let builder = Builder::new();
+    builder.build_ast(&modules_statements);
+    builder.build_audio(&modules_statements, &normalized_output_dir, &mut global_store);
+
+    // SECTION Logging
+    let logger = Logger::new();
+    
+    let success_message = format!(
+        "Build completed successfully in {:.2?}. Output files written to: '{}'",
+        duration.elapsed(),
+        normalized_output_dir
+    );
+
+    logger.log_message(LogLevel::Success, &success_message);
 }