Allow foreign system to load dynamic libraries at runtime

[ftphikari]

Example:

package dynamic_module

when ODIN_OS == .Windows {
    foreign import dll_name "thing.dll"
} else when ODIN_OS == .Linux {
    foreign import dll_name "system:thing"
}

@(default_calling_convention="c", prefix="foo_")
foreign dll_name {
   // missing symbols are nil procedure pointers by default
   bar :: proc(baz: i32) ---

   @(stub="_alternative_baz") // if you have an alternative implementation in case the DLL doesn't export that symbol, or the DLL can't be loaded.
   baz :: proc(barzle: i32) -> bool ---
}

_alternative_baz :: proc "c" (barzle: i32) -> bool {
    return false
} 

To figure out if the library was loaded:

intrinsic.was_foreign_import_loaded(dynamic_module.dll_name)

[ftphikari]

@Kelimion do you concur?

[Kelimion]

That would be nice to have, yes, as per our discussion on Discord.

Implementation-wise it would need looking at - because the Odin runtime would need to handle this under the covers - what if any implications this has for -no-crt compiles, as dlopen, dlsym wouldn't be available out of the box in those cases.

[ftphikari]

Another take on a possible change. Main idea is to have a unified system for compile-time/runtime linking libraries with a single set of symbol definitions.

// some_lib/bindings/bindings.odin

package some_lib_bindings

bindings: runtime.Bindings

// in one place
bindings {
    some_func: proc(),
}

// in another, possibly in another file
@(link_prefix="some_")
bindings {
    other_func: proc(),
}

Example 1; comptime

// some_lib/some_lib.odin

package some_lib

import "bindings"

foreign import "some_lib.dll"
// This presumably imports all of the symbols into this package for access, or something like that
#foreign_bind(some_lib, &bindings.bindings)

Example 2; runtime

Note: there has to be a way to iterate through runtime.Bindings using RTTI

// my_program/main.odin

package main

import some_lib_runtime "some_lib/bindings"

main :: proc() {
    some_lib := dynlib.load("some_lib.dll")
    ok := dynlib.bind(&some_lib, &some_lib_runtime.bindings)
    // NOTE: ok signifies if *all* symbols were loaded, mirroring comptime binding; to handle individual symbols missing - you can write your own binding function
    { // in this scope you can pretend to be working with a library as usual; you can do it at global scope as well
      some_lib :: some_lib_runtime.bindings
      some_lib.some_func()
    }
}