crisp 0.4.1

A small, expressive Lisp-inspired programming language.
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

use chumsky::Parser as ChumskyParser;
use clap::builder::styling::{AnsiColor, Effects, Styles};
use clap::{Parser, Subcommand};
use colored::Colorize;
use crisp::parsing::error::print_parse_errors;
use std::fs;
use std::path::PathBuf;

fn help_styles() -> Styles {
    Styles::styled()
        .header(AnsiColor::Green.on_default() | Effects::BOLD)
        .usage(AnsiColor::Green.on_default() | Effects::BOLD)
        .literal(AnsiColor::Cyan.on_default() | Effects::BOLD)
        .placeholder(AnsiColor::Yellow.on_default())
}

#[derive(Parser)]
#[command(
    name = "crisp",
    styles = help_styles(),
    color = clap::ColorChoice::Auto
)]
#[command(about = "A small, expressive Lisp-inspired programming language", long_about = None)]
struct Cli {
    #[command(subcommand)]
    command: Commands,
}

#[derive(Subcommand)]
enum Commands {
    Repl,
    Parse {
        #[arg(value_name = "FILE")]
        file: PathBuf,
    },
}

fn main() {
    let cli = Cli::parse();
    match cli.command {
        Commands::Repl => {
            println!("{} {}", "Starting".cyan(), "Crisp REPL".yellow());
        }
        Commands::Parse { file } => match fs::read_to_string(&file) {
            Ok(source) => {
                println!(
                    "{} {}",
                    "Loaded file:".cyan(),
                    file.display().to_string().yellow()
                );
                let crisp_parsed = crisp::parsing::crip_parser()
                    .parse(&source)
                    .into_output_errors();
                if !crisp_parsed.1.is_empty() {
                    print_parse_errors(&source, &crisp_parsed.1);
                } else {
                    println!("{}", "No errors detected".green());
                }
            }
            Err(err) => {
                eprintln!(
                    "{} Failed to read '{}': {}",
                    "Error:".red().bold(),
                    file.display().to_string().yellow(),
                    err
                );
                std::process::exit(1);
            }
        },
    }
}