molecule-codegen 0.9.2

Code generator for molecule.
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
112
113
114
115
116
117
118
119
120
121
122
123

use std::io;

use case::CaseExt;

use crate::{ast, C_API_VERSION_MIN, VERSION};

#[macro_use]
mod utilities;

mod import;

mod builder;
mod reader;

use self::{builder::GenBuilder, import::GenImport, reader::GenReader};

pub(crate) struct Generator;

impl Generator {
    fn title<W: io::Write>(writer: &mut W, title: &str) -> io::Result<()> {
        writeln!(writer, "/*")?;
        writeln!(writer, " * {}", title)?;
        writeln!(writer, " */")?;
        writeln!(writer)
    }

    fn ifndef<W: io::Write>(o: &mut W, name: &str) -> io::Result<()> {
        let n = name.to_snake().to_uppercase();
        let api_decorator = utilities::API_DECORATOR;
        w!(o, "#ifndef {}_H                                        ", n);
        w!(o, "#define {}_H                                        ", n);
        w!(o, "                                                       ");
        w!(o, "#ifdef __cplusplus                                     ");
        w!(o, "extern \"C\" {{                                        ");
        w!(o, "#endif /* __cplusplus */                               ");
        w!(o, "                                                       ");
        w!(o, "#ifndef {}                              ", api_decorator);
        w!(o, "#define __DEFINE_MOLECULE_API_DECORATOR_{}          ", n);
        w!(o, "#define {}                              ", api_decorator);
        w!(o, "#endif /* {} */                         ", api_decorator);
        Ok(())
    }

    fn endif<W: io::Write>(o: &mut W, name: &str) -> io::Result<()> {
        let n = name.to_snake().to_uppercase();
        let api_decorator = utilities::API_DECORATOR;
        w!(o, "                                                       ");
        w!(o, "#ifdef __DEFINE_MOLECULE_API_DECORATOR_{}           ", n);
        w!(o, "#undef {}                               ", api_decorator);
        w!(o, "#undef __DEFINE_MOLECULE_API_DECORATOR_{}           ", n);
        w!(o, "#endif /* __DEFINE_MOLECULE_API_DECORATOR_{} */     ", n);
        w!(o, "                                                       ");
        w!(o, "#ifdef __cplusplus                                     ");
        w!(o, "}}                                                     ");
        w!(o, "#endif /* __cplusplus */                               ");
        w!(o, "                                                       ");
        w!(o, "#endif /* {}_H */                                   ", n);
        Ok(())
    }

    fn define_version<W: io::Write>(o: &mut W) -> io::Result<()> {
        let molc_ver = semver::Version::parse(VERSION)
            .map(|v| (v.major * 1000 + v.minor) * 1000 + v.patch)
            .unwrap();
        let api_ver_min = semver::Version::parse(C_API_VERSION_MIN)
            .map(|v| (v.major * 1000 + v.minor) * 1000 + v.patch)
            .unwrap();
        w!(o, "#define MOLECULEC_VERSION {}                 ", molc_ver);
        w!(o, "#define MOLECULE_API_VERSION_MIN {}       ", api_ver_min);
        Ok(())
    }
}

impl super::LanguageGenerator for Generator {
    fn generate<W: io::Write>(writer: &mut W, ast: &ast::Ast) -> io::Result<()> {
        writeln!(writer, "// Generated by Molecule {}", VERSION)?;
        writeln!(writer)?;
        Self::define_version(writer)?;
        writeln!(writer)?;
        writeln!(writer, r#"#include "molecule_reader.h""#)?;
        writeln!(writer, r#"#include "molecule_builder.h""#)?;
        writeln!(writer)?;
        Self::ifndef(writer, ast.namespace())?;
        let imports = ast.imports();
        if !imports.is_empty() {
            writeln!(writer)?;
            for import in imports {
                import.gen_import(writer)?;
            }
        }
        writeln!(writer)?;
        Self::title(writer, "Reader APIs")?;
        for decl in ast.major_decls() {
            decl.gen_reader_interfaces(writer)?;
        }
        writeln!(writer)?;
        Self::title(writer, "Builder APIs")?;
        for decl in ast.major_decls() {
            decl.gen_builder_interfaces(writer)?;
        }
        writeln!(writer)?;
        Self::title(writer, "Default Value")?;
        writeln!(writer, r#"#define ____ 0x00"#)?;
        writeln!(writer)?;
        for decl in ast.major_decls() {
            decl.gen_default(writer)?;
        }
        writeln!(writer)?;
        writeln!(writer, r#"#undef ____"#)?;
        writeln!(writer)?;
        Self::title(writer, "Reader Functions")?;
        for decl in ast.major_decls() {
            decl.gen_reader_functions(writer)?;
        }
        writeln!(writer)?;
        Self::title(writer, "Builder Functions")?;
        for decl in ast.major_decls() {
            decl.gen_builder_functions(writer)?;
        }
        Self::endif(writer, ast.namespace())?;
        Ok(())
    }
}