Add Ctrl-C handling to the REPL

[jaykru]

I noticed that you can't stop execution with a SIGINT when working interactively at the REPL (it does seem to work for loaded files) so I went ahead and tried adding it. Would be glad to know if there is a less invasive way of doing this!

[rblanckaert]

Thanks for your contribution! This seems like a great feature for the repl to have.
However, as implemented there is a performance penalty and some surprising behavior to people who are using luau as a library.

[rblanckaert]

This check is too expensive to run after every opcode. The VM_INTERRUPT macro already checks the status in places where loops and calls can occur. Just wait for the PC to reach one of these existing checks.

[rblanckaert]

See previous comment, but also wouldn't the behavior need to be the same as above for this to work as submitted?

[jaykru]

Definitely! Just forgot to duplicate my changes from the macro above.

[rblanckaert]

Not every implementor is going to want this behavior. This should be setup inside the Repl.cpp. There the CLI could have a signal handler that reaches into its global lua_State and sets the status variable.

[zeux]

Correction: it should be sufficient for this entire feature to be implemented in Repl; instead of setting a status variable (and checking it in VM_INTERRUPT), it should be sufficient to dynamically set the interrupt callback from Repl. Some care needs to be taken in the profiler support code (in Repl) so that the profile callback doesn't overwrite the interrupt callback, but otherwise the interrupt callback is a fully general mechanism that should be sufficient to perform termination here.

[zeux]

I believe this would also need some Windows-specific code as SIGINT isn't supported on Windows.

[jaykru]

I went ahead and reimplemented the functionality using the interrupt handler scheme as suggested by @zeux. Let me know how this looks 😃 I had to add a couple things to lapi due to a circular import problem I didn't quite understand...not sure if that was the correct approach.

Haven't yet had a chance to look into reproducing this for Windows; maybe tomorrow evening!

[zeux]

This still has core changes that are not necessary:

• Interrupt handler should raise an error if SIGINT was raised; the error will be caught at the top level. The global sigint flag needs to be reset at the top level to correctly break out of pcall.
• LUA_SIGINT status is not necessary, and neither is lua_setstatus (the latter is dangerous as it can put the thread into an inconsistent state depending on how it's used).
• Setting interrupt handler can be done via lua_callbacks

Additionally, the preferred mode of operation for interrupt handlers is to set them lazily (this can be done on any thread / signal), in this case instead of the flag what should probably happen is that the signal handler should set the interrupt callback that errors unconditionally, and the top-level should clear the interrupt handler after handling the error.

[zeux]

This should be luaL_error(L, "Execution interrupted"); (compatible with building Luau without use of exceptions)

[jaykru]

So, I tried replacing the exception with a call to luaL_error in my most recent commit. This works fine as a drop-in replacement in the release build, but results in the following error on Ctrl-C in the debug build:

VM/src/lapi.cpp(600): ASSERTION FAILED: L->top < L->ci->top
Illegal instruction

Is this behavior expected? or should I file an issue?

[zeux]

This required lua_rawcheckstack(L, 1); as inside the interrupt callback the LUA_MINSTACK guarantee is (intentionally) not upheld.

[jaykru]

This still has core changes that are not necessary:

• Interrupt handler should raise an error if SIGINT was raised; the error will be caught at the top level. The global sigint flag needs to be reset at the top level to correctly break out of pcall.

The most recent commit raises an error with luaL_error. I didn't understand the latter concern about resetting the sigint flag to break out of pcall, but it seems like it may not be relevant with the switch to lazy interrupt setting that I also rolled into the most recent commit.

• LUA_SIGINT status is not necessary, and neither is lua_setstatus (the latter is dangerous as it can put the thread into an inconsistent state depending on how it's used).

I've addressed both of these concerns.

• Setting interrupt handler can be done via lua_callbacks

I removed my custom interrupt handler setter and use lua_callbacks in the most recent commit.

Additionally, the preferred mode of operation for interrupt handlers is to set them lazily (this can be done on any thread / signal), in this case instead of the flag what should probably happen is that the signal handler should set the interrupt callback that errors unconditionally, and the top-level should clear the interrupt handler after handling the error.

This is also addressed in the most recent commit, although I had to keep track of a global lua_State for the repl because I'm not able to pass any context beyond the signal value to the signal handler. I'm not certain this is the best way to do this.

[zeux]

Sorry this got stuck a little bit, I think this looks good now modulo some style issues, I'll clean this up a little and merge it next week.

[jaykru]

Sounds good, @zeux. Thanks! :)