<d_bot>
<mbacarella> when it's time to do a minor collection, how are the live words detected? I assume it's doing something clever instead of tracing from the roots?
spip has quit [Ping timeout: 246 seconds]
spip has joined #ocaml
<d_bot>
<Anurag> > @pilothole nice. one question: did ppxlib require changing to use objects, or did you add that for funsies?
<d_bot>
<Anurag> The use of objects was related to ppxlib. I'll add that this was my first time using anything ppx related, and there might be a better/simpler approach than what I used in my pull-request.
tizoc has quit [Quit: Coyote finally caught me]
tizoc has joined #ocaml
kaph has joined #ocaml
<gopiandcode>
Okay, thanks for the help! got it running, turns out the issue was with using the appropriate Cflags, now I can compile modules that reference other dynamically linked modules without problem!
waleee has quit [Ping timeout: 250 seconds]
<drakonis>
gopiandcode: any gocaml updates in the near future?
<gopiandcode>
drakonis: yes, I plan to release an update to bring it up to date with the latest ocaml soon
<drakonis>
fantastic.
Techcable has quit [Remote host closed the connection]
Techcable has joined #ocaml
Techcable_ has joined #ocaml
chrisz has quit [Ping timeout: 248 seconds]
chrisz has joined #ocaml
zebrag has quit [Quit: Konversation terminated!]
Techcable has quit [Remote host closed the connection]
Techcable_ has quit [Remote host closed the connection]
Sankalp has quit [Ping timeout: 250 seconds]
Sankalp has joined #ocaml
Haudegen has joined #ocaml
gravicappa has joined #ocaml
<d_bot>
<cod1r> hi
kotrcka has quit [Remote host closed the connection]
vicfred has joined #ocaml
Techcable has joined #ocaml
shawnw has joined #ocaml
Serpent7776 has joined #ocaml
xgqt has quit [Ping timeout: 272 seconds]
xgqt has joined #ocaml
mro has joined #ocaml
<gopiandcode>
Is it possible to allow dynlinked code to access global variables in the calling modules context? like updating a ref?
Anarchos has joined #ocaml
olle has joined #ocaml
bobo has joined #ocaml
spip has quit [Ping timeout: 240 seconds]
<octachron>
gopiandcode, yes, that's how dynlinked code can communicate with the caller.
<gopiandcode>
In my case, I'm also compiling the code at runtime as well ~ how would I configure the `Env.t` env to include the signature of the host code itself?
<gopiandcode>
Currently, I'm trying to manually use `Env.add_module` ... and just manually constructing the signature of the parts fo the current host context that I want my dynlinked code to access
<gopiandcode>
is there an easier way?
mro has quit [Remote host closed the connection]
mro has joined #ocaml
<octachron>
You should not add persistent module with `Env.add_module`.
<gopiandcode>
right, I figured that was probably not the right approach
<octachron>
It sounds simpler for you to use the persistent module loading hook.
<gopiandcode>
Where could I find that? Typemod? or Env?
<gopiandcode>
oh, do you mean Env.persistent_structures_of_dir?
<gopiandcode>
paired with Env.add_persistent_structure?
<octachron>
No, look at Persistent_env
bartholin has joined #ocaml
<gopiandcode>
octachron: yup, just tried Env.add_persistent_structure and the code just failed to type check; I'll have a look at peristent_env and how it's used in the compiler
<gopiandcode>
is Persistent_env something global?
<gopiandcode>
octachron: I'm using a native code compilation pipeline adapted from opttoploop or opttopeval (4.12.0 branch)
<gopiandcode>
octachron: I can successfully typecheck, compile, dynlink and execute arbitrary OCaml snippets from files or strings, but I would like to let the snippets to also access variables in the host environment
<gopiandcode>
I'm not sure where Persistent_env interacts with the compilation pipeline unless it's some global state
<Anarchos>
gopiandcode if you find a solution to compile ocaml code and use it at runtime , i am interested in your solution
<gopiandcode>
Anarchos: I've managed to compile ocaml code natively and use it at runtime (I can retrieve values (even functional ones back from the compiled code))
<gopiandcode>
Anarchos: I'm just working on trying to get shared state between the compiled and host code
<gopiandcode>
let vl' : int -> int = eval_expr env (raw_parse_expr_str "fun i -> i + 1") in Printf.printf "evaluated value: %d\n" (vl' 2);
<Anarchos>
gopiandcode great ! is your solution available somewhere ?
<gopiandcode>
I can share a snippet, just give me a sec
<Anarchos>
gopiandcode i want to compile some struct and use them at runtime
<gopiandcode>
That should be possible as well, you'll probably have to use an existential type to hide the type definition so you can share it between the compiled and host code
<Anarchos>
gopiandcode by struct, i mean module A = struct … end
<gopiandcode>
Ah right, that should work as well, but you'll probably need to define the module signature in the host, and you'll need to share the signature between the host and compiled code I think?
<gopiandcode>
I'm Still working on sharing signatures/types between the compiled and host code
<gopiandcode>
it's mostly just a simplified version of the opttopeval native toplevel code from 4.12.0 branch, although took a quite a while to work out which parts of the spooky global compiler state had to be initialised in what order to prevent things from crashing
<Anarchos>
gopiandcode ok so you use natdynlink to run an 'external' toplevel, and communicate with it ?
<gopiandcode>
I'm not running an 'external' toplevel, afaik I think
<gopiandcode>
I'm compiling the module down to assembly, and then dynamically loading it
<gopiandcode>
at least that's what I believe 'caml_natdynlink_run_toplevel' does,
<gopiandcode>
You can see the definition of that native function at the above link
<gopiandcode>
it doesn't run a toplevel itself
<gopiandcode>
it just calls dlopen on a given filename, and then runs the dll
<gopiandcode>
At least that is my understanding of how the native toplevel works - each submitted phrase is compiled natively to a dll and loaded dynamically
<octachron>
That's indeed the case (in the normal setup)
wingsorc has quit [Ping timeout: 260 seconds]
Tuplanolla has joined #ocaml
<gopiandcode>
octachron: ah, I think I see what you mean
<gopiandcode>
I guess I should use Env.add_persistent_structure
<gopiandcode>
and then update the Persistent_signature.load function to return a cached cmi
<gopiandcode>
I guess I can use ppx_blob to depend on the source code of one of the modules in my project
<gopiandcode>
ohhh, that might be a big hack, but then I could build the cmi file from the source code text, avoiding the circular dependency
dextaa4 has joined #ocaml
mro has quit [Remote host closed the connection]
<gopiandcode>
AHHHH!! IT WORKS!
gravicappa has quit [Ping timeout: 260 seconds]
<gopiandcode>
Anarchos: I am able to confirm that using the approach suggested by octachron, it is possible to share modules between compiled and host env
<gopiandcode>
Global.S has to be a signature that is visible from both the host env, and the compilation env
Haudegen has quit [Quit: Bin weg.]
<gopiandcode>
but that aside, works like a charm!!
<Anarchos>
gopiandcode i think i will have to compile the signature first :)
<gopiandcode>
Yeah, the signature has to be visible from the host env, so it should be available when you're compiling the project, but that's not too suprising as OCaml is statically typed
mro has quit [Remote host closed the connection]
mro has joined #ocaml
mro has quit [Client Quit]
gravicappa has joined #ocaml
dextaa4 has quit [Remote host closed the connection]
slbtty has joined #ocaml
kaph has quit [Read error: Connection reset by peer]
kaph has joined #ocaml
Haudegen has joined #ocaml
Anarchos has quit [Quit: Vision[]: i've been blurred!]