meplang 0.1.8

An EVM low-level language that gives full control over the control flow of the smart contract.
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
124
125
126
127
128
129
130
131
132
133

use meplang::*;
use tracing_subscriber::layer::SubscriberExt;
use tracing_subscriber::util::SubscriberInitExt;

const HELP_MESSAGE: &str = "\
Usage: meplang <COMMAND>\n\n\
Commands:\n\
\tcompile: Compile a Meplang file into EVM bytecode.\n\
\tversion: Print version information.\n\
";

fn main() {
    tracing_subscriber::registry()
        .with(tracing_subscriber::fmt::layer())
        .with(tracing_subscriber::filter::EnvFilter::from_default_env())
        .init();

    let mut args = std::env::args();
    args.next();

    let Some(mode) = args.next() else {
        println!("Meplang - An EVM low-level language.\n\n{}", HELP_MESSAGE);
        return;
    };

    match mode.as_str() {
        "version" => println!("Meplang version: {}", env!("CARGO_PKG_VERSION")),
        "compile" => {
            let mut contract = Option::<String>::None;
            let mut input_file = Option::<String>::None;
            let mut output_file = Option::<String>::None;
            let mut settings = Option::<CompilerSettings>::None;

            while let Some(arg) = args.next() {
                match arg.as_str() {
                    "-c" | "-contract" => {
                        let Some(next) = args.next() else {
                            tracing::error!("Expected an argument after `{}`.", arg);
                            return;
                        };
                        if contract.replace(next).is_some() {
                            tracing::error!("Contract name specified multiple times.");
                            return;
                        }
                    },
                    "-i" | "-input" => {
                        let Some(next) = args.next() else {
                            tracing::error!("Expected an argument after `{}`.", arg);
                            return;
                        };
                        if input_file.replace(next).is_some() {
                            tracing::error!("Input path specified multiple times.");
                            return;
                        }
                    },
                    "-o" | "-output" => {
                        let Some(next) = args.next() else {
                            tracing::error!("Expected an argument after `{}`.", arg);
                            return;
                        };
                        if output_file.replace(next).is_some() {
                            tracing::error!("Output path specified multiple times.");
                            return;
                        }
                    },
                    "-s" | "-settings" => {
                        let Some(next) = args.next() else {
                            tracing::error!("Expected an argument after `{}`.", arg);
                            return;
                        };
                        let decoded: CompilerSettings = match serde_json::from_str(&next) {
                            Ok(decoded) => decoded,
                            Err(err) => {
                                tracing::error!("Unable to decode compiler settings: {}", err);
                                return;
                            },
                        };
                        if settings.replace(decoded).is_some() {
                            tracing::error!("Compiler settings specified multiple times.");
                            return;
                        }
                    },
                    _ => {
                        tracing::error!("Unexpected argument `{}`.", &arg);
                        return;
                    },
                }
            }

            let Some(contract) = contract else {
                tracing::error!("Expected a contract name (-contract <CONTRACT_NAME>).");
                return;
            };

            let Some(input_file) = input_file else {
                tracing::error!("Expected an input file (-input <CONTRACT_NAME>).");
                return;
            };

            match compile_file(input_file.as_str(), contract.as_str(), settings.unwrap_or_default()) {
                Ok(artifacts) => {
                    if let Some(output_file) = output_file {
                        match std::fs::write(&output_file, serde_json::to_string_pretty(&artifacts).unwrap()) {
                            Ok(()) => {
                                println!(
                                    "Contract `{}` bytecode written in the file `{}`.",
                                    contract, output_file
                                );
                                return;
                            },
                            Err(err) => {
                                tracing::error!("{}", err);
                                return;
                            },
                        }
                    } else {
                        println!(
                            "Contract `{}` bytecode: {}",
                            contract,
                            format!("0x{}", hex::encode(artifacts.main_bytecode()))
                        );
                        return;
                    }
                },
                Err(err) => {
                    tracing::error!("{}", err);
                    return;
                },
            }
        },
        _ => tracing::error!("Unexpected command `{}`", mode),
    }
}