// Note: called only if the input thread does not perform an asynchronous read operation
void SC_TerminalClient::interpretInput()
{
char *data = mInputBuf.getData();
int c = mInputBuf.getSize();
int i = 0;
while( i < c ) {
switch (data[i]) {
case kInterpretCmdLine:
interpretCmdLine(data, i, true);
break;
case kInterpretPrintCmdLine:
interpretCmdLine(data, i, false);
break;
case kRecompileLibrary:
recompileLibrary();
break;
default:
++i;
continue;
}
data += i+1;
c -= i+1;
i = 0;
}
mInputBuf.reset();
if (mUseReadline)
mReadlineSem.post();
else
startInputRead();
}
// WARNING: Call with input locked!
void SC_TerminalClient::interpretInput()
{
char *data = mInputBuf.getData();
int c = mInputBuf.getSize();
int i = 0;
while( i < c ) {
switch (data[i]) {
case kInterpretCmdLine:
interpretCmdLine(s_interpretCmdLine, data, i);
break;
case kInterpretPrintCmdLine:
interpretCmdLine(s_interpretPrintCmdLine, data, i);
break;
case kRecompileLibrary:
recompileLibrary();
break;
default:
++i;
continue;
}
data += i+1;
c -= i+1;
i = 0;
}
mInputBuf.reset();
if( mUseReadline ) pthread_cond_signal( &mInputCond );
}
void SC_TerminalClient::commandLoop()
{
bool haveNext = false;
struct timespec nextAbsTime;
lockSignal();
while( shouldBeRunning() )
{
while ( mSignals ) {
int sig = mSignals;
unlockSignal();
if (sig & sig_input) {
//postfl("input\n");
lockInput();
interpretInput();
// clear input signal, as we've processed anything signalled so far.
lockSignal();
mSignals &= ~sig_input;
unlockSignal();
unlockInput();
}
if (sig & sig_sched) {
//postfl("tick\n");
double secs;
lock();
haveNext = tickLocked( &secs );
// clear scheduler signal, as we've processed all items scheduled up to this time.
// and will enter the wait according to schedule.
lockSignal();
mSignals &= ~sig_sched;
unlockSignal();
unlock();
flush();
//postfl("tick -> next time = %f\n", haveNext ? secs : -1);
ElapsedTimeToTimespec( secs, &nextAbsTime );
}
if (sig & sig_stop) {
stopMain();
lockSignal();
mSignals &= ~sig_stop;
unlockSignal();
}
if (sig & sig_recompile) {
recompileLibrary();
lockSignal();
mSignals &= ~sig_recompile;
unlockSignal();
}
lockSignal();
}
if( !shouldBeRunning() ) {
break;
}
else if( haveNext ) {
int result = pthread_cond_timedwait( &mCond, &mSignalMutex, &nextAbsTime );
if( result == ETIMEDOUT ) mSignals |= sig_sched;
}
else {
pthread_cond_wait( &mCond, &mSignalMutex );
}
}
unlockSignal();
}
void SC_TerminalClient::commandLoop()
{
bool haveNext = false;
struct timespec 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);
ElapsedTimeToTimespec( secs, &nextAbsTime );
}
if (sig & sig_stop) {
stopMain();
}
if (sig & sig_recompile) {
recompileLibrary();
}
lockSignal();
}
if( !shouldBeRunning() ) {
break;
}
else if( haveNext ) {
int result = pthread_cond_timedwait( &mCond, &mSignalMutex, &nextAbsTime );
if( result == ETIMEDOUT ) mSignals |= sig_sched;
}
else {
pthread_cond_wait( &mCond, &mSignalMutex );
}
}
unlockSignal();
}
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();
}
