path: root/src/macro_processor/main.rs

use skaldpress::macro_processor::MacroProcessor;
use std::env;
use std::fs;
use std::io;
use std::io::Write;

fn repl() {
    println!("=Skaldpress Macro Processor (REPL)");
    println!(" type \"quit\" to exit");
    let mut macro_processor = MacroProcessor::new();
    loop {
        let mut input = String::new();
        loop {
            print!("> ");
            let _ = io::stdout().flush();
            let mut _input = String::new();
            io::stdin()
                .read_line(&mut _input)
                .expect("error: unable to read user input");
            if _input == "\n" {
                input.pop();
                break;
            }
            if _input == "quit\n" {
                std::process::exit(0);
            }
            input.push_str(&_input);
        }
        println!("\x1b[32m=INPUT\x1b[0m\n{:#?}", input);
        println!("\x1b[32m=PROCESSING\x1b[0m");
        match macro_processor.process_input(&input) {
            Ok(out) => println!("\x1b[32m=OUTPUT\x1b[0m\n{}", out),
            Err(e) => println!("Error {}", e),
        }
    }
}

fn main() {
    let args: Vec<String> = env::args().collect();

    if args.len() < 2 {
        repl();
        std::process::exit(0);
    }

    let input_file = match fs::read_to_string(&args[1]) {
        Ok(x) => x,
        Err(e) => {
            println!("Could not read input-file \"{}\": {}", args[1], e);
            std::process::exit(1);
        }
    };

    let mut macro_processor = MacroProcessor::new();
    match macro_processor.process_input(&input_file) {
        Ok(out) => println!("{}", out),
        Err(e) => println!("Error {}", e),
    }
}