import vector_literals: *
import string:*
import io:*
import mem: *
import util: *
import os: *

obj LLVMModule {}
obj LLVMType {}
obj LLVMValue {}
obj LLVMGenericValue {}
obj LLVMBasicBlock {}
obj LLVMBuilder {}
obj LLVMExecutionEngine {}

ext fun LLVMModuleCreateWithName(ModuleID: *char): *LLVMModule
ext fun LLVMInt32Type(): *LLVMType
ext fun LLVMFunctionType(ret_type: *LLVMType, param_types: **LLVMType, ParamCount: uint, isVarArg: int): *LLVMType
ext fun LLVMAddFunction(mod: *LLVMModule, name: *char, rettype: *LLVMType): *LLVMValue
ext fun LLVMAppendBasicBlock(func: *LLVMValue, name: *char): *LLVMBasicBlock
ext fun LLVMCreateBuilder(): *LLVMBuilder
ext fun LLVMPositionBuilderAtEnd(builder: *LLVMBuilder, block: *LLVMBasicBlock)
ext fun LLVMGetParam(func: *LLVMValue, num: int): *LLVMValue
ext fun LLVMBuildAdd(builder: *LLVMBuilder, first: *LLVMValue, second: *LLVMValue, name: *char): *LLVMValue
ext fun LLVMBuildRet(builder: *LLVMBuilder, value: *LLVMValue): *LLVMValue
ext fun LLVMVerifyModule(M: *LLVMModule, Action: int, error: **char): int
var LLVMAbortProcessAction = 1
ext fun LLVMDisposeMessage(error: *char)
ext fun LLVMLinkInMCJIT()
/*ext fun LLVMInitializeNativeTarget(): bool*/
ext fun LLVMInitializeX86Target(): bool
ext fun LLVMCreateExecutionEngineForModule(engine: **LLVMExecutionEngine, M: *LLVMModule, error: **char): int
ext fun LLVMCreateGenericValueOfInt(Ty: *LLVMType, N: ulong, IsSigned: int): *LLVMGenericValue
ext fun LLVMRunFunction(EE: *LLVMExecutionEngine, F: *LLVMValue, NumArgs: uint, Args: **LLVMGenericValue): *LLVMGenericValue
ext fun LLVMGenericValueToInt(GenVal: *LLVMGenericValue, IsSigned: int): ulong

#link("LLVM-3.8")

fun main(argc: int, argv: **char): int {
    var mod = LLVMModuleCreateWithName("my_module")
    var param_types = vector(LLVMInt32Type(), LLVMInt32Type())
    var ret_type = LLVMFunctionType(LLVMInt32Type(), param_types.getBackingMemory(), (2) cast uint, 0)
    var sum = LLVMAddFunction(mod, "sum", ret_type)
    var entry = LLVMAppendBasicBlock(sum, "entry")
    var builder = LLVMCreateBuilder()
    LLVMPositionBuilderAtEnd(builder, entry)
    var tmp = LLVMBuildAdd(builder, LLVMGetParam(sum,0), LLVMGetParam(sum,1), "tmp")
    LLVMBuildRet(builder, tmp)

    var error = null<char>()
    LLVMVerifyModule(mod, LLVMAbortProcessAction, &error)
    LLVMDisposeMessage(error)

    var engine: *LLVMExecutionEngine
    error = null<char>()
    LLVMLinkInMCJIT()
    /*LLVMInitializeNativeTarget()*/
    // LLVMInitializeNativeTarget is static/inline :/
    LLVMInitializeX86Target()
    
    if (LLVMCreateExecutionEngineForModule(&engine, mod, &error)) {
        error("Failed to create execution engine")
    }
    if (error) {
        println(string("error: ") + error)
        LLVMDisposeMessage(error)
        exit(1)
    }
    if (argc < 3) error(string("usage: ") + argv[0] + " x y")
    var x = string_to_num<ulong>(string(argv[1]))
    var y = string_to_num<ulong>(string(argv[2]))
    var args = vector(LLVMCreateGenericValueOfInt(LLVMInt32Type(), x, 0),
                      LLVMCreateGenericValueOfInt(LLVMInt32Type(), y, 0))
    var res = LLVMRunFunction(engine, sum, 2u, args.getBackingMemory())
    println(string("result: ") + (LLVMGenericValueToInt(res, 0)) cast int)
    return 0
}