lmntalc 0.13.1

A compiler for the LMNtal language
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

use clap::ValueEnum;
use lmntalc_core::{
    codegen::IRSet,
    diagnostics::{Diagnostic, DiagnosticStage},
    model::guard::ProcessConstraint,
};

mod common;
pub mod cpp;
pub mod java;
pub mod python;

#[derive(Debug, Clone, Copy)]
pub enum Target {
    Cpp,
    Python,
    Java,
}

impl Target {
    pub fn extension(&self) -> &'static str {
        match self {
            Target::Cpp => "cpp",
            Target::Python => "py",
            Target::Java => "java",
        }
    }

    pub fn emit(self, ir_set: &IRSet) -> Result<String, BackendError> {
        match self {
            Target::Cpp => cpp::CppBackend::new().emit(ir_set),
            Target::Python => python::PythonBackend::new().emit(ir_set),
            Target::Java => java::JavaBackend::new().emit(ir_set),
        }
    }
}

impl ValueEnum for Target {
    fn value_variants<'a>() -> &'a [Self] {
        &[Target::Cpp, Target::Python, Target::Java]
    }

    fn to_possible_value(&self) -> Option<clap::builder::PossibleValue> {
        Some(match self {
            Target::Cpp => clap::builder::PossibleValue::new("cpp").alias("c++"),
            Target::Python => clap::builder::PossibleValue::new("python").alias("py"),
            Target::Java => clap::builder::PossibleValue::new("java"),
        })
    }
}

#[derive(Debug)]
pub enum BackendError {
    UnsupportedConstraint { constraint: ProcessConstraint },
    UnsupportedFunction { function: String },
    UnsupportedData { kind: &'static str },
    UnsupportedInstruction { instruction: &'static str },
    UnsupportedOperator { operator: &'static str },
    MissingVariableType { variable_id: usize },
}

impl std::fmt::Display for BackendError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            BackendError::UnsupportedConstraint { constraint } => {
                write!(f, "backend does not support constraint {}", constraint)
            }
            BackendError::UnsupportedFunction { function } => {
                write!(f, "backend does not support function {}", function)
            }
            BackendError::UnsupportedData { kind } => {
                write!(f, "backend does not support {} data yet", kind)
            }
            BackendError::UnsupportedInstruction { instruction } => {
                write!(f, "backend does not support instruction {}", instruction)
            }
            BackendError::UnsupportedOperator { operator } => {
                write!(f, "backend does not support operator {}", operator)
            }
            BackendError::MissingVariableType { variable_id } => {
                write!(
                    f,
                    "missing inferred type for temporary variable {}",
                    variable_id
                )
            }
        }
    }
}

impl std::error::Error for BackendError {}

impl BackendError {
    pub fn diagnostic(&self) -> Diagnostic {
        Diagnostic::error(DiagnosticStage::Backend, self.to_string(), None)
    }
}

pub trait Backend {
    fn new() -> Self;
    fn emit(&mut self, generator: &IRSet) -> Result<String, BackendError>;
}