16:24 <enebo[m]> headius: byteit101 I think we can easily do the IR version. I will make a continuable IR interpreter

16:26 <enebo[m]> The main interpreters are all static methods so we make another interpreter which just uses those as well. The entry point will accept a context which can hold temp vars and ipc

16:26 <enebo[m]> so we call it and get a context back then call again with the same context and it continues

16:26 <enebo[m]> There are actually a couple of ways of doing this

16:27 <enebo[m]> I can do first pass on interp if byteit101 can hook it into his POC

16:27 <byteit101[m]> awesome! Feel free to either base it on my branch or master.

16:28 <enebo[m]> I think the other part is making code to detect unsupported initailize methods

16:28 <byteit101[m]> replace the ConcreteJavaProxy#splitInitialize method with that

16:28 <byteit101[m]> I'll add the rest of the plumbing (and add a second resumeInitialize method)

16:28 <enebo[m]> I was thinking any jump/branch past the super or any branch jump to before the super is enough

16:28 <byteit101[m]> Busy today, but will hopefully have time tomorrow

16:29 <enebo[m]> byteit101: yeah I will try and make something today.

16:29 <byteit101[m]> In theory: if cond; super(a); else super(b,c); end

16:29 <byteit101[m]> is valid

16:30 <byteit101[m]> unsure if we want to allow that

16:30 <enebo[m]> byteit101: I would say not at first

16:30 <enebo[m]> byteit101: but we could detect via flow analysis is all paths super

16:31 <enebo[m]> so I think we could handle it at some point

16:31 <enebo[m]> The other thing which may not mean a lot to you is that I plan on making this work with startup instrs

16:31 <enebo[m]> we make a simple linear set of instrs which are intended for one-time or fast to get up and running code

16:32 <enebo[m]> we then later make "full" interpreter instrs which will make a CFG and run compiler passes and then relinearize back to a list of instrs for interpretation

16:32 <enebo[m]> This second set and the data structures it creates is more for us to bytecode compilation but we also with -X-C will use the full interp

16:33 <enebo[m]> So another future to this might be to support the notion of splitting a method for the JIT (which comes back to the topic of synthetic methods we talked about last week)

16:37 <enebo[m]> The trade-off of startup and full is potentially some speed and for the most part it means startup and JITted (from Full). If we have tons and tons of Java objects calling native super like this then we have more motivation to add it for full/JIT

16:38 <byteit101[m]> makes sense

16:38 <enebo[m]> but for JavaFX initially we are not talking about a lot of objects

16:39 <enebo[m]> and it will definitely be a speed up from what is done today

17:17 <headius[m]> Good morning!

19:54 <lopex[m]> late afternoon!

22:46 <lopex[m]> headius: I'm having problems releasing joni now

22:47 <lopex[m]> what jdk shoud I use for it ?

22:48 <lopex[m]> enebo: ?

22:48 <lopex[m]> it complaing about modules

22:48 <lopex[m]> *complains

22:49 <lopex[m]> ok Il try 11