clipasm 0.5.0

A strict, typed language for compiling and rendering Video and Audio graphs
Documentation
use std::collections::BTreeMap;
use std::path::PathBuf;

use crate::diagnostic::{BuiltinDiagnostic, Diagnostic, Result};
use crate::external::{ExternalArgumentValue, ExternalInvocation, ExternalParameterValue};
use crate::source::Spanned;

use super::{InputSlot, ParameterValue, ResolvedCall, ResolvedInput};

#[derive(Clone, Debug)]
pub(crate) struct ExternalRuntime {
    executable: Spanned<PathBuf>,
    arguments: Vec<ExternalArgumentValue>,
    preserve_input: InputSlot,
    parameter_defaults: Vec<Option<Spanned<ParameterValue>>>,
}

impl ExternalRuntime {
    pub(crate) fn new(
        executable: Spanned<PathBuf>,
        arguments: Vec<ExternalArgumentValue>,
        preserve_input: InputSlot,
        parameter_defaults: Vec<Option<Spanned<ParameterValue>>>,
    ) -> Self {
        Self {
            executable,
            arguments,
            preserve_input,
            parameter_defaults,
        }
    }

    pub(crate) fn invocation(&self, call: &ResolvedCall) -> Result<ExternalInvocation> {
        let inputs = call
            .inputs()
            .map(|(input, binding)| match binding {
                ResolvedInput::One(value) => Ok((input.name.clone(), *value)),
                ResolvedInput::Variadic(_) => Err(Diagnostic::builtin(
                    BuiltinDiagnostic::InvalidExternalProgram,
                    format!(
                        "external input `{}` unexpectedly became variadic",
                        input.name
                    ),
                    call.origin().span.clone(),
                )),
            })
            .collect::<Result<BTreeMap<_, _>>>()?;
        let parameters = call
            .parameters()
            .enumerate()
            .filter_map(|(index, (descriptor, value))| {
                value
                    .or_else(|| self.parameter_defaults[index].as_ref())
                    .map(|value| (descriptor, value))
            })
            .map(|(descriptor, value)| {
                let parameter = match &value.value {
                    ParameterValue::Integer(value) => ExternalParameterValue::Integer(*value),
                    ParameterValue::Keyword(value) => {
                        ExternalParameterValue::Keyword(value.clone())
                    }
                    ParameterValue::File(path) => {
                        ExternalParameterValue::File(Spanned::new(path.clone(), value.span.clone()))
                    }
                    ParameterValue::Number(_)
                    | ParameterValue::Duration(_)
                    | ParameterValue::TimeRange(_) => {
                        return Err(Diagnostic::builtin(
                            BuiltinDiagnostic::InvalidExternalProgram,
                            format!(
                                "external parameter `{}` uses an unsupported runtime type",
                                descriptor.name
                            ),
                            value.span.clone(),
                        ));
                    }
                };
                Ok((descriptor.name.clone(), parameter))
            })
            .collect::<Result<BTreeMap<_, _>>>()?;
        let (preserved, _) = call.input_binding(self.preserve_input);
        Ok(ExternalInvocation {
            executable: self.executable.clone(),
            arguments: self.arguments.clone(),
            preserve_input: preserved.name.clone(),
            inputs,
            parameters,
        })
    }
}