protospec-build 0.3.0

One binary format language to rule them all, One binary format language to find them, One binary format language to bring them all and in the darkness bind them.
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
103
104
105
106
107
108
109
110
111

use super::*;

mod resolve;

mod ffi;

mod import;

mod field;

mod const_;

impl Program {
    pub fn from_ast<'a, T: ImportResolver + 'static>(
        ast: &ast::Program,
        resolver: &'a T,
    ) -> AsgResult<Program> {
        let mut cached_imports: IndexMap<String, Program> = IndexMap::new();

        Program::from_ast_imports(ast, resolver, &mut cached_imports)?;
        Program::from_ast_imported(ast, resolver, &cached_imports)
    }

    fn from_ast_imported<T: ImportResolver + 'static>(
        ast: &ast::Program,
        resolver: &T,
        import_cache: &IndexMap<String, Program>,
    ) -> AsgResult<Program> {
        let program = Arc::new(RefCell::new(Program {
            types: IndexMap::new(),
            consts: IndexMap::new(),
            transforms: IndexMap::new(),
            functions: IndexMap::new(),
        }));

        {
            let mut return_fields = vec![];
            let scope = Arc::new(RefCell::new(Scope {
                parent_scope: None,
                program: program.clone(),
                declared_fields: IndexMap::new(),
                declared_inputs: IndexMap::new(),
            }));

            // import ffis
            for declaration in ast.declarations.iter() {
                match declaration {
                    ast::Declaration::Ffi(ffi) => {
                        Scope::convert_ffi_declaration(ffi, resolver, &*program)?;
                    }
                    _ => (),
                }
            }

            // handle file imports
            for declaration in ast.declarations.iter() {
                match declaration {
                    ast::Declaration::Import(import) => {
                        Scope::convert_import_declaration(import, resolver, &*program, import_cache)?;
                    }
                    _ => (),
                }
            }

            // consts and enums
            for declaration in ast.declarations.iter() {
                match declaration {
                    ast::Declaration::Type(type_) if matches!(type_.value.type_.raw_type, ast::RawType::Enum(_) | ast::RawType::Bitfield(_)) => {
                        let field = Scope::convert_type_declaration(type_, &*program)?;
                        let scope = Scope::convert_ast_field_arguments(&scope, &field, Some(&type_.arguments[..]))?;
                        Scope::convert_ast_field(&scope, &type_.value, &field)?;
                    }
                    ast::Declaration::Const(const_) => {
                        Scope::convert_const_declaration(const_, &*program, &scope)?;
                    }
                    _ => (),
                }
            }

            // remaining fields
            for declaration in ast.declarations.iter() {
                match declaration {
                    ast::Declaration::Type(type_) if !matches!(type_.value.type_.raw_type, ast::RawType::Enum(_) | ast::RawType::Bitfield(_)) => {
                        let field = Scope::convert_type_declaration(type_, &*program)?;
                        return_fields.push((type_, field));
                    }
                    _ => (),
                }
            }

            // convert arguments
            let mut sub_scopes = vec![];
            for (type_, field) in &return_fields {
                sub_scopes.push(Scope::convert_ast_field_arguments(&scope, &field, Some(&type_.arguments[..]))?);
            }

            // convert rest
            for ((type_, field), sub_scope) in return_fields.into_iter().zip(sub_scopes.iter()) {
                Scope::convert_ast_field(sub_scope, &type_.value, &field)?;
            }
        }

        let program = Arc::try_unwrap(program)
            .ok()
            .expect("leaked program arc")
            .into_inner();

        program.scan_cycles();
        Ok(program)
    }
}