parser.rs

use std::rc::Rc;
use std::collections::HashMap;
use std::fmt;
use std::path::Path;
use std::fs::File;
use std::io::Read;
use std::mem::discriminant;

//This pub enum is used to contain all the possible data types of Lmao 
// that live everywhere but the Heap.
#[derive(PartialEq, Clone, Copy, PartialOrd)]
pub enum Value{
	//Signed integers.
	Int8(i8),
	Int16(i16),
	Int32(i32),
	Int64(i64),
	IntSize(isize),

	//Unsigned integers.
	UInt8(u8),
	UInt16(u16),
	UInt32(u32),
	UInt64(u64),
	UIntSize(usize),

	//Specified float types
	Float32(f32),
	Float64(f64),

	//Char and boolean.
	Char(char),
	Boolean(bool),

	//Used to reference items in the heap.
	StringBox(usize),
	ListBox(usize),
	ObjectBox(usize),
	MiscBox(usize),
	NULLBox,
}

//Determines if a translation from one value type to another is valid. 
// Typically the types have to match unless it's nullbox to box stuff.
pub fn is_valid_mutation(a: Value, b: Value) -> bool{
	if discriminant(&a) == discriminant(&b){
		true
	}else{
		match (a, b){
			(Value::NULLBox, Value::StringBox(_)) => true,
			(Value::StringBox(_), Value::NULLBox) => true,
			(Value::NULLBox, Value::ListBox(_)) => true,
			(Value::ListBox(_), Value::NULLBox) => true,
			(Value::NULLBox, Value::ObjectBox(_)) => true,
			(Value::ObjectBox(_), Value::NULLBox) => true,
			(Value::NULLBox, Value::MiscBox(_)) => true,
			(Value::MiscBox(_), Value::NULLBox) => true,
			_ => false,
		}	
	}
}

impl Eq for Value {}

impl fmt::Display for Value{
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result{
		match self {
			Value::Int8(n) => write!(f, "i8 {}", n),
			Value::Int16(n) => write!(f, "i16 {}", n),
			Value::Int32(n) => write!(f, "i32 {}", n),
			Value::Int64(n) => write!(f, "i64 {}", n),
			Value::IntSize(n) => write!(f, "isize {}", n),

			Value::UInt8(n) => write!(f, "u8 {}", n),
			Value::UInt16(n) => write!(f, "u16 {}", n),
			Value::UInt32(n) => write!(f, "u32 {}", n),
			Value::UInt64(n) => write!(f, "u64 {}", n),
			Value::UIntSize(n) => write!(f, "usize {}", n),

			Value::Float32(flt32) => {
				if flt32.abs() <= 1000000.0 && flt32.abs() >= 0.000001{
					write!(f, "f32 {}", flt32)
				}else{
					write!(f, "f32 {:e}", flt32)
				}
			},
			Value::Float64(flt64) => {
				if flt64.abs() <= 1000000.0 && flt64.abs() >= 0.000001{
					write!(f, "f64 {}", flt64)
				}else{
					write!(f, "f64 {:e}", flt64)
				}
			},
			Value::Char(c) => write!(f, "Char \'{}\'", c.escape_default().collect::<String>()),
			Value::Boolean(b) => write!(f, "Boolean {}", b),
			Value::StringBox(sb) => write!(f, "StringBox {}", sb),
			Value::ListBox(lb) => write!(f, "ListBox {}", lb),
			Value::ObjectBox(ob) => write!(f, "ObjectBox {}", ob),
			Value::MiscBox(bn) => write!(f, "MiscBox {}", bn),
			Value::NULLBox => write!(f, "NULLBox"),
		}
	}
}

impl Default for Value{
	fn default() -> Self{
		Value::NULLBox
	}
}

//Used to contain values on the heap only.
#[derive(PartialEq, Eq, Clone)]
pub enum HeapValue{
	String(String),
	List(Vec<Value>),
	Object(HashMap<String, Value>),
	Primitive(Value),
}

//Function used in displaying Lists as well as casting them to strings.
fn stringify_val_vec(ls: &Vec<Value>) -> String{
	let stringified = ls	
		.iter()
		.map(|el| format!("{}", el))
		.collect::<Vec<String>>()
		.join(", ");
	format!("[{}]", stringified)
}

fn stringify_obj(obj: &HashMap<String, Value>) -> String{
	let stringified = obj
		.iter()
		.map(|(k, v)| format!("{}: {}", k, v))
		.collect::<Vec<String>>()
		.join(", ");
	format!("{}{}{}", "{", stringified, "}")
}

impl fmt::Display for HeapValue{
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result{
		match self {
			HeapValue::String(s) => write!(f, "String {:?}", s),
			HeapValue::List(ls) => {
				write!(f, "List {}", stringify_val_vec(ls))
			},
			HeapValue::Object(o) => {
				write!(f, "Object {}", stringify_obj(o))
			},
			HeapValue::Primitive(p) => write!(f, "{}", p),
		}
	}
}

impl Default for HeapValue{
	fn default() -> Self{
		HeapValue::Primitive(Value::default())
	}
}

//Exists in token lists and AST.
#[derive(PartialEq, Eq, Clone)]
pub enum SuperValue{
	Reg(Value), 
	Heap(Box<HeapValue>),
}

impl From<HeapValue> for SuperValue{
	fn from(v: HeapValue) -> Self{
		SuperValue::Heap(Box::new(v))
	}
}

impl From<Value> for SuperValue{
	fn from(v: Value) -> Self{
		SuperValue::Reg(v)
	}
}

impl fmt::Display for SuperValue{
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result{
		match self{
			SuperValue::Reg(r) => write!(f, "{}", r),
			SuperValue::Heap(h) => write!(f, "{}", h),
		}
	}
}

impl Default for SuperValue {
	fn default() -> Self{
		SuperValue::Reg(Value::default())
	}
}

#[derive(Clone, Copy)]
pub enum CastType{
	Usize, Uint8, Uint16, Uint32, Uint64,
	Size, Int8, Int16, Int32, Int64, 
	F32, F64, Char, Bool, StringBox, String, ListBox,
	List, ObjectBox, MiscBox
}
macro_rules! disp_match{
	($target:ident, $form:ident, $($var:ident, $res:literal),* $(,)?) => {
		match $target{
			$(CastType::$var => write!($form, $res),)*
		}	
	};
}

impl fmt::Display for CastType{
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result{
		disp_match!{self, f,
			Usize, "usize",
			Uint8, "u8",	
			Uint16, "u16",	
			Uint32, "u32",	
			Uint64, "u64",	

			Size, "isize",
			Int8, "i8",	
			Int16, "i16",	
			Int32, "i32",	
			Int64, "i64",	

			F32, "f32",
			F64, "f64",
	
			Char, "Char",
			Bool, "Boolean",
		
			StringBox, "StringBox",
			ListBox, "ListBox",
			ObjectBox, "ObjectBox",
			MiscBox, "MiscBox",

			List, "List",
			String, "String",
		}
	}
}

pub enum CastError{
	InvalidCast
}

pub trait TryCast<T>: Sized{
	type CastError;
	
	fn try_cast(v: T, target: CastType) -> Result<Self,Self::CastError>;
}

//Used to make match statement less bloated for conversions.
macro_rules! target_match{
	($target:ident, $($tar:literal, $res:ident),* $(,)?) => {
		match $target{
			$($tar => Ok(CastType::$res),)*
			_ => Err(CastError::InvalidCast)
		}	
	};
}

impl TryCast<&str> for CastType{
	type CastError = CastError;
	fn try_cast(tar: &str, _: CastType) -> Result<Self, Self::CastError>{
		target_match!{tar,
			"usize", Usize,
			"u8", Uint8,
			"u16", Uint16,
			"u32", Uint32,
			"u64", Uint64,

			"isize", Size,
			"i8", Int8,
			"i16", Int16,
			"i32", Int32,
			"i64", Int64,
			
			"f32", F32,
			"f64", F64,

			"Char", Char,
			"Boolean", Bool,

			"StringBox", StringBox,
			"String", String,
			"ListBox", ListBox,
			"ObjectBox", ObjectBox,
			"List", List,
			"MiscBox", MiscBox
		}
	}
}

//Macro that compacts the match statement for integer casting.
macro_rules! integer_match {
	($t:ty, $v:ident, $target:ident, $($var:ident, $cast_to:ident, $type:ty),* $(,)?) => {
		match $target {
			$(CastType::$var => Ok(SuperValue::Reg(Value::$cast_to($v as $type))),)*
			CastType::Bool => Ok(SuperValue::Reg(Value::Boolean($v != (0 as $t)))),
			
			CastType::Char => {
				let char_num = $v as u32;
				if let Some(chr) = std::char::from_u32(char_num){
					Ok(SuperValue::Reg(Value::Char(chr)))
				}else{Err(Self::CastError::InvalidCast)} 
			},

			CastType::StringBox => Ok(Value::StringBox($v as usize).into()),
			CastType::ListBox => Ok(Value::ListBox($v as usize).into()),
			CastType::ObjectBox => Ok(Value::ObjectBox($v as usize).into()),
			CastType::MiscBox => Ok(Value::MiscBox($v as usize).into()),

			CastType::String => Ok(HeapValue::String($v.to_string()).into()),
			
			_ => Err(Self::CastError::InvalidCast)
		}
	};
}

macro_rules! impl_integer_casts {
	//What this block basically says is to loop through zero 
	// or more type arguments given and generate the two impl's below.
	($($t:ty),*) => {
		$(
			impl TryCast<$t> for SuperValue{
				type CastError = CastError;
				fn try_cast(v: $t, target: CastType) -> Result<Self, Self::CastError>{
					integer_match!{$t, v, target, 
						Usize, UIntSize, usize,
						Uint8, UInt8, u8,	
						Uint16, UInt16, u16,	
						Uint32, UInt32, u32,	
						Uint64, UInt64, u64,	

						Size, IntSize, isize,
						Int8, Int8, i8,	
						Int16, Int16, i16,	
						Int32, Int32, i32,	
						Int64, Int64, i64,	
			
						F32, Float32, f32,
						F64, Float64, f64,
					}
				}	
			}
		)*
	}
}

impl_integer_casts!{usize, u8, u16, u32, u64, isize, i8, i16, i32, i64, f32, f64}

//Macro that compacts the match statement for bool casting.
macro_rules! bool_match{
	($v:ident , $target:ident, $($var:ident, $cast_to:ident, $type:ty),* $(,)?) => {
		match $target {
			$(CastType::$var => 
				Ok(SuperValue::Reg(Value::$cast_to((if $v {1} else {0}) as $type))),)*
			CastType::Bool => Ok(Value::Boolean($v).into()),
			CastType::String => Ok(HeapValue::String($v.to_string()).into()),
			_ => Err(Self::CastError::InvalidCast)
		}
	};
}
impl TryCast<bool> for SuperValue{
	type CastError = CastError;
	fn try_cast(v: bool, target: CastType) -> Result<Self, Self::CastError>{
		bool_match!{v, target, 
			Usize, UIntSize, usize,
			Uint8, UInt8, u8,	
			Uint16, UInt16, u16,	
			Uint32, UInt32, u32,	
			Uint64, UInt64, u64,	

			Size, IntSize, isize,
			Int8, Int8, i8,	
			Int16, Int16, i16,	
			Int32, Int32, i32,	
			Int64, Int64, i64,	

			F32, Float32, f32,
			F64, Float64, f64
		}
	}	
}

//Macro that compacts the match statement for Char casting.
macro_rules! char_match{
	($v:ident , $target:ident, $($var:ident, $cast_to:ident, $type:ty),* $(,)?) => {
		match $target {
			$(CastType::$var => Ok(Value::$cast_to(($v as u32) as $type).into()),)*
			CastType::String => Ok(HeapValue::String($v.to_string()).into()),
			_ => Err(Self::CastError::InvalidCast)
		}
	};
}
impl TryCast<char> for SuperValue{
	type CastError = CastError;
	fn try_cast(v: char, target: CastType) -> Result<Self, Self::CastError>{
		char_match!{v, target, 
			Usize, UIntSize, usize,
			Uint8, UInt8, u8,	
			Uint16, UInt16, u16,	
			Uint32, UInt32, u32,	
			Uint64, UInt64, u64,	

			Size, IntSize, isize,
			Int8, Int8, i8,	
			Int16, Int16, i16,	
			Int32, Int32, i32,	
			Int64, Int64, i64,	

			F32, Float32, f32,
			F64, Float64, f64
		}
	}	
}

//Macro that compacts the match statement for String casting.
macro_rules! string_match{
	(&$v:ident , $target:ident, $($var:ident, $cast_to:ident, $type:ty),* $(,)?) => {
		match $target {
			$(CastType::$var => {
				if let Ok(parsed) = $v.parse(){
					Ok(SuperValue::Reg(Value::$cast_to(parsed)))
				}else{
					Err(Self::CastError::InvalidCast)
				}
			},)*
			CastType::List => {
				let char_ls: Vec<Value> = $v	
					.chars()
					.map(|c| Value::Char(c))
					.collect();
				Ok(HeapValue::List(char_ls).into())
			},
			CastType::Bool => {
				match $v.as_str(){
					"True" | "true" => Ok(Value::Boolean(true).into()),
					"False" | "false" => Ok(Value::Boolean(false).into()),
					_ => Err(Self::CastError::InvalidCast)
				}
			}
			_ => Err(Self::CastError::InvalidCast)
		}
	};
}
impl TryCast<&String> for SuperValue{
	type CastError = CastError;
	fn try_cast(v: &String, target: CastType) -> Result<Self, Self::CastError>{
		string_match!{&v, target, 
			Usize, UIntSize, usize,
			Uint8, UInt8, u8,	
			Uint16, UInt16, u16,	
			Uint32, UInt32, u32,	
			Uint64, UInt64, u64,	

			Size, IntSize, isize,
			Int8, Int8, i8,	
			Int16, Int16, i16,	
			Int32, Int32, i32,	
			Int64, Int64, i64,	

			F32, Float32, f32,
			F64, Float64, f64
		}
	}	
}

impl TryCast<&Vec<Value>> for SuperValue{
	type CastError = CastError;
	fn try_cast(v: &Vec<Value>, target: CastType) -> Result<Self, Self::CastError>{
		match target{
			CastType::String => Ok(HeapValue::String(stringify_val_vec(v)).into()),
			_ => Err(Self::CastError::InvalidCast)
		}
	}
}

impl TryCast<&HashMap<String, Value>> for SuperValue{
	type CastError = CastError;
	fn try_cast(v: &HashMap<String, Value>, target: CastType) -> Result<Self, Self::CastError>{
		match target{
			CastType::String => Ok(HeapValue::String(stringify_obj(v)).into()),
			_ => Err(Self::CastError::InvalidCast)
		}
	}
}

#[derive(PartialEq, Eq, Clone, Copy)]
pub enum Operator{
	Add, Sub, Mul, Div, 
	Mod, Pow, 

	UsizeMax, U8Max, U16Max, U32Max, U64Max,  
	IsizeMax, I8Max, I16Max, I32Max, I64Max, 

	Swap, Drop, DropStack, Rot, Dup, DeepDup, 

	Equal, NotEqual, GreaterThan, LessThan, GreaterThanEqualTo,
	LessThanEqualTo, StringCompare, Concat,

	And, Or, Xor, Not,

	Push, Pop, Fpush, Fpop, Index, Length,

	IsEmpty, Clear, Contains, ChangeItemAt,
	
	IsWhitespaceChar, IsAlphaChar, IsNumChar,

	ObjAddField, ObjGetField, ObjMutField, ObjRemField,

	BitOr, BitAnd, BitXor, BitNot, BitShift, Cast,

	PrintLine, ReadLine, PrintChar, ReadChar, Print, Read, 
	DebugPrintStack, DebugPrintHeap,

	FileWrite, FileRead, FileCreate, FileRemove, FileExists,

	QueryType, LeaveScopeIfTrue, ThrowCustomError, GetArgs, 
	IsValidBox, TimeUnixNow, TimeWait, 

	Unknown
}

impl Default for Operator{
	fn default() -> Self{Operator::Unknown}
}
macro_rules! match_call{
	($mac:ident) => {
		$mac!{
			("+", Add), ("-", Sub), ("*", Mul), ("/", Div), 
			("mod", Mod), ("%", Mod), ("pow", Pow),

			("isizeMax", IsizeMax), ("usizeMax", UsizeMax),

			("i8Max", I8Max), ("i16Max", I16Max), ("i32Max", I32Max), 
			("i64Max", I64Max),

			("u8Max", U8Max), ("u16Max", U16Max), ("u32Max", U32Max),
			("u64Max", U64Max),

			("swap", Swap),	("drop", Drop),	("dropStack", DropStack),	
			("rot", Rot), ("dup", Dup),	("deepDup", DeepDup),	

			("==", Equal), ("!=", NotEqual), (">", GreaterThan), ("<", LessThan), 
			(">=", GreaterThanEqualTo), ("<=", LessThanEqualTo), 
			("stringCompare", StringCompare), ("++", Concat),

			("and", And), ("&&", And), ("or", Or), ("||", Or), 
			("xor", Xor), ("not", Not), ("!", Not),

			("push", Push), ("p", Push), ("pop", Pop), ("po", Pop), 
			("fpush", Fpush), ("fp", Fpush), ("fpop", Fpop), ("fpo", Fpop), 
			("index", Index), ("length", Length), ("len", Length),

			("isEmpty", IsEmpty), ("clear", Clear), 
			("contains", Contains), ("changeItemAt", ChangeItemAt),

			("isWhitespaceChar", IsWhitespaceChar), ("isAlphaChar", IsAlphaChar), 
			("isNumChar", IsNumChar),

			("objAddField", ObjAddField), ("objGetField", ObjGetField), 
			("objMutField", ObjMutField), ("objRemField", ObjRemField),

			("bitOr", BitOr), ("|", BitOr), ("bitAnd", BitAnd), 
			("&", BitAnd), ("bitXor", BitXor), ("^", BitXor), ("bitNot", BitNot), 
			("bitShift", BitShift), ("cast", Cast),

			("printLine", PrintLine), ("readLine", ReadLine), 
			("printChar", PrintChar), ("readChar", ReadChar), 
			("print", Print), ("read", Read), ("debugPrintStack", DebugPrintStack), 
			("debugPrintHeap", DebugPrintHeap),

			("fileWrite", FileWrite), ("fileRead", FileRead), 
			("fileCreate", FileCreate), ("fileRemove", FileRemove), 
			("fileExists", FileExists),

			("queryType", QueryType), ("leaveScopeIfTrue", LeaveScopeIfTrue), 
			("throwCustomError", ThrowCustomError), ("getArgs", GetArgs), 
			("isValidBox", IsValidBox), ("timeUnixNow", TimeUnixNow), 
			("timeWait", TimeWait),
		}
	};
}

impl Operator{
	fn new(op_name: &str) -> Self{
		macro_rules! op_match{
			($(($name:literal, $var:ident)),* $(,)?) => {
				match op_name{
					$($name => Operator::$var,)*			
					_ => Operator::Unknown,
				}	
			};
		}	
		match_call!{op_match}	
	}
	pub fn stringify(&self) -> String{
		macro_rules! op_match{
			($(($name:literal, $var:ident)),* $(,)?) => {
				#[allow(unreachable_patterns)]
				match self{
					$(Operator::$var => $name.to_string(),)*			
					_ => "Unknown".to_string(),
				}	
			};
		}
		match_call!{op_match}
	}
}

#[derive(Clone, Eq, PartialEq)]
pub struct FileInfo{
	pub name: String,
	pub program: String,
	pub prog_lines: Vec<String>,
	pub lines: Vec<u32>
}

impl FileInfo{
	fn new(n: &str, prog: &str) -> Self{
		FileInfo{
			name: n.to_string(),
			program: prog.to_string(),
			prog_lines: prog
				.lines()
				.map(|el| el.to_string())
				.collect(),
			lines: Vec::new()
		}
	}
	fn append_line(&mut self, num: u32) {
		self.lines.push(num);
	}
	//Wraps error string in a line number and program line display system.
  	fn err_str_line(&self, err: &str, line_num: u32) -> String{
		let linedex = (line_num - 1) as usize;
  		if linedex > self.prog_lines.len() - 1{
			panic!("Error number that was too big was used!!!! \
			Max: {} Given: {}", self.prog_lines.len() - 1, linedex);
		}
		
		//Error head.
		let invert = "\x1b[7m";
		let reset = "\x1b[0m";
		let line_marker_str = format!("Error in \"{}\" at line {}:", self.name, line_num);

		//Program string with filler following it.
		let p_str = format!("{}", self.prog_lines[linedex]);
		let filler_line = "~".repeat(line_marker_str.chars().count());

		//All put together.
		format!("{}{}{}\n{}\n{}\n{}", invert, line_marker_str, 
		reset, p_str, filler_line, err)
  	}
	//Takes in a token index.
	//Produces an error message with line number or panics if invalid.
	pub fn err_str_tok(&self, msg: &str, idx: usize) -> String{
		if let Some(line) = self.lines.get(idx){
			self.err_str_line(msg, *line)
		}else{
			panic!("Invalid index given for conversion! Given: {} Max: {}", idx, self.lines.len() - 1);
		}
	}
}

//Can either be a value to push to the stack or 
// a command to run an operator or something like that.
#[derive(PartialEq, Eq, Clone)]
pub enum Token{
	Val(SuperValue),
	Op(Operator),
	If,
	Else,
	While,
	Var,
	Loc,
	Box,
	Func,
	Attempt,
	OnError,
	File{file: Rc<FileInfo>, tokens: Vec<Token>},
	Terminator,
	Fragment(String),
	CastTo,
	Defer,
	NOTHING
}

impl Default for Token{
	fn default() -> Self{
		Token::Val(SuperValue::default())
	}
}

impl fmt::Display for Token{
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result{
		match self {
			Token::Val(v) => write!(f, "Value: {}", v),
			Token::Op(o) => write!(f, "Op: {}", o.stringify()),
			Token::If => write!(f, "If"),
			Token::Else => write!(f, "Else"),
			Token::While => write!(f, "While"),
			Token::Var => write!(f, "Var"),
			Token::Loc => write!(f, "Loc"),
			Token::Box => write!(f, "Box"),
			Token::Func => write!(f, "Func"),
			Token::Defer => write!(f, "Defer"),
			Token::Attempt => write!(f, "Attempt"),
			Token::OnError => write!(f, "OnError"),
			Token::Terminator => write!(f, "Terminator: ;"),
			Token::Fragment(frag) => write!(f, "Fragment: {}", frag),
			Token::File{file: fi, tokens: _} => write!(f, "File: {}", fi.name),
			Token::CastTo => write!(f, "CastTo"),
			Token::NOTHING => write!(f, "NOTHING"),
		}
	}
}

#[derive(Copy, Eq, PartialEq, Clone)]
pub enum VarCmd{
	Make,
	Get,
	Mutate,
	Delete,
	Unknown
}

impl VarCmd{
	pub fn new(val: &str) -> Self{
		match val{
			"mak" => VarCmd::Make,
			"get" => VarCmd::Get,
			"mut" => VarCmd::Mutate,
			"del" => VarCmd::Delete,
			_ => VarCmd::Unknown
		}
	}	
}

impl fmt::Display for VarCmd{
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result{
		let cmd_str = match self{
			VarCmd::Make => "mak",
			VarCmd::Get => "get",
			VarCmd::Mutate => "mut",
			VarCmd::Delete => "del",
			VarCmd::Unknown => "UNKNOWN"
		};		

		write!(f, "{}", cmd_str)
	}	
}

#[derive(Copy, Eq, PartialEq, Clone)]
pub enum BoxCmd{
	Free,
	Null,
	Make,
	Open,
	Alter,
	Unknown
}

impl BoxCmd{
	pub fn new(val: &str) -> Self{
		match val{
			"make" => BoxCmd::Make,
			"open" => BoxCmd::Open,
			"altr" => BoxCmd::Alter,
			"null" => BoxCmd::Null,
			"free" => BoxCmd::Free,
			_ => BoxCmd::Unknown
		}
	}	
}

impl fmt::Display for BoxCmd{
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result{
		let cmd_str = match self{
			BoxCmd::Make => "make",
			BoxCmd::Open => "open",
			BoxCmd::Alter => "altr",
			BoxCmd::Null => "null",
			BoxCmd::Free => "free",
			BoxCmd::Unknown => "UNKNOWN"
		};	

		write!(f, "{}", cmd_str)
	}	
}

#[derive(Copy, Eq, PartialEq, Clone)]
pub enum FunCmd{
	Define,
	Call,
	Unknown
}

impl FunCmd{
	pub fn new(val: &str) -> Self{
		match val{
			"def" => FunCmd::Define,
			"call" => FunCmd::Call,
			_ => FunCmd::Unknown,
		}
	}	
}

impl fmt::Display for FunCmd{
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result{
		let cmd_str = match self{
			FunCmd::Define => "def",
			FunCmd::Call => "call",
			FunCmd::Unknown => "UNKNOWN"
		};		

		write!(f, "{}", cmd_str)
	}	
}

#[derive(Clone)]
pub struct FuncData{
	pub cmd: FunCmd,
	pub name: String,
	pub bod: ASTNode,
	pub body_token_count: usize,
	pub start_token_index: usize,
	pub f_file_info: Rc<FileInfo>
}

impl FuncData{
	pub fn new(c: FunCmd, n: &str, b: ASTNode, 
	start: usize, size: usize, fi: Rc<FileInfo>) -> Rc<Self>{
		Rc::new(FuncData{
			cmd: c,
			name: n.to_string(),
			bod: b,
			body_token_count: size,
			start_token_index: start,
			f_file_info: fi
		})
	}
}

#[derive(Clone)]
pub struct IfData{
	pub if_true: ASTNode,
	pub if_false: ASTNode,
	pub if_token_count: usize,
	pub else_token_count: usize
}

impl IfData{
	pub fn new(t: ASTNode, f: ASTNode) -> Box<Self>{
		Box::new(IfData{
			if_true: t, if_false: f,
			if_token_count: 0, 
			else_token_count: 0
		})
	}
}

#[derive(Clone)]
pub struct VarData{
	pub name: String,
	pub cmd: VarCmd,
}

impl VarData{
	fn new(n: &str, c: VarCmd) -> Box<Self>{
		Box::new(VarData{
			name: n.to_string(),
			cmd: c
		})
	}
}

#[derive(Clone)]
pub struct AttErrData{
	pub att: ASTNode,
	pub err: ASTNode,
	pub att_token_count: usize,
	pub err_token_count: usize
}
impl AttErrData{
	fn new(attempt: ASTNode, error: ASTNode) -> Box<Self>{
		Box::new(AttErrData{att: attempt, 
		err: error, att_token_count: 0, err_token_count: 0})
	}
}

#[derive(Clone)]
pub struct FileData{
	pub file: Rc<FileInfo>,	
	pub program: ASTNode
}
impl FileData{
	fn new(f: Rc<FileInfo>, prog: ASTNode) -> Box<Self>{
		Box::new(FileData{file: f, program: prog})
	}
}

#[derive(Clone)]
pub struct WhileData{
	pub body: ASTNode,
	pub token_count: usize
}
impl WhileData{
	fn new(b: ASTNode, count: usize) -> Box<Self>{
		Box::new(WhileData{body: b, token_count: count})
	}
}

#[derive(Clone)]
pub struct DeferData{
	pub body: ASTNode,
	pub token_count: usize,
	pub start_token_index: usize
}
impl DeferData{
	fn new(b: ASTNode, count: usize, start: usize) -> Rc<Self>{
		Rc::new(DeferData{
			body: b, 
			token_count: count, 
			start_token_index: start
		})
	}
}

//The various types of nodes that are part of the Abstract Syntax Tree
#[derive(Clone)]
pub enum ASTNode{
	Op(Operator),
	Val(Value),	
	HeapVal(Box<HeapValue>),
	If(Box<IfData>),
	While(Box<WhileData>),
	Expression(Box<Vec<ASTNode>>),
	Function(Rc<FuncData>),
	Variable(Box<VarData>),
	LocVar(Box<VarData>),
	BoxOp(BoxCmd),
	AttErr(Box<AttErrData>),
	Defer(Rc<DeferData>),
	CastTo(CastType),
	File(Box<FileData>)
}

//Useful for shorthand conversion of ASTNode vec to Expression.
impl From<Vec<ASTNode>> for ASTNode{
	fn from(v: Vec<ASTNode>) -> Self{
		ASTNode::Expression(Box::new(v))	
	}
}

impl Default for ASTNode{
	fn default()->Self{
		ASTNode::Val(Value::NULLBox)
	}
}

impl fmt::Display for ASTNode{
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result{
		match self{
			ASTNode::Op(id) => write!(f, "Operator {}", id.stringify()),
			ASTNode::Val(v) => write!(f, "{}", v),
			ASTNode::HeapVal(hv) => write!(f, "{}", hv),
			ASTNode::If(data) => write!(f, "If [true_branch: {}, false_branch: {}]", data.if_true, data.if_false),
			ASTNode::While(data) => write!(f, "While [{}]", data.body),
			ASTNode::Expression(vec) => {
				let strs: Vec<String> = vec.iter().map(|n| format!("{}", n)).collect();
				write!(f, "Expression [{}]", strs.join(", "))
			},
			ASTNode::Function(data) => {
				write!(f, "Function [cmd: {}, name: {}, body: {}]", data.cmd, data.name, data.bod)
			},
			ASTNode::Variable(data) => write!(f, "Variable [name: {}, cmd: {}]", data.name, data.cmd),
			ASTNode::LocVar(data) => write!(f, "Local Variable [name: {}, cmd: {}]", data.name, data.cmd),
			ASTNode::BoxOp(op) => write!(f, "BoxOp {}", op),
			ASTNode::AttErr(data) => write!(f, "AttErr [attempt: {}, err: {}]", data.att, data.err),
			ASTNode::Defer(data) => write!(f, "Defer [{}]", data.body),
			ASTNode::CastTo(data_type) => write!(f, "CastTo {}", data_type),
			ASTNode::File(data) => write!(f, "File {}", data.file.name)
		}
	}
}

//Uses the implemented format traits to build a string for the given Value type. 
// From there, it only consumes the characters that name the actual type.
// This avoids needing a big match statement. 
pub fn type_to_string(v: Value) -> String{
	let mut chrs = String::new();
	for c in format!("{}", v).chars(){
		if c == ' '{
			break;
		}else{
			chrs.push(c);
		}
	}
	chrs
}

//Takes in a file string and calls the necessary functions 
// to build an AST from it.
pub fn parse_string_to_ast(argv: &Vec<String>, program_string: String) -> Result<ASTNode, String>{
	//Constructs means of checking for duplicate imports.
	let mut imported_files: HashMap<String, ()> = HashMap::new();

	//Handles empty argv.
	let top_file_name: &str;
	if argv.len() > 1{
		top_file_name = &argv[1];
	}else{
		top_file_name = "";
	}

	//Prevents self-importing.
	imported_files.insert(top_file_name.to_string(), ());
	
	let top_file = FileInfo::new(top_file_name, &program_string);
	match tokenize(top_file, &mut imported_files){
		Ok(token) => {
			match make_ast(token){
				Ok(res) => return Ok(res),
				Err(e) => return Err(e),
			}
		},
		Err(e) => return Err(e),	
	}
}

//Tokenizes program string into list of tokens.
pub fn tokenize(mut file: FileInfo, imported: &mut HashMap<String, ()>) 
-> Result<Token, String>
{
	let chars: Vec<char> = file.program.chars().collect();
	let mut tokens: Vec<Token> = Vec::new();
	let mut curr_token: Vec<char> = Vec::new();

	let mut in_string = false;
	let mut in_comment = false;
	let mut in_char = false;

	let mut line = 1;

	let mut i: usize = 0;
	loop{
		if i > chars.len() - 1{
			if in_string{
				let t: String = curr_token.iter().collect();
				let err_str = format!("String \"{}\" not ended with matching double quotation!", t);
				return Err(file.err_str_line(&err_str, line));
			}

			if curr_token.len() > 0{
				match lex_token(&curr_token.iter().collect::<String>()){
					Ok(token) => tokens.push(token),
					Err(e) => return Err(e),
				}
			}
			
			break;
		}

		match (chars[i], in_string, in_comment, in_char){
			//Start of string case.
			('\"', false, false, false) => {
				curr_token.push(chars[i]);
				in_string = true;
			},
			//Makes it so strings can have double quotes inside them, as long as they are escaped.
			('\\', true, false, false) => {
				if ((i + 1) < chars.len()) && (chars[i + 1] == '\"'){
					curr_token.push('\\');
					curr_token.push('\"');
					i += 1;
				}else{
					curr_token.push('\\');
				}
			},
			//End of string case.
			('\"', true, false, false) => {
				curr_token.push(chars[i]);
				in_string = false;
			},
			//In string case.
			(_, true, false, false) => {
				curr_token.push(chars[i]);
			},
			//Start of Char case.
			('\'', false, false, false) => {
				curr_token.push(chars[i]);
				in_char = true;
			},
			//End of Char case, or continuance with escape.
			('\'', false, false, true) => {
				if 
					curr_token.len() > 0 && 
					curr_token[curr_token.len() - 1] != '\\'{
					in_char = false	
				}
				curr_token.push(chars[i]);
			},
			//In Char case.
			(c, false, false, true) => {
				curr_token.push(c);
			},
			//Comment entry case.
			('/', false, false, false) => {
				if ((i + 1) < chars.len()) && (chars[i + 1] == '/'){
					in_comment = true;
					i += 1;
				}else{
					curr_token.push(chars[i]);
				}
			},
			//Exit comment case.
			('\n', false, true, false) => {
				in_comment = false;
			},
			//In comment case.
			(_, false, true, false) => (),
			//General parsing case.
			(c, false, false, false) => {
				if !c.is_whitespace(){
					curr_token.push(c);
				}else{
					if curr_token.len() > 0{
						let t = curr_token.iter().collect::<String>();
						curr_token.clear();

						if t.starts_with("import(\"") && t.ends_with("\")"){
							let import_str = "import(\"";
							let file_str = &t[import_str.len()..t.len()-2];

							let import_file_path = Path::new(file_str);

							if !imported.contains_key(file_str){
								imported.insert(file_str.to_string(), ());
			
								//Opens the input file to read from.
								let mut import_file = match File::open(&import_file_path){
									Ok(f) => f,
									Err(reason) => {
										let import_file_name = import_file_path.display();
										let err_str = file.err_str_line(
											&format!("Unable to open import \
											file \"{}\" for parsing because {}", 
											import_file_name, reason), line
										);
										return Err(err_str);
									}, 
								};

								//Reads in the code from the given file after opening it.
								let mut import_code_str = String::new();
								if let Err(reason) = import_file.read_to_string(&mut import_code_str){
									let import_file_name = import_file_path.display();
									let err_str = file.err_str_line(
										&format!("Unable to read in import \
										file \"{}\" for parsing because {}", 
										import_file_name, reason), line
									);
									return Err(err_str);
								}

								//Pushes all tokens from recursive traversal into current lexed list.
								let import_info = FileInfo::new(&file_str, &import_code_str);
								match tokenize(import_info, imported){
									Ok(import_token) => {
										tokens.push(import_token)	
									},
									Err(e) => return Err(file.err_str_line(&e, line)),
								}
							}
						}else{
							match lex_token(&t){
								Ok(token) => tokens.push(token),
								Err(e) => return Err(file.err_str_line(&e, line)),
							}
						}
						file.append_line(line);
					}
				}
			},
			_ => return Err(file.err_str_line("SHOULD NEVER GET HERE!!!!!!!", line)),
		}
		if chars[i] == '\n' && i < chars.len() - 1{
			line += 1;
		}

		i += 1;
	}


	Ok(Token::File{file: Rc::new(file), tokens: tokens})
}

pub fn throw_parse_error(t: &str, attempted_token: &str) -> String{
	return format!("Incorrectly constructed {}! Tried: {}", t, attempted_token);
}

pub fn replace_literals_with_escapes(s: &str) -> String{
	let chars: Vec<char> = s.chars().collect();	
	let max = chars.len();
	let mut new_str = String::new();

	let mut is_escaped = false;

	for i in 0..max{
		//Skips current char if it's already been escaped.
		if is_escaped{
			is_escaped = false;
			continue;
		}			

		if i + 1 < max && chars[i] == '\\'{
			match chars[i + 1]{
				'\\' => new_str.push('\\'),
				'n' => new_str.push('\n'),
				't' => new_str.push('\t'),
				'r' => new_str.push('\r'),
				'\"' => new_str.push('\"'),
				'\'' => new_str.push('\''),
				'0' => new_str.push('\0'),
				'b' => new_str.push('\x08'),
				'f' => new_str.push('\x0c'),
				other => new_str.push(other),
			}
			is_escaped = true;
		}else{
			new_str.push(chars[i]);
		}
	
	}
	new_str
}

//Takes in a string and returns a token or related error message.
fn lex_token(tok: &str) -> Result<Token, String>{
	macro_rules! tok_match{
		($el:ident, $(($tystr:literal, $ty:ty, $var:ident)),* $(,)?) => {
			match $el{
				t if t == "True" || t == "true" => {
					let bool_val = Value::Boolean(true);
					let sup = SuperValue::Reg(bool_val);
					Ok(Token::Val(sup))
				},
				t if t == "False" || t == "false" => {
					let bool_val = Value::Boolean(false);
					let sup = SuperValue::Reg(bool_val);
					Ok(Token::Val(sup))
				},
				//String case.
				t if t.starts_with("\"") && t.ends_with("\"") => {
					Ok(Token::Val(HeapValue::String(
					replace_literals_with_escapes(&t[1..(t.len() - 1)])).into()))
				}, 
				//Char case.
				t if t.starts_with("\'") && t.ends_with("\'") && t.len() < 13 => {
					let mut iter = t.chars();
					_ = iter.next();
					match (iter.next(), iter.next()){
						(Some('\\'), Some(c)) => {
							let res = match c{
								'n' => '\n',
								't' => '\t',
								'r' => '\r',
								'0' => '\0',
								'\'' => '\'',
								'\"' => '\"',
								'b' => '\x08',
								'f' => '\x0c',
								_ => '\\',
							};	
							Ok(Token::Val(Value::Char(res).into()))
						},
						(Some(c), Some(_)) => Ok(Token::Val(Value::Char(c).into())),
						_ => Err(format!("Token {} is not a valid Char!", t)),	
					}
				},
				//List case.
				t if t == "[]" => Ok(Token::Val(HeapValue::List(Vec::new()).into())),
				//Object case.
				t if t == "{}" => Ok(Token::Val(HeapValue::Object(HashMap::new()).into())),
				//Generalized macro case handling specified floats and integers.
				$(t if t.ends_with($tystr) && t.len() > $tystr.len() => {
					match $el[0..($el.len() - $tystr.len())].parse::<$ty>(){
						Ok(parsed) => Ok(Token::Val(Value::$var(parsed).into())),	
						Err(_) => Err(throw_parse_error($tystr, t)),
					}
				},)*
				//Type inference for float.
				t if t.contains(".") 
						&& (t.chars().next().unwrap() == '-' 
						|| (t.chars().next().unwrap() >= '0' 
							&& t.chars().next().unwrap() <= '9')) 
						=> {
					match $el.parse::<f32>(){
						Ok(parsed) => Ok(Token::Val(Value::Float32(parsed).into())),
						Err(_) => Err(throw_parse_error("f32", t)),
					}
				},
				//Type inference for integer.
				t if (t.chars().next().unwrap() == '-' && t.len() > 1) 
						|| (t.chars().next().unwrap() >= '0' 
							&& t.chars().next().unwrap() <= '9') 
						=> {
					match $el.parse::<isize>(){
						Ok(parsed) => Ok(Token::Val(Value::IntSize(parsed).into())),
						Err(_) => Err(throw_parse_error("isize", t)),
					}
				},
				//The keywords for starting fancy operators.
				"if" => Ok(Token::If),
				"while" => Ok(Token::While),
				"var" => Ok(Token::Var),
				"loc" => Ok(Token::Loc),
				"func" => Ok(Token::Func),
				"attempt" => Ok(Token::Attempt),
				"castTo" => Ok(Token::CastTo),
				"box" => Ok(Token::Box),
				"defer" => Ok(Token::Defer),
				//Terminators for some/all fancy operators.
				"onError" => Ok(Token::OnError),
				";" => Ok(Token::Terminator),
				"else" => Ok(Token::Else),
				//General catch-all case mostly meant for operators.
				t => {
					//If valid operator, kick that back.
					let op_val = Operator::new(&t);
					if op_val != Operator::Unknown{
						return Ok(Token::Op(op_val));
					}

					//If alphanumeric only, kick back as fragment.
					for c in t.chars(){
						if c.is_whitespace(){
							return Err(
								format!(
							"Token: \"{}\" is not a valid Token!", t)
							);
						}
					}	
					Ok(Token::Fragment(t.to_string()))
				}, 
			}	
		};
	}

	tok_match!{tok,
		("f32", f32, Float32),
		("f64", f64, Float64),
		
		("usize", usize, UIntSize),
		("u8", u8, UInt8),
		("u16", u16, UInt16),
		("u32", u32, UInt32),
		("u64", u64, UInt64),

		("isize", isize, IntSize),
		("i8", i8, Int8),
		("i16", i16, Int16),
		("i32", i32, Int32),
		("i64", i64, Int64),
	}
}

fn fancy_op_sans_term_err(fancy_op: Token) -> String {
	format!("Ended Fancy Operator based on token: {} \
without finding a valid terminator!", fancy_op)
}

fn invalid_term_for_att() -> String{
	"Invalid terminator for attempt given! Expected \"onError\", found \";\""
	.to_string()
}

fn term_not_ending_fancy_op() -> String{
 "Invalid terminator given! Not inside fancy operator!"
.to_string()
}

fn rogue_fragment_err(frag: &str) -> String{
	format!("Parsing error! \
Fragment \"{}\" not contained by a fancy Operator!", frag)
}

fn never_here() -> String {
	"SHOULD NEVER GET HERE!!!".to_string()
}

fn rogue_else_err() -> String{
	"Else token detected outside of fancy operator!"
	.to_string()
}

fn non_if_term_err(t: Token) -> String{
	format!(
		"Else token must follow \
		If token! Else following \"{}\" token here!", t
	)
}

fn rogue_onerror() -> String{
	"OnError token detected outside of fancy operator!"
	.to_string()
}

fn non_att_term_err(t: Token) -> String{
	format!(
		"OnError token must follow \
		Attempt token! OnError following \"{}\" token here!", t
	)
}

fn unknown_var_cmd(cmd: &str, name: &str, is_var: bool) -> String{
	let loc_or_var = ["Loc", "Var"];
	format!(
		"Unknown {} command \"{}\" for variable named \"{}\"!", 
		loc_or_var[is_var as usize], cmd, name
	)
}

fn invalid_var_toks(a: &Token, b: &Token, c: &Token, is_var: bool) -> String{
	let loc_or_var = ["Loc", "Var"];
	format!(
		"{} command needs 2 Fragment tokens \
and one Terminator token! Found: {}, {}, and {}", 
	loc_or_var[is_var as usize], a, b, c)
}

fn missing_terminator(a: &Token, b: &Token, is_var: bool) -> String{
	let loc_or_var = ["Loc", "Var"];
	format!("{} command expected ending terminator token for total \
of 3 arguments! Only supplied with: {} and {}", 
	loc_or_var[is_var as usize], a, b)
}

fn missing_term_and_middle(a: &Token, is_var: bool) -> String{
	let loc_or_var = ["Loc", "Var"];
	format!("{} command expected middle Fragment token \
 and Terminator token at the end for total \
of 3 arguments! Only supplied with: {}", 
loc_or_var[is_var as usize], a)
}

fn var_missing_args(is_var: bool) -> String{
	let loc_or_var = ["Loc", "Var"];
	format!("{} command takes 3 arguments, none supplied!", 
	loc_or_var[is_var as usize])
}

fn invalid_box_command(cmd: &str) -> String{
	format!(
		"\"{}\" is not a valid Box command!", 
		cmd
	)
}

fn invalid_box_format(a: &Token, b: &Token) -> String{
    format!("Expected valid Box command Fragment token and Terminator token! Received tokens: \"{}\" and \"{}\"", a, b)
}

fn box_missing_term(a: &Token) -> String{
	format!("Expected terminator after Box command fragment: \"{}\"; \
found nothing!", a)
}

fn missing_box_args() -> String{
	"Parsing error! Expected Box command fragment \
and Terminator after Box keyword. Found nothing!".to_string()
}

fn invalid_cast_type(ty: &str) -> String{
	format!("\"{}\" is \
not a valid casting data type!", ty)
}

fn invalid_castto_tokens(a: &Token, b: &Token) -> String{
	format!("Expected data type Fragment and Terminator token! \
Received tokens: \"{}\" and \"{}\"", a, b)
}

fn castto_missing_term(a: &Token) -> String{
	format!("Expected Terminator after data type \"{}\"; \
found nothing!", a)
}

fn castto_missing_args() -> String{
	"Expected data type Fragment and Terminator tokens \
after CastTo token. Found nothing!".to_string()
}

fn f_call_incorrect_term(name: &str, t: &Token) -> String{
	format!("Expected Terminator token at end \
of calling function \"{}\" found: \"{}\"", name, t)	
}

fn f_call_missing_term(name: &str) -> String{
	format!("Expected Terminator token at end \
of calling function \"{}\" found nothing!", name)	
}

fn unknown_func_command(name: &str, c: &str) -> String{
	format!("Invalid command token given for function \"{}\"! \
  Given: \"{}\"", name, c)
}

fn invalid_func_args(a: &Token, b: &Token) -> String{
	format!("Func token expected at least \
two Fragment tokens after it! Found: \"{}\" and \"{}\"", a, b)	
}

fn f_last_arg_missing(t: &Token) -> String{
	format!("Func token expected at least two Fragment tokens after it! \
Only found: \"{}\"", t)	
}

fn f_missing_both_args() -> String{
	"Func token expected at least two Fragment tokens after it! Found nothing!"
	.to_string()
}

//This function does the heavy-lifting of recursively building the AST.
pub fn make_ast_prime(
	file: Rc<FileInfo>,
	tokens: &Vec<Token>, 
	mut token_index: usize,
	fancy_op: Token
) -> Result<(Vec<ASTNode>, usize), String>{

	let mut already_parsed: Vec<ASTNode> = Vec::new();

	//Loops through all tokens in expression.
	loop{
		//If out of tokens to parse, end or throw error if there were terminators to look for.
		if token_index >= tokens.len(){
			if fancy_op != Token::NOTHING{
				let err_str = fancy_op_sans_term_err(fancy_op);
				return Err(file.err_str_tok(&err_str, tokens.len() - 1));
			}else{
				return Ok((already_parsed, token_index));
			}
		//If still tokens to parse, converts the tokens into an ASTNode.
		}else{
			match &tokens[token_index]{
				Token::Terminator => {
					match fancy_op{
						Token::Attempt => {
							return Err(file.err_str_tok(
								&invalid_term_for_att(), token_index));
						},
						Token::NOTHING => {
							let e = term_not_ending_fancy_op();
							return Err(file.err_str_tok(&e, token_index));
						},
						_ => {
							return Ok((already_parsed, token_index));	
						},
					}
				},
				Token::Val(sup_val) => {
					match sup_val{
						SuperValue::Reg(v) => {
							already_parsed.push(ASTNode::Val(*v));
						},
						SuperValue::Heap(hv) => {
							already_parsed.push(ASTNode::HeapVal(Box::new(*hv.clone())));
						},
					}				
				},
				//Basically a direct translation.
				Token::Op(o) => already_parsed.push(ASTNode::Op(*o)),
				//If you see a rogue fragment like this, error out!
				Token::Fragment(f) => {
					let e = rogue_fragment_err(f);
					return Err(file.err_str_tok(&e, token_index));
				},	
				Token::While =>{
					match make_ast_prime(
						file.clone(), tokens, token_index + 1, Token::While
					)
					{
						Ok((loop_body, token_idx_prime)) => {
							let idx_delta = token_idx_prime - token_index;
							let l_data = WhileData::new(loop_body.into(), idx_delta);
							already_parsed.push(ASTNode::While(l_data));
							token_index = token_idx_prime;	
						},
						Err(e) => return Err(file.err_str_tok(&e, token_index)),
					}
					
				},
				Token::Defer =>{
					match make_ast_prime(
						file.clone(), tokens, token_index + 1, Token::Defer
					)
					{
						Ok((def_bod, token_idx_prime)) => {
							let data = DeferData::new(def_bod.into(), 
								token_idx_prime - token_index, token_index);
							already_parsed.push(ASTNode::Defer(data));
							token_index = token_idx_prime;	
						},
						Err(e) => return Err(file.err_str_tok(&e, token_index)),
					}
					
				},
				Token::If => {
					match make_ast_prime(
						file.clone(), tokens, token_index + 1, Token::If
					)
					{
						Ok((if_body, token_idx_prime)) => {
							let if_delta = token_idx_prime - token_index;
							token_index = token_idx_prime;
							//If else statement detected, 
							// parses recursively the else body.
							// Otherwise just puts nothing in for else_body.
							let else_body: Vec<ASTNode>;
							let else_delta: usize;
							match tokens[token_index]{
								Token::Else => {
									match make_ast_prime(
										file.clone(), tokens, token_index + 1, Token::Else
									)
									{
										Ok((bod, tok_idx_prime_prime)) => {
											else_delta = tok_idx_prime_prime - token_index;
											else_body = bod;	
											token_index = tok_idx_prime_prime;
										},
										Err(e) => return Err(file.err_str_tok(&e, token_idx_prime)),
									}
								},
								Token::Terminator => {
									else_body = Vec::new(); 
									else_delta = 0;
								},
								_ => return Err(file.err_str_tok(&never_here(), token_index))
							}

							//Builds and pushes If ASTNode.	
							let mut if_data = 
								IfData::new(if_body.into(), else_body.into());
							if_data.if_token_count = if_delta;
							if_data.else_token_count = else_delta;
							let if_node = ASTNode::If(if_data);
							already_parsed.push(if_node);

						},
						Err(e) => return Err(file.err_str_tok(&e, token_index)),
					}
				},
				//Acts like a terminator but only for If statements.
				Token::Else => {
					match fancy_op{
						Token::If => return Ok((already_parsed, token_index)),
						Token::NOTHING => {
							let e = rogue_else_err();
							return Err(file.err_str_tok(&e, token_index));	
						},
						t => {
							let e = non_if_term_err(t);
							return Err(file.err_str_tok(&e, token_index));
						}
					}
				},
				Token::Attempt => {
					match make_ast_prime(
						file.clone(), tokens, token_index + 1, Token::Attempt
					)
					{
						Ok((att_body, token_idx_prime)) => {
							match make_ast_prime(
								file.clone(), tokens, token_idx_prime + 1, Token::OnError
							)
							{
								Ok((err_bod, tok_idx_prime_prime)) => {
									let mut att_err_data = AttErrData::new(
										att_body.into(), err_bod.into()
									);
									att_err_data.att_token_count = 
										token_idx_prime - token_index;
									att_err_data.err_token_count = 
										tok_idx_prime_prime - token_idx_prime;
									let att_err_node = ASTNode::AttErr(att_err_data);

									already_parsed.push(att_err_node);
									token_index = tok_idx_prime_prime;
								},
								Err(e) => return Err(file.err_str_tok(&e, token_idx_prime)),
							}
						},
						Err(e) => return Err(file.err_str_tok(&e, token_index)),
					}
				},
				Token::OnError => {
					match fancy_op{
						Token::Attempt => return Ok((already_parsed, token_index)),
						Token::NOTHING => {
							let e = rogue_onerror();
							return Err(file.err_str_tok(&e, token_index));
						},
						t => {
							let e = non_att_term_err(t);
							return Err(file.err_str_tok(&e, token_index));
						},
					}
				},
				Token::Var => {
					let ti = token_index;
					let ts = tokens;
					match (ts.get(ti + 1), ts.get(ti + 2), ts.get(ti + 3)) {
						(Some(Token::Fragment(a)), Some(Token::Fragment(name)), 
						Some(Token::Terminator)) => 
						{
							//Parses command and throws a fit if not known.
							let command = VarCmd::new(a);
							if command == VarCmd::Unknown{
								let e = unknown_var_cmd(a, name, true);
								return Err(file.err_str_tok(&e, token_index));
							}

							let var_data = VarData::new(name, command);
							already_parsed.push(ASTNode::Variable(var_data));
							token_index += 3;
						},
						(Some(a), Some(b), Some(c)) => {
							let e = invalid_var_toks(a, b, c, true);
							return Err(file.err_str_tok(&e, token_index));
						},
						(Some(a), Some(b), None) => {
							let e = missing_terminator(a, b, true);
							return Err(file.err_str_tok(&e, token_index));
						},
						(Some(a), None, None) => {
							let e = missing_term_and_middle(a, true);
							return Err(file.err_str_tok(&e, token_index));
						},
						(None, None, None) => {
							let e = var_missing_args(true);
							return Err(file.err_str_tok(&e, token_index));
						},
						_ => return Err(file.err_str_tok(&never_here(), token_index)),
					}
				},
				Token::Loc => {
					let ti = token_index;
					let ts = tokens;
					match (ts.get(ti + 1), ts.get(ti + 2), ts.get(ti + 3)) {
						(Some(Token::Fragment(a)), Some(Token::Fragment(name)), 
						Some(Token::Terminator)) => 
						{
							//Parses command and throws a fit if not known.
							let command = VarCmd::new(a);
							if command == VarCmd::Unknown || command == VarCmd::Delete{
								let e = unknown_var_cmd(a, name, false);
								return Err(file.err_str_tok(&e, token_index));
							}

							let var_data = VarData::new(name, command);
							already_parsed.push(ASTNode::LocVar(var_data));
							token_index += 3;
						},
						(Some(a), Some(b), Some(c)) => {
							let e = invalid_var_toks(a, b, c, false);
							return Err(file.err_str_tok(&e, token_index));
						},
						(Some(a), Some(b), None) => {
							let e = missing_terminator(a, b, false);
							return Err(file.err_str_tok(&e, token_index));
						},
						(Some(a), None, None) => {
							let e = missing_term_and_middle(a, false);
							return Err(file.err_str_tok(&e, token_index));
						},
						(None, None, None) => {
							let e = var_missing_args(false);
							return Err(file.err_str_tok(&e, token_index));
						},
						_ => return Err(file.err_str_tok(&never_here(), token_index)),
					}
				},
				Token::Box => {
					match (tokens.get(token_index + 1), tokens.get(token_index + 2)){
						(Some(Token::Fragment(f)), Some(Token::Terminator)) => {
							let cmd = BoxCmd::new(f);
							if cmd == BoxCmd::Unknown{
								let e = invalid_box_command(f);
								return Err(file.err_str_tok(&e, token_index));
							}
							already_parsed.push(ASTNode::BoxOp(cmd));	
							token_index += 2;
						},
						(Some(a), Some(b)) => {
							let e = invalid_box_format(a, b);
							return Err(file.err_str_tok(&e, token_index));
						},
						(Some(a), None) => {
							let e = box_missing_term(a);
							return Err(file.err_str_tok(&e, token_index));
						},
						(None, None) => {
							let e = missing_box_args();
							return Err(file.err_str_tok(&e, token_index));
						},
						_ => return Err(file.err_str_tok(&never_here(), token_index)),
					}
				},
				Token::CastTo => {
					match (tokens.get(token_index + 1), tokens.get(token_index + 2)){
						(Some(Token::Fragment(ty)), Some(Token::Terminator)) => {
							match CastType::try_cast(ty, CastType::MiscBox){
								Ok(cast_type) => {
									already_parsed.push(ASTNode::CastTo(cast_type));
									token_index += 2;
								},
								Err(_) => return Err(
									file.err_str_tok(
									&invalid_cast_type(ty), token_index)),
							}
						},
						(Some(a), Some(b)) => {
							let e = invalid_castto_tokens(a, b);
							return Err(file.err_str_tok(&e, token_index));
						},
						(Some(a), None) => {
							let e = castto_missing_term(a);
							return Err(file.err_str_tok(&e, token_index));
						},
						(None, None) => {
							let e = castto_missing_args();
							return Err(file.err_str_tok(&e, token_index));
						},
						_ => return Err(file.err_str_tok(&never_here(), token_index)),
					}
				},
				Token::Func => {
					match (tokens.get(token_index + 1), tokens.get(token_index + 2)) {
						(Some(Token::Fragment(c)), Some(Token::Fragment(name))) => {
							match FunCmd::new(c){
								FunCmd::Define => {
									match make_ast_prime(
										file.clone(), tokens, token_index + 3, Token::Func
									)
									{
										Ok((f_bod, token_index_prime)) => {
											let f_data = FuncData::new(
												FunCmd::Define, name, 
												f_bod.into(), token_index + 3, 
												token_index_prime - (token_index + 2),
												file.clone());
											already_parsed.push(ASTNode::Function(f_data));
											token_index = token_index_prime;
										},
										Err(e) => return Err(file.err_str_tok(&e, token_index)),
									}
								},
								FunCmd::Call => {
									//Since it's a function call, 
									// it checks for a terminator and that's it.
									match tokens.get(token_index + 3){
										Some(Token::Terminator) => {
											let nil_file = Rc::new(FileInfo::new("", ""));
											let f_data = FuncData::new(
												FunCmd::Call, name, 
												Vec::new().into(), 0, 0, nil_file);
											already_parsed.push(ASTNode::Function(f_data));

											token_index += 3;
										},
										Some(a) => {
											let e = f_call_incorrect_term(name, a);
											return Err(file.err_str_tok(&e, token_index));
										},
										None => {
											let e = f_call_missing_term(name);
											return Err(file.err_str_tok(&e, token_index));
										},
									}
								},
								FunCmd::Unknown => {
									let e = unknown_func_command(name, c);
									return Err(file.err_str_tok(&e, token_index));
								}
							}
						},
						(Some(a), Some(b)) => {
							let e = invalid_func_args(a, b);
							return Err(file.err_str_tok(&e, token_index));
						},
						(Some(a), None) => {
							let e = f_last_arg_missing(a);
							return Err(file.err_str_tok(&e, token_index));
						},
						(None, None) => {
							let e = f_missing_both_args();
							return Err(file.err_str_tok(&e, token_index));
						},
						_ => return Err(file.err_str_tok(&never_here(), token_index)),
					}
				},
				Token::File{file: f, tokens: toks} => {
					match make_ast_prime(Rc::clone(f), &toks, 0, Token::NOTHING) {
						Ok((file_body, _)) => {
							let f_data = FileData::new(Rc::clone(&f), file_body.into());
							already_parsed.push(ASTNode::File(f_data));
						},
						Err(e) => return Err(file.err_str_tok(&e, token_index))
					}	
				},
				Token::NOTHING => (),
			}
			token_index += 1;
		}
	}
}

// Consumes a file Token and creates an AST based on it.
pub fn make_ast(tokens: Token) -> Result<ASTNode, String>{
	if let Token::File{file: f, tokens: toks} = tokens{
		match make_ast_prime(Rc::clone(&f), &toks, 0, Token::NOTHING){
			Ok((ast_vec, _)) => {
				let ast_data = FileData::new(f, ast_vec.into());
				Ok(ASTNode::File(ast_data))
			},
			Err(e) => return Err(e),
		}
	}else{
		return Err(format!("Parsing error! AST creation must start at File level Token! \
Received token: {}", tokens));
	}
}