Radicalc  Check-in [906aaa2d5e]

	}

	public class Function {
		public string name;
		public Type type;
		public List<Type> parameters = new List<Type>();
		public Block block;
		public bool intrinsic;
	}

	public class Block {
		public Scope scope;
		public List<Statement> statements = new List<Statement>();
	}

		t.Add(new Type{name = "i64",    size = 64, builtin = true});
		t.Add(new Type{name = "u8",     size = 8,  builtin = true});
		t.Add(new Type{name = "u16",    size = 16, builtin = true});
		t.Add(new Type{name = "u32",    size = 32, builtin = true});
		t.Add(new Type{name = "u64",    size = 64, builtin = true});
		t.Add(new Type{name = "string", size = -1, builtin = true});
		t.Add(new Type{name = "bool",   size = 1,  builtin = true});

		var cmp_types = new[]{"i8","i16","i32","i64","u8","u16","u32","u64"};
		var eq_types = cmp_types.Concat(new[]{"string", "bool"}).ToArray();

		var cmp_funs = new[]{"cmp_lt", "cmp_leq", "cmp_gt", "cmp_geq"};
		var num_funs = new[]{"add", "sub", "mul", "div"};
		var eq_funs = new[]{"cmp_eq", "cmp_neq"};

		var bool_ty = GetType(top, "bool");
		foreach(var cmp in cmp_types) {
			var ty = GetType(top, cmp);
			foreach(var fun in cmp_funs) {
				var f = new Function{name=fun, type=bool_ty, intrinsic=true};
				f.parameters.Add(ty);
				f.parameters.Add(ty);
				top.functions.Add(f);
			}
			foreach(var fun in num_funs) {
				var f = new Function{name=fun, type=ty, intrinsic=true};
				f.parameters.Add(ty);
				f.parameters.Add(ty);
				top.functions.Add(f);
			}
		}
		foreach(var eq in eq_types) {
			var ty = GetType(top, eq);
			foreach(var fun in eq_funs) {
				var f = new Function{name=fun, type=bool_ty, intrinsic=true};
				f.parameters.Add(ty);
				f.parameters.Add(ty);
				top.functions.Add(f);
			}
		}
	}

	static Type
	GetType(Top top, string name) {
		var t = top.types.First(item => item.name == name);
		if(t == null)
			throw new ArgumentOutOfRangeException("Unknown type: " + name);
		return t;
	}

	static Function
	GetFunction(Top top, string name, List<Type> pars) {
		foreach(var fun in top.functions) {
			if(fun.name == name && fun.parameters.Count == pars.Count) {
				var ok = true;
				for(var i = 0; i < pars.Count && ok; ++i) {
					if(fun.parameters[i] != pars[i])
						ok = false;
				}
				if(ok)
					return fun;
			}
		}
		return null;
	}

	static Variable
	GetVariable(Scope scope, string name) {

	Annotate(ParseStep.Top ptop) {
		var top = new Top();
		InitIntrinsics(top);
		var dict = new Dictionary<ParseStep.Function, Function>();
		//pre annotate functions(without their body)
		foreach(var pf in ptop.functions) {
			var scope = new Scope();
			var f = new Function {name = pf.name, intrinsic = false};
			f.type = GetType(top, pf.type.name);
			foreach(var pfp in pf.parameters) {
				var t = GetType(top, pfp.type.name);
				var v = new Variable(pfp.name, t, true);
				scope.variables.Add(v);
				f.parameters.Add(t);
			}

				}
				block.scope.variables.Add(va);
				var st = new StatementAssignment();
				st.left = new ExpressionVariableUse(){variable=va};
				st.right = exp;
				stmts.Add(st);
				break;
			case ParseStep.StatementExpression pexpr:
				var ex = new StatementExpression();
				ex.expression = Annotate(pexpr.expression, top, block.scope);
				stmts.Add(ex);
				break;
			default:
				var emsg = "unknown statement type: ";
				emsg += ps.GetType().Name;
				throw new InvalidOperationException(emsg);
			}
		}
	}

	public static ConditionalBlock
	Annotate(ParseStep.ConditionalBlock pblock, Scope parent_scope,
	         Function fun, Top top)

			if(fun.function == null) {
				var m = "can't find function "+pfuncall.function+"(";
				foreach(var t in types)
					m += t.name+", ";
				m += ")";
				throw new InvalidOperationException(m);
			}
			fun.type = fun.function.type;
			return fun;
		case ParseStep.ExpressionMemberAccess pmember:
			var member = new ExpressionMemberAccess();
			throw new InvalidOperationException("nope");
			//todo: can't do yet, need to implement those types first :P
		case ParseStep.ExpressionVariableUse pvaruse:
			var varuse = new ExpressionVariableUse();

fun factorial(n:i32):i32
	var result = 1
	var i = 1
	while i <= n
		result = result * i
		i = i + 1
	end
	return result
end

fun main():i32
	var i = 0



	return factorial(3*3)
end