int SC_TerminalClient::run(int argc, char** argv)
{
Options& opt = mOptions;
if (!parseOptions(argc, argv, opt)) {
return mReturnCode;
}
// finish argv processing
const char* codeFile = 0;
if (argc > 0) {
codeFile = argv[0];
opt.mDaemon = true;
argv++; argc--;
}
opt.mArgc = argc;
opt.mArgv = argv;
// read library configuration file
if (opt.mLibraryConfigFile) {
int argLength = strlen(opt.mLibraryConfigFile);
SC_LanguageConfig::readLibraryConfigYAML(opt.mLibraryConfigFile);
} else
SC_LanguageConfig::readDefaultLibraryConfig();
// initialize runtime
initRuntime(opt);
// startup library
mShouldBeRunning = true;
compileLibrary();
// enter main loop
if (codeFile) executeFile(codeFile);
if (opt.mCallRun) runMain();
if (opt.mDaemon) {
daemonLoop();
}
else {
initInput();
if( shouldBeRunning() ) startInput();
if( shouldBeRunning() ) commandLoop();
endInput();
cleanupInput();
}
if (opt.mCallStop) stopMain();
// shutdown library
shutdownLibrary();
flush();
shutdownRuntime();
return mReturnCode;
}
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();
}
