neyuki 0.1.1

A small Lua-like scripting language implemented in Rust
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
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

use std::env;
use std::process;

pub mod ast;
#[path = "../bench/mod.rs"]
mod bench;
mod bytecode;
mod compiler;
mod crypto_lib;
pub mod diagnostics;
mod fs_lib;
#[path = "../fuzz/mod.rs"]
mod fuzz;
mod http_lib;
mod io_lib;
mod lexer;
mod lint;
mod parser;
mod runtime;
pub mod sema;
mod sql_lib;
mod string_lib;
mod tests;
mod vm;

fn main() {
    let args: Vec<String> = env::args().collect();
    if args.len() < 2 {
        eprintln!("Usage: {} <action> [path]", args[0]);
        process::exit(1);
    }

    let action = &args[1];

    if action == "lint" {
        let path = args
            .get(2)
            .map(String::as_str)
            .unwrap_or("examples/hello.nyk");
        if let Err(err) = lint::lint(path) {
            eprintln!("{}", err);
            process::exit(1);
        }
    } else if action == "compile" {
        // The optimizing IR pipeline is the default; `--direct` keeps the
        // older single-pass compiler reachable for comparison.
        let use_direct = args.iter().any(|a| a == "--direct");
        let non_flag_args: Vec<&String> = args
            .iter()
            .skip(2)
            .filter(|a| !a.starts_with('-'))
            .collect();
        let Some(path) = non_flag_args.first() else {
            eprintln!("Usage: {} compile <path> [output] [--direct]", args[0]);
            process::exit(1);
        };
        let compile_res = if use_direct {
            compiler::compile_file_to_bytecode(path)
        } else {
            compiler::compile_file_to_bytecode_via_ir(path)
        };
        match compile_res {
            Ok(bytecode) => {
                let out_path = non_flag_args
                    .get(1)
                    .map(|s| (*s).clone())
                    .unwrap_or_else(|| format!("{}b", path));
                if let Err(err) = std::fs::write(&out_path, &bytecode) {
                    eprintln!("failed to write bytecode to {}: {}", out_path, err);
                    process::exit(1);
                }
                println!(
                    "compiled to bytecode ({}) via {} with magic 'neyuki!' ({} bytes)",
                    out_path,
                    if use_direct {
                        "direct compiler"
                    } else {
                        "IR CFG pipeline"
                    },
                    bytecode.len()
                );
            }
            Err(err) => {
                eprintln!("{}: {}", path, err);
                process::exit(1);
            }
        }
    } else if action == "run" {
        // Programs run on the register VM. `--tree-walker` selects the
        // original AST interpreter instead; `--opt-ir` is accepted for
        // compatibility and means the default.
        let use_tree_walker = args.iter().any(|a| a == "--tree-walker");
        let non_flag_args: Vec<&String> = args
            .iter()
            .skip(2)
            .filter(|a| !a.starts_with('-'))
            .collect();
        let Some(path) = non_flag_args.first() else {
            eprintln!("Usage: {} run <path> [--tree-walker]", args[0]);
            process::exit(1);
        };
        if use_tree_walker {
            if let Err(err) = runtime::run_file(path) {
                eprintln!("runtime error: {}", err);
                process::exit(1);
            }
        } else if let Err(err) = vm::run_file(path) {
            eprintln!("vm error: {}", err);
            process::exit(1);
        }
    } else if action == "dump-ir" {
        // Prints the IR of every function before and after optimization.
        let Some(path) = args.get(2) else {
            eprintln!("Usage: {} dump-ir <path>", args[0]);
            process::exit(1);
        };
        match compiler::compile_file(path) {
            Ok(stmts) => print!("{}", compiler::dump_ir(&stmts)),
            Err(err) => {
                eprintln!("{}: {}", path, err);
                process::exit(1);
            }
        }
    } else if action == "disasm" {
        let use_direct = args.iter().any(|a| a == "--direct");
        let non_flag_args: Vec<&String> = args
            .iter()
            .skip(2)
            .filter(|a| !a.starts_with('-'))
            .collect();
        let Some(path) = non_flag_args.first() else {
            eprintln!("Usage: {} disasm <path> [--direct]", args[0]);
            process::exit(1);
        };
        // A debugging aid: shows what the compiler emits even for sources
        // the type checker would reject.
        let proto_res = compiler::compile_file(path).and_then(|stmts| {
            if use_direct {
                compiler::try_compile_to_proto(&stmts)
            } else {
                compiler::compile_bundled_to_proto(&stmts)
            }
        });
        match proto_res {
            Ok(proto) => print!("{}", bytecode::disasm::disassemble_proto(&proto, 0)),
            Err(err) => {
                eprintln!("{}: {}", path, err);
                process::exit(1);
            }
        }
    } else if action == "test" {
        tests::run_all_tests();
    } else if action == "fuzz" {
        fuzz::run_all_fuzz_tests();
    } else if action == "bench" {
        bench::run_all_benchmarks();
    } else {
        eprintln!("Unknown action: {}", action);
        process::exit(1);
    }
}