Function InitNewThread

source/application.cpp:1818–1885

void InitNewThread(int aPriority, bool aSkipUninterruptible, bool aIncrementThreadCountAndUpdateTrayIcon
	, bool aIsCritical)
// The value of aIsCritical is ignored when aSkipUninterruptible==true.
// To reduce the expectation that a newly launched hotkey or timed subroutine will
// be immediately interrupted by a timed subroutine or hotkey, interruptions are
// forbidden for a short time (user-configurable).  If the subroutine is a quick one --
// finishing prior to when ExecUntil() or the Timer would have set g_AllowInterruption to be
// true -- we will set it to be true afterward so that it gets done as quickly as possible.
// The following rules of precedence apply:
// If either UninterruptibleTime or UninterruptedLineCountMax is zero, newly launched subroutines
// are always interruptible.  Otherwise: If both are negative, newly launched subroutines are
// never interruptible.  If only one is negative, newly launched subroutines cannot be interrupted
// due to that component, only the other one (which is now known to be positive otherwise the
// first rule of precedence would have applied).
{
	if (aIncrementThreadCountAndUpdateTrayIcon)
	{
		++g_nThreads; // It is the caller's responsibility to avoid calling us if the thread count is too high.
		// Once g_array[0] is used by AutoExec section, it's never used by any other thread because:
		//  1) the auto-execute thread might never finish, in which case it needs to keep consulting the values in g_array[0].
		//  2) it's used to retain the default settings for each newly launched thread.
		++g; 
	}
	// Copy only settings, not state, from the auto-execute thread.
	memcpy(static_cast<ScriptThreadSettings*>(g), static_cast<ScriptThreadSettings*>(&g_default), sizeof(ScriptThreadSettings));

	global_struct &g = *::g; // Must be done AFTER the ++g above. Reduces code size and may improve performance.
	global_clear_state(g);
	g.Priority = aPriority;

	// If the current quasi-thread is paused, the thread we're about to launch will not be, so the tray icon
	// needs to be checked unless the caller said it wasn't needed.  In any case, if the tray icon is already
	// in the right state (which it usually, since paused threads are rare), UpdateTrayIcon() is a very fast call.
	if (aIncrementThreadCountAndUpdateTrayIcon)
		g_script.UpdateTrayIcon(); // Must be done ONLY AFTER updating "g" (e.g, ++g) and/or g->IsPaused.

	if (aSkipUninterruptible)
		return;

	if (!g.ThreadIsCritical)
		g.ThreadIsCritical = aIsCritical;

	if (g_script.mUninterruptibleTime && g_script.mUninterruptedLineCountMax // Both components must be non-zero to start off uninterruptible.
		|| g.ThreadIsCritical) // v1.0.38.04.
	{
		g.AllowThreadToBeInterrupted = false;
		if (!g.ThreadIsCritical)
		{
			if (g_script.mUninterruptibleTime < 0) // A setting of -1 (or any negative) means the thread's uninterruptibility never times out.
				g.UninterruptibleDuration = -1; // "Lock in" the above because for backward compatibility, above is not supposed to affect threads after they're created. Override the default value contained in g_default.
				//g.ThreadStartTime doesn't need to be set when g.UninterruptibleDuration < 0.
			else // It's now known to be >0 (due to various checks above).
			{
				// For backward compatibility, "lock in" the time this thread will become interruptible
				// because that's how previous versions behaved (i.e. 'Thread "Interrupt", NewTimeout'
				// doesn't affect the current thread, only the thread creation behavior in the future).
				// This also makes it more predictable, since AllowThreadToBeInterrupted is only changed
				// when IsInterruptible() is called, which might not happen in between changes to the setting.