enalang 0.2.0

Exhaustingly Notorious Algorithms - umbrella package
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
134
135
136
137
138
139
140
141
142
143
144
145

use std::time;
use clap::{Args, Parser, Subcommand};
use colored::Colorize;

#[derive(Parser)]
#[command(author, version, about, long_about = None)]
#[command(propagate_version = true)]
struct Cli {
    #[command(subcommand)]
    command: Commands,
}

#[derive(Subcommand)]
enum Commands {
    /// Compile given files for future execution
    Compile(Compile),
    /// Runs IR files
    Run(Run),
    /// Combines several IR files into one
    Link(Link),
}

#[derive(Args)]
struct Link {
    /// Files to merge
    files: Vec<String>,
    /// Output file
    #[arg(short, long)]
    output: Option<String>,
}

#[derive(Args)]
struct Compile {
    /// Files to compile
    files: Vec<String>,
    /// Output file
    #[arg(short, long)]
    output: Option<String>,
    /// Prints ir before exit
    #[arg(short, long, default_value_t = false)]
    print_ir: bool,
}

#[derive(Args)]
struct Run {
    /// File to run
    file: String,
    /// Block to start execution from
    #[arg(short, long)]
    main_word: Option<String>,
    /// Enable stack debugging
    #[arg(long, default_value_t = false)]
    debug_stack: bool,
    /// Enable or disable GC
    #[arg(long, default_value_t = true)]
    gc: bool,
    /// Whether to debug GC
    #[arg(long, default_value_t = false)]
    debug_gc: bool,
    /// Whether to debug calls
    #[arg(long, default_value_t = false)]
    debug_calls: bool,
}

fn compile(c: Compile) {
    let mut ena = enalang::Ena::new(enalang::EnaOptions::default());
    if let Err(e) = ena.read_files(&c.files[..]) {
        ena.report_error_and_exit(e);
    }
    if let Err(e) = ena.parse_files() {
        ena.report_error_and_exit(e);
    }
    if let Err(e) = ena.compile_files() {
        ena.report_error_and_exit(e);
    }
    if let Err(e) = ena.link_files() {
        ena.report_error_and_exit(e);
    }
    if let Err(e) = ena.save(&c.output.unwrap_or("output.enair".to_string())) {
        ena.report_error_and_exit(e);
    }

    if c.print_ir {
        println!("{:#?}", ena.ir.unwrap());
    }
}

fn link(l: Link) {
    let mut ena = enalang::Ena::new(enalang::EnaOptions::default());
    if let Err(e) = ena.load_irs(&l.files[..]) {
        ena.report_error_and_exit(e);
    }
    // if let Err(e) = ena.link_files() {
    //     ena.report_error_and_exit(e);
    // }
    if let Err(e) = ena.save(&l.output.unwrap_or("output.enair".to_string())) {
        ena.report_error_and_exit(e);
    }
}

fn run(r: Run) {
    let mut ena = enalang::Ena::new(enalang::EnaOptions {
        debug_gc: r.debug_gc,
        gc: r.gc,
        debug_stack: r.debug_stack,
        debug_calls: r.debug_calls,
    });
    match ena.load_ir(&r.file) {
        Err(e) => {
            ena.report_error_and_exit(e);
        }
        Ok(e) => {
            ena.ir = Some(e);
        }
    }
    if let Err(e) = ena.run(&r.main_word.unwrap_or("main".to_string())) {
        ena.report_error_and_exit(e);
    }
}

fn main() {
    let args = Cli::parse();

    match args.command {
        Commands::Compile(c) => {
            let begin = time::Instant::now();
            compile(c);
            println!(
                "Compilation {} in {:?}",
                "successful".bold().green(),
                begin.elapsed()
            );
        }
        Commands::Link(l) => {
            let begin = time::Instant::now();
            link(l);
            println!(
                "Linking {} in {:?}",
                "successful".bold().green(),
                begin.elapsed()
            );
        }
        Commands::Run(r) => run(r),
    };
}