void SC_TerminalClient::tick( const boost::system::error_code& error )
{
	mTimer.cancel();

	double secs;
	lock();
	bool haveNext = tickLocked( &secs );
	unlock();

	flush();

	std::chrono::system_clock::time_point nextAbsTime;
	ElapsedTimeToChrono( secs, nextAbsTime );

	if (haveNext) {
		mTimer.expires_at(nextAbsTime);
		mTimer.async_wait(boost::bind(&SC_TerminalClient::tick, this, _1));
	}
}
void SC_TerminalClient::commandLoop()
{
	bool haveNext = false;
	mutex_chrono::system_clock::time_point nextAbsTime;

	lockSignal();

	while( shouldBeRunning() ) {

		while ( mSignals ) {
			int sig = mSignals;
			mSignals = 0;

			unlockSignal();

			if (sig & sig_input) {
				//postfl("input\n");
				lockInput();
				interpretInput();
				unlockInput();
			}

			if (sig & sig_sched) {
				//postfl("tick\n");
				double secs;
				lock();
				haveNext = tickLocked( &secs );
				unlock();

				flush();

				//postfl("tick -> next time = %f\n", haveNext ? secs : -1);
				ElapsedTimeToChrono( secs, nextAbsTime );
			}

			if (sig & sig_stop) {
				stopMain();
			}

			if (sig & sig_recompile) {
				recompileLibrary();
			}

			lockSignal();
		}

		if( !shouldBeRunning() ) {
			break;
		}
		else if( haveNext ) {
			unlockSignal();
			{
				unique_lock<SC_Lock> lock(mSignalMutex);

				cv_status status = mCond.wait_until(lock, nextAbsTime);
				if( status == cv_status::timeout )
					mSignals |= sig_sched;
			}
			lockSignal();
		}
		else {
			unlockSignal();
			{
				unique_lock<SC_Lock> lock(mSignalMutex);
				mCond.wait(lock);
			}
			lockSignal();
		}
	}

	unlockSignal();
}