module ILCreator

open System.Reflection
open System.Reflection.Emit
open ILInstructions
open System.Threading
open System
open System.IO

// Yep I'm not using this yet
let rec evaluate (il:ILGenerator) expr =
    match expr with
    | PushInt i     -> il.Emit(OpCodes.Ldc_I4, i)
    | Add           -> il.Emit(OpCodes.Add)
    | Sub           -> il.Emit(OpCodes.Sub)
    | Div           -> il.Emit(OpCodes.Div)
    | Mul           -> il.Emit(OpCodes.Mul)

let createAssembly name =
    let assemblyName = new AssemblyName(Path.GetFileNameWithoutExtension(name))
    AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Save)

let createClass (moduleBuilder: ModuleBuilder) name =
    moduleBuilder.DefineType(name, TypeAttributes.Public)

let createMethod (typeBuilder : TypeBuilder) name instructions =
    let newMethod = typeBuilder.DefineMethod(name, MethodAttributes.Public ||| MethodAttributes.Static)
    let ilGenerator = newMethod.GetILGenerator()
    List.map (fun i -> ilGenerator.Emit(i)) instructions |> ignore
    newMethod

let generateIL assemblyName expr =
    let assemblyBuilder = createAssembly assemblyName
    let moduleBuilder = assemblyBuilder.DefineDynamicModule(assemblyName)
    let typeBuilder = createClass moduleBuilder "Program"

    // Don't mind this: it is just an example
    createMethod typeBuilder "MyNewMethod" [OpCodes.Ldc_I4_1; OpCodes.Ldc_I4_1; OpCodes.Add] |> ignore
    let mainMethod = createMethod typeBuilder "Main" [OpCodes.Ldc_I4_0; OpCodes.Ret]

    typeBuilder.CreateType()                    |> ignore
    moduleBuilder.CreateGlobalFunctions()       |> ignore
    assemblyBuilder.SetEntryPoint(mainMethod)   |> ignore
    assemblyBuilder.Save(assemblyName)          |> ignore