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

use verilization_compiler::*;

use std::env;
use std::ffi::OsString;
use lang::{Language, LanguageRegistry, LanguageHandler};


fn command_version() -> Result<i32, VError> {
	let version = env!("CARGO_PKG_VERSION");
	println!("verilization compiler version {} (native)", version);
	Ok(0)
}

fn command_help() -> Result<i32, VError> {
	let help_message = include_str!("help.txt");
	println!("{}", help_message);
	Ok(0)
}

fn command_generate<Lang: Language>(input_files: Vec<OsString>, options: Lang::Options) -> Result<i32, VError> {
	let model = load_files(input_files)?;

	Lang::generate(&model, options, &mut FileOutputHandler {})?;
	Ok(0)
}

struct ParseGenerateCommand<Args: Iterator<Item = OsString>> {
	args: Args,
}

impl <Args: Iterator<Item = OsString>> LanguageHandler for ParseGenerateCommand<Args> {
	type Result = Result<i32, VError>;

	fn run<Lang: Language>(&mut self) -> Self::Result {
		let mut input_files = Vec::new();
		let mut lang_options = Lang::empty_options();
	
	
		while let Some(arg) = self.args.next() {
			match arg.to_str().unwrap() {
				"-i" => {
					if let Some(filename) = self.args.next() {
						input_files.push(filename)
					}
					else {
						println!("Missing value for input file");
						return Ok(1);
					}
				},
	
				arg => {
					if let Some(option) = arg.strip_prefix("-o:") {
						if let Some(value) = self.args.next() {
							Lang::add_option(&mut lang_options, option, value)?;
						}
						else {
							println!("Missing value for option {}", option);
							return Ok(1);
						}
					}
					else {
						println!("Unknown argument: {}", arg);
						return Ok(1);
					}
				}
			}
		}
	
		let lang_options = Lang::finalize_options(lang_options)?;
	
		command_generate::<Lang>(input_files, lang_options)
	}
}

fn parse_args<Args, Registry: LanguageRegistry>(mut args: Args, registry: &Registry) -> Result<i32, VError> where Args : Iterator<Item = OsString> {
	while let Some(arg) = args.next() {
		match arg.to_str().unwrap() {
			"version" | "--version" | "-v" => return command_version(),
			"help" | "--help" | "-h" => return command_help(),
			"generate" => {
				let lang = match args.next() {
					Some(lang) => lang,
					None => {
						println!("Language not specified");
						return Ok(1);
					},
				};

				let lang = lang.to_str().unwrap();

				match registry.handle_language(lang, &mut ParseGenerateCommand { args }) {
					Some(result) => return result,
					None => {
						println!("Unknown language: {}", lang);
						return Ok(1);
					}
				}
			},
				
			arg => {
				println!("Unexpected argument: {}", arg);
				return Ok(1);
			},
		}
	}

	println!("No command specified");
	Ok(1)
}


pub fn main_impl<Registry: LanguageRegistry>(registry: &Registry) {
	let mut args = env::args_os();
	args.next();

	match parse_args(args, registry) {
		Ok(exit_code) => std::process::exit(exit_code),
		Err(err) => {
			println!("{:?}", err);
			std::process::exit(1)
		},
	}
}