vesti 0.14.1

A preprocessor that compiles into LaTeX
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

#![allow(clippy::enum_variant_names)]
#![allow(clippy::derive_partial_eq_without_eq)]
#![allow(clippy::needless_return)]
#![deny(bindings_with_variant_name)]

mod codegen;
mod commands;
mod compile;
mod constants;
mod error;
mod lexer;
mod location;
mod parser;
mod vesmodule;

use std::fs;
use std::process::ExitCode;

use clap::Parser;

use crate::commands::{LatexEngineType, VestiOpt};
use crate::compile::VestiCompiler;
use crate::error::VestiErr;

fn main() -> ExitCode {
    let args = commands::VestiOpt::parse();

    match args {
        VestiOpt::Clear => match fs::remove_dir_all(constants::VESTI_LOCAL_DUMMY_DIR) {
            Ok(_) => ExitCode::SUCCESS,
            Err(err) => {
                eprintln!("{err}");
                return ExitCode::FAILURE;
            }
        },
        ref argument @ VestiOpt::Compile {
            has_sub_vesti,
            emit_tex_only,
            compile_limit,
            no_color,
            watch,
            use_old_bracket,
            ..
        } => {
            let pretty_print = if no_color {
                crate::error::pretty_print::plain_print
            } else {
                crate::error::pretty_print::pretty_print
            };

            let file_lists = match args.take_filename() {
                Ok(inner) => inner,
                Err(err) => {
                    pretty_print(None, err, None).unwrap();
                    return ExitCode::FAILURE;
                }
            };

            let engine_type = match argument.get_latex_type() {
                Ok(LatexEngineType::Invalid) => {
                    let err = VestiErr::make_util_err(error::VestiUtilErrKind::InvalidLaTeXEngine);
                    pretty_print(None, err, None).unwrap();
                    return ExitCode::FAILURE;
                }
                Ok(engine) => engine,
                Err(err) => {
                    pretty_print(None, err, None).unwrap();
                    return ExitCode::FAILURE;
                }
            };

            let use_old_bracket = match commands::get_use_old_bracket_status() {
                Ok(val) => use_old_bracket || val,
                Err(err) => {
                    pretty_print(None, err, None).unwrap();
                    return ExitCode::FAILURE;
                }
            };

            let mut compiler = match VestiCompiler::init(
                &file_lists,
                engine_type,
                has_sub_vesti,
                emit_tex_only,
                compile_limit,
                no_color,
                use_old_bracket,
                watch,
            ) {
                Ok(compiler) => compiler,
                Err(err) => {
                    pretty_print(None, err, None).unwrap();
                    return ExitCode::FAILURE;
                }
            };

            compiler.run()
        }
    }
}