protected override int?TryInteractiveAction()
{
try {
return(base.TryInteractiveAction());
} catch (ThreadAbortException e) {
Exception visibleException = RubyUtils.GetVisibleException(e);
if (visibleException == e || visibleException == null)
{
throw;
}
else
{
throw visibleException;
}
} catch (SystemExit e) {
return(e.Status);
}
}
private static void RubyThreadStart(RubyContext /*!*/ context, BlockParam /*!*/ startRoutine, object[] /*!*/ args, ThreadGroup group)
{
RubyThreadInfo info = RubyThreadInfo.FromThread(Thread.CurrentThread);
info.CreatedFromRuby = true;
info.Group = group;
try {
object threadResult;
// TODO: break/returns might throw LocalJumpError if the RFC that was created for startRoutine is not active anymore:
if (startRoutine.Yield(args, out threadResult) && startRoutine.Returning(threadResult, out threadResult))
{
info.Exception = new ThreadError("return can't jump across threads");
}
info.Result = threadResult;
} catch (MethodUnwinder) {
info.Exception = new ThreadError("return can't jump across threads");
} catch (Exception e) {
if (info.ExitRequested)
{
// Note that "e" may not be ThreadAbortException at this point If an exception was raised from a finally block,
// we will get that here instead
Utils.Log(String.Format("Thread {0} exited.", info.Thread.ManagedThreadId), "THREAD");
info.Result = false;
#if !SILVERLIGHT
Thread.ResetAbort();
#endif
}
else
{
e = RubyUtils.GetVisibleException(e);
RubyExceptionData.ActiveExceptionHandled(e);
info.Exception = e;
StringBuilder trace = new StringBuilder();
trace.Append(e.Message);
trace.AppendLine();
trace.AppendLine();
trace.Append(e.StackTrace);
trace.AppendLine();
trace.AppendLine();
RubyExceptionData data = RubyExceptionData.GetInstance(e);
if (data.Backtrace != null)
{
foreach (var frame in data.Backtrace)
{
trace.Append(frame.ToString());
}
}
Utils.Log(trace.ToString(), "THREAD");
if (_globalAbortOnException || info.AbortOnException)
{
throw;
}
}
} finally {
// Its not a good idea to terminate a thread which has set Thread.critical=true, but its hard to predict
// which thread will be scheduled next, even with green threads. However, ConditionVariable.create_timer
// in monitor.rb explicitly does "Thread.critical=true; other_thread.raise" before exiting, and expects
// other_thread to be scheduled immediately.
// To deal with such code, we release the critical monitor here if the current thread is holding it
if (context.RubyOptions.Compatibility < RubyCompatibility.Ruby19 && context.CriticalThread == Thread.CurrentThread)
{
SetCritical(context, false);
}
}
}