func genProgram(node *ast.Program, b *bytes.Buffer) string {
	write(b, "#include <string>\n#include <iostream>\n#include \"Builtins.cpp\"\n\n")

	for _, funcs := range node.Functions {
		gen(funcs, b)
	}

	write(b, "int main() {\n")
	for _, stmt := range node.Statements {
		gen(stmt, b)
	}
	write(b, "return 0;\n}")
	return ""
}

func genBlockStatement(node *ast.BlockStatement, b *bytes.Buffer) string {
	for _, stmt := range node.Statements {
		gen(stmt, b)
	}
	return ""
}

func genExpressionStatement(node *ast.ExpressionStatement, b *bytes.Buffer) string {
	value := gen(node.Expression, b)
	write(b, "%s;\n", value)
	return ""
}

func genAssignStatement(node *ast.AssignStatement, b *bytes.Buffer) string {
	right := gen(node.Right, b)
	// get left type
	write(b, "%s = %s;\n", node.Left.Value, right)
	return ""
}

func genInitStatement(node *ast.InitStatement, b *bytes.Buffer) string {
	right := gen(node.Expr, b)
	kind, _ := GetIdentType(node.Location)
	write(b, "%s %s = %s;\n", kind, node.Location, right)
	return ""
}

func genReturnStatement(node *ast.ReturnStatement, b *bytes.Buffer) string {
	value := gen(node.ReturnValue, b)
	write(b, "return %s;\n", value)
	return ""
}

func genFunctionStatement(node *ast.FunctionStatement, b *bytes.Buffer) string {
	if IsBuiltin(node.Name) {
		panic("built in function")
	}

	write(b, "%s %s(", node.Return, node.Name)

	for i, arg := range node.Parameters {
		write(b, "%s %s", arg.Type, arg.Arg)
		if i != len(node.Parameters)-1 {
			write(b, ",")
		}
	}
	write(b, ") {\n")
	gen(node.Body, b)
	write(b, "}\n\n")
	return ""
}

func genIfStatement(node *ast.IfStatement, b *bytes.Buffer) string {
	cond := gen(node.Condition, b)
	write(b, "if (\"true\" == %s.val) {\n", cond)
	gen(node.Block, b)
	write(b, "} else {\n")
	gen(node.Alternative, b)
	write(b, "}\n\n")
	return ""
}