use fmt;
use internal::parser;
use internal::interpreter;
use io;
use os;

export fn main() void = {
	let f = os::open("test.ra")!;
	defer io::close(f)!;
	let p = parser::parser {
		h = f,
		state = parser::tokentype::START,
		unreadbuf = ['0'...],
		unreadcount = 0z,
		currentline = 1z,
		end = false,
	};
	
	let it = interpreter::interpreter {
		vars = [],
	};

	for (let ast => parser::parse(&p)) {
		let ast = match (ast) {
		case let a: parser::ast =>
			yield a;
		case let e: parser::error =>
			fmt::fatal(parser::strerror(e));
		};
		interpreter::interpret(&it, ast);
	};
	for (let var .. it.vars) {
		fmt::printfln("{}: {}", var.0, var.1)!;
	};

//	let ast = parser::parse(&p);
//	let ast = match (ast) {
//	case let a: parser::ast =>
//		yield a;
//	case let e: parser::error =>
//		fmt::fatal(parser::strerror(e));
//	};
//	walkast(ast);
//	let it = interpreter::interpreter {
//		vars = [],
//	};
//
//	interpreter::interpret(&it, ast);
//
//	let ast = parser::parse(&p);
//	let ast = match (ast) {
//	case let a: parser::ast =>
//		yield a;
//	case let e: parser::error =>
//		fmt::fatal(parser::strerror(e));
//	};
//	interpreter::interpret(&it, ast);
//
//	for (let var .. it.vars) {
//		fmt::printfln("{}: {}", var.0, var.1)!;
//	};
//
//	let ast = parser::parse(&p);
//	let ast = match (ast) {
//	case let a: parser::ast =>
//		yield a;
//	case let e: parser::error =>
//		fmt::fatal(parser::strerror(e));
//	};
	//interpreter::interpret(&it, ast);

	//let tk = parsetoken(&p);
	//fmt::printfln("tk value: {}\ntk type: {}", tk.value, parser::strtktype(tk.tktype))!;
	//tk = parsetoken(&p);
	//fmt::printfln("tk value: {}\ntk type: {}", tk.value, parser::strtktype(tk.tktype))!;
};

fn walkast(ast: parser::ast) void = {
	match (ast.value) {
	case parser::assign =>
		fmt::println("ASSIGN")!;
	case let v: parser::varname =>
		fmt::printfln("VARNAME: {}", v)!;
	case let v: parser::operation =>
		fmt::print("OPERATION: ")!;
		for (let arg .. v.stack) {
			match (arg) {
			case let i: int =>
				fmt::printf("{} ", i)!;
			case let o: parser::operator =>
				switch (o) {
				case parser::operator::ADD =>
					fmt::print("+ ")!;
				case parser::operator::SUBTRACT =>
					fmt::print("- ")!;
				case parser::operator::MULTIPLY =>
					fmt::print("* ")!;
				case parser::operator::DIVIDE =>
					fmt::print("/ ")!;
				};
			};
		};
		fmt::println()!;
	case =>
		abort();
	};
	for (let c .. ast.children) {
		walkast(c);
	};
};

//fn parsetoken(p: *parser::parser) parser::token = {
//	let tk = match (parser::parsetoken(p)) {
//		case let tk: parser::token =>
//			yield tk;
//		case let e: parser::error =>
//			fmt::fatal(parser::strerror(e));
//	};
//	return tk;
//};