zoisite 0.1.0

Zoisite is a programming language designed specifically for competitive programming.
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

use clap::{Parser, ValueEnum};
use std::process::exit;
use std::{fs, path::Path};
use zoisite::{run_lifecycle, LifecycleOptions};

#[derive(Debug, Clone, ValueEnum, PartialEq)]
enum EmitFormat {
    Syntax,
    Ir,
    Submission,
    Executable,
}

#[derive(Parser, Debug)]
#[command(name = "Zoisite")]
#[clap(author, version, about)]
struct Args {
    #[clap(help = "Path to the Zoisite source file")]
    input: String,

    #[clap(
        long,
        value_enum,
        value_delimiter = ',',
        default_values_t = [EmitFormat::Ir, EmitFormat::Submission, EmitFormat::Executable],
        help = "Comma-separated list of output formats: syntaxx, ir, submission, executable",
        hide_default_value = true,
        hide_possible_values = true,
    )]
    emit: Vec<EmitFormat>,

    #[clap(short = 'O', long = "optimize", help = "Enable optimizations")]
    optimize: bool,

    #[clap(short = 'd', long = "debug", help = "Enable debug information")]
    debug: bool,

    #[clap(long, help = "Additional arguments to pass to clang")]
    clang_args: Option<String>,
}

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

    let base_name = Path::new(&args.input)
        .file_stem()
        .and_then(|s| s.to_str())
        .unwrap_or("output")
        .to_string();

    let source = fs::read_to_string(&args.input)
        .expect("Failed to read source file");

    let clang_args_vec: Vec<String> = args.clang_args
        .iter()
        .flat_map(|s| s.split_whitespace())
        .map(String::from)
        .collect();

    let opts = LifecycleOptions {
        base_name,
        debug: args.debug,
        optimize: args.optimize,
        run_jit: false,
        output_syntax: args.emit.contains(&EmitFormat::Syntax),
        output_ir: args.emit.contains(&EmitFormat::Ir),
        output_submission: args.emit.contains(&EmitFormat::Submission),
        output_executable: args.emit.contains(&EmitFormat::Executable),
        clang_args: clang_args_vec,
    };

    if !run_lifecycle(&source, opts) {
        eprintln!("Compilation failed");
        exit(1);
    }
}