clipasm 0.2.1

A strict, typed, stack-based programmatic video compiler
Documentation
use std::collections::BTreeMap;
use std::path::PathBuf;

use serde::Serialize;

use crate::diagnostic::{Diagnostic, Result};
use crate::program::{InputSlot, ParameterValue, ResolvedCall, ResolvedInput};
use crate::source::Spanned;

pub(crate) const EXTERNAL_PROTOCOL_VERSION: u32 = 1;

#[derive(Clone, Debug, Serialize)]
pub(crate) struct ExternalInvocation {
    pub(crate) executable: Spanned<PathBuf>,
    pub(crate) arguments: Vec<ExternalArgumentValue>,
    pub(crate) preserve_input: String,
    pub(crate) inputs: BTreeMap<String, crate::model::ValueRef>,
    pub(crate) parameters: BTreeMap<String, ExternalParameterValue>,
}

#[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::new(
                    "E_INVALID_EXTERNAL_PROGRAM",
                    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::new(
                            "E_INVALID_EXTERNAL_PROGRAM",
                            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,
        })
    }
}

#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
#[serde(tag = "kind", rename_all = "snake_case")]
pub(crate) enum ExternalArgumentValue {
    Text { value: String },
    File { path: Spanned<PathBuf> },
}

#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
#[serde(untagged)]
pub(crate) enum ExternalParameterValue {
    Integer(i64),
    Keyword(String),
    File(Spanned<PathBuf>),
}