clipasm 0.3.2

A strict, typed language for compiling and rendering Video and Audio graphs
Documentation
use crate::model::ValueType;
use crate::program::{ParameterType, StackAccess};
use crate::source::{SourceSpan, Spanned};

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) struct SourceFileSyntax {
    pub(crate) version: Spanned<u32>,
    pub(crate) declarations: Vec<Declaration>,
    pub(crate) statements: Vec<Statement>,
    pub(crate) span: SourceSpan,
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) enum Declaration {
    Config(ConfigDeclaration),
    Import(PathDeclaration),
    External(ExternalDeclaration),
    Input(InputDeclaration),
    Parameter(ParameterDeclaration),
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) struct ExternalDeclaration {
    pub(crate) executable: Option<Spanned<String>>,
    pub(crate) arguments: Option<Vec<ExternalArgumentDeclaration>>,
    pub(crate) semantic_version: Option<Spanned<String>>,
    pub(crate) preserve: Option<Spanned<String>>,
    pub(crate) span: SourceSpan,
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) enum ExternalArgumentDeclaration {
    Text(Spanned<String>),
    File(Spanned<String>),
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) struct ConfigDeclaration {
    pub(crate) video: Option<VideoConfigDeclaration>,
    pub(crate) audio: Option<AudioConfigDeclaration>,
    pub(crate) output: Option<Spanned<String>>,
    pub(crate) span: SourceSpan,
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) struct VideoConfigDeclaration {
    pub(crate) width: Option<Spanned<String>>,
    pub(crate) height: Option<Spanned<String>>,
    pub(crate) fps: Option<Spanned<String>>,
    pub(crate) span: SourceSpan,
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) struct AudioConfigDeclaration {
    pub(crate) sample_rate: Option<Spanned<String>>,
    pub(crate) span: SourceSpan,
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) struct PathDeclaration {
    pub(crate) path: Spanned<String>,
    pub(crate) alias: Spanned<String>,
    pub(crate) span: SourceSpan,
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) struct InputDeclaration {
    pub(crate) name: Spanned<String>,
    pub(crate) value_type: Spanned<ValueType>,
    pub(crate) span: SourceSpan,
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) struct ParameterDeclaration {
    pub(crate) name: Spanned<String>,
    pub(crate) parameter_type: Spanned<ParameterType>,
    pub(crate) default: Option<Scalar>,
    pub(crate) span: SourceSpan,
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) enum Scalar {
    String(Spanned<String>),
    Atom(Spanned<String>),
    Expression(ScalarExpression),
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) enum ScalarExpression {
    String(Spanned<String>),
    Atom(Spanned<String>),
    Reference(Spanned<String>),
    Selector {
        root: Spanned<String>,
        path: Vec<Spanned<String>>,
        span: SourceSpan,
    },
    Unary {
        operator: UnaryOperator,
        operand: Box<Self>,
        span: SourceSpan,
    },
    Binary {
        operator: BinaryOperator,
        left: Box<Self>,
        right: Box<Self>,
        span: SourceSpan,
    },
    Postfix {
        operator: PostfixOperator,
        operand: Box<Self>,
        span: SourceSpan,
    },
}

impl ScalarExpression {
    pub(crate) const fn span(&self) -> &SourceSpan {
        match self {
            Self::String(value) | Self::Atom(value) | Self::Reference(value) => &value.span,
            Self::Selector { span, .. }
            | Self::Unary { span, .. }
            | Self::Binary { span, .. }
            | Self::Postfix { span, .. } => span,
        }
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum UnaryOperator {
    Positive,
    Negative,
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum BinaryOperator {
    Range,
    Add,
    Subtract,
    Multiply,
    Divide,
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum PostfixOperator {
    Percent,
    Milliseconds,
    Seconds,
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) struct Statement {
    pub(crate) expression: Expression,
    pub(crate) output_bindings: OutputBindings,
    pub(crate) span: SourceSpan,
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) enum Expression {
    Reference(Spanned<String>),
    ScalarBinding {
        name: Spanned<String>,
        value: ScalarExpression,
        span: SourceSpan,
    },
    Invocation(Invocation),
    Block(Block),
    String(Spanned<String>),
    Atom(Spanned<String>),
    Scalar(ScalarExpression),
}

impl Expression {
    #[must_use]
    pub(crate) const fn span(&self) -> &SourceSpan {
        match self {
            Self::Reference(value) | Self::String(value) | Self::Atom(value) => &value.span,
            Self::ScalarBinding { span, .. } => span,
            Self::Scalar(expression) => expression.span(),
            Self::Invocation(invocation) => &invocation.span,
            Self::Block(block) => &block.span,
        }
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) struct Invocation {
    pub(crate) access: Option<Spanned<StackAccess>>,
    pub(crate) name: Spanned<String>,
    pub(crate) type_argument: Option<Spanned<ValueType>>,
    pub(crate) arguments: Vec<Argument>,
    pub(crate) body: Option<Block>,
    pub(crate) span: SourceSpan,
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) enum Argument {
    Positional(Expression),
    Named {
        name: Spanned<String>,
        value: Expression,
    },
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) struct Block {
    pub(crate) access: Option<Spanned<StackAccess>>,
    pub(crate) statements: Vec<Statement>,
    pub(crate) span: SourceSpan,
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) enum OutputBindings {
    None,
    One(Spanned<String>),
    Many(Vec<Spanned<String>>, SourceSpan),
}