devalang_core/core/preprocessor/resolver/
value.rs

1use std::collections::HashMap;
2
3use crate::core::{
4    preprocessor::{module::Module, resolver::driver::resolve_statement},
5    shared::value::Value,
6    store::global::GlobalStore,
7};
8
9fn find_export_value(name: &str, global_store: &GlobalStore) -> Option<Value> {
10    for (_path, module) in &global_store.modules {
11        if let Some(val) = module.export_table.get_export(name) {
12            return Some(val.clone());
13        }
14    }
15
16    None
17}
18
19pub fn resolve_value(value: &Value, module: &Module, global_store: &mut GlobalStore) -> Value {
20    match value {
21        Value::String(s) => {
22            // Keep raw strings as-is; they may be runtime-evaluated (e.g., expressions)
23            Value::String(s.clone())
24        }
25
26        Value::Identifier(name) => {
27            if let Some(original_val) = module.variable_table.get(name) {
28                return resolve_value(original_val, module, global_store);
29            }
30
31            if let Some(export_val) = find_export_value(name, global_store) {
32                return resolve_value(&export_val, module, global_store);
33            }
34
35            // Leave unresolved identifiers as-is; may be runtime-bound (e.g., foreach variable)
36            Value::Identifier(name.clone())
37        }
38
39        Value::Map(map) => {
40            if let Some(Value::Identifier(entity)) = map.get("entity") {
41                // SECTION Synth
42                if entity == "synth" {
43                    if let Some(Value::Map(synth_data)) = map.get("value") {
44                        let resolved_waveform = synth_data
45                            .get("waveform")
46                            .map(|wf| resolve_value(wf, module, global_store))
47                            .unwrap_or(Value::Null);
48
49                        let resolved_params = synth_data
50                            .get("parameters")
51                            .map(|p| resolve_value(p, module, global_store))
52                            .unwrap_or(Value::Map(HashMap::new()));
53
54                        let mut result = HashMap::new();
55                        result.insert("waveform".to_string(), resolved_waveform);
56                        result.insert("parameters".to_string(), resolved_params);
57
58                        return Value::Map(result);
59                    }
60                }
61            }
62
63            let mut resolved = HashMap::new();
64            for (k, v) in map {
65                resolved.insert(k.clone(), resolve_value(v, module, global_store));
66            }
67
68            Value::Map(resolved)
69        }
70
71        Value::Block(stmts) => {
72            let resolved_stmts = stmts
73                .iter()
74                .map(|stmt| resolve_statement(stmt, module, &module.path, global_store))
75                .collect();
76            Value::Block(resolved_stmts)
77        }
78
79        other => other.clone(),
80    }
81}
devalang_core/core/preprocessor/resolver/value.rs

devalang_core/core/preprocessor/resolver/
value.rs
