StaticRunner_launch
StaticRunner_isRunnerAvailable
StaticRunner_isInterruptibleCommand
-StaticRunner_setInterruptibleCommand
-StaticRunner_getCurrentCommandOrigin
-StaticRunner_setCurrentCommandOrigin
+StaticRunner_setCommandOrigin
StoreConsoleCommand
StorePrioritaryCommand
StoreDebuggerCommand
}
// interrupt me to execute a prioritary command
- while (StaticRunner_isInterruptibleCommand() == 1 && StaticRunner_isRunnerAvailable() == 1)
+ while (StaticRunner_isRunnerAvailable() == 1 && StaticRunner_isInterruptibleCommand() == 1)
{
- // save the origin of the actual running command
- command_origin_t origin = StaticRunner_getCurrentCommandOrigin();
StaticRunner_launch();
- StaticRunner_setInterruptibleCommand(1);
- // restore the origin of the actual running command
- StaticRunner_setCurrentCommandOrigin(origin);
}
//copy from runvisitor::seqexp
*/
#include <fstream>
+
//file included in runvisitor.cpp
namespace ast {
}
// interrupt me to execute a prioritary command
- while (StaticRunner_isInterruptibleCommand() == 1 && StaticRunner_isRunnerAvailable() == 1)
+ while (StaticRunner_isRunnerAvailable() == 1 && StaticRunner_isInterruptibleCommand() == 1)
{
- // save the origin of the actual running command
- command_origin_t origin = StaticRunner_getCurrentCommandOrigin();
StaticRunner_launch();
- StaticRunner_setInterruptibleCommand(1);
- // restore the origin of the actual running command
- StaticRunner_setCurrentCommandOrigin(origin);
}
if (file)
}
// interrupt me to execute a prioritary command
- while (StaticRunner_isInterruptibleCommand() == 1 && StaticRunner_isRunnerAvailable() == 1)
+ while (StaticRunner_isRunnerAvailable() == 1 && StaticRunner_isInterruptibleCommand() == 1)
{
StaticRunner_launch();
- StaticRunner_setInterruptibleCommand(1);
}
//printf input expression line following mode configuration
ConfigVariable::DecreasePauseLevel();
ConfigVariable::macroFirstLine_end();
CoverageInstance::stopChrono((void*)&e);
+ // resume will make the execution continue
+ // event if resume is a console command, it must not release the prompt
+ // because the prompt will be release at the and of the original command
+ StaticRunner_setCommandOrigin(NONE);
return;
}
else
public:
static int launch(void);
static void setRunner(Runner* _RunMe);
- static void setCurrentRunner(Runner* _RunMe);
static Runner* getRunner(void);
- static Runner* getCurrentRunner(void);
static bool isRunnerAvailable(void);
static bool isInterruptibleCommand(void);
- static void setInterruptibleCommand(bool _isInterruptible);
static command_origin_t getCommandOrigin();
- static command_origin_t getCurrentCommandOrigin();
- static void setCurrentCommandOrigin(command_origin_t _origin);
static void execAndWait(ast::Exp* _theProgram, ast::RunVisitor *_visitor,
bool _isInterruptible, bool _isPrioritary, command_origin_t _iCommandOrigin);
static bool exec(ast::Exp* _theProgram, ast::RunVisitor *_visitor);
static void sendExecDoneSignal();
+ static void setCommandOrigin(command_origin_t _origin);
private:
static std::atomic<Runner*> m_RunMe;
static std::atomic<Runner*> m_CurrentRunner;
- static std::atomic<bool> m_bInterruptibleCommand;
};
extern "C"
void StaticRunner_launch(void);
int StaticRunner_isRunnerAvailable(void);
int StaticRunner_isInterruptibleCommand(void);
- void StaticRunner_setInterruptibleCommand(int val);
command_origin_t StaticRunner_getCommandOrigin(void);
- command_origin_t StaticRunner_getCurrentCommandOrigin(void);
- void StaticRunner_setCurrentCommandOrigin(command_origin_t origin);
+ void StaticRunner_setCommandOrigin(command_origin_t _origin);
}
#endif /* !__RUNNER_HXX__ */
int iOldMode = ConfigVariable::getPromptMode();
ConfigVariable::setPromptMode(2);
- // save current runner
- Runner* rCurrent = StaticRunner::getCurrentRunner();
-
- // send the good signal to unlock wait
- // ie: unlock console thread to display prompt again
- StaticRunner::sendExecDoneSignal();
+ // unlock console thread to display prompt again
+ ThreadManagement::SendConsoleExecDoneSignal();
int iPauseLevel = ConfigVariable::getPauseLevel();
while (ConfigVariable::getPauseLevel() == iPauseLevel)
}
}
- // set back the runner to know wich "execution done" signal send
- // StaticRunner::sendExecDoneSignal
- StaticRunner::setCurrentRunner(rCurrent);
-
//return from console so change mode to initial
ConfigVariable::setPromptMode(iOldMode);
}
\ No newline at end of file
std::atomic<Runner*> StaticRunner::m_RunMe(nullptr);
std::atomic<Runner*> StaticRunner::m_CurrentRunner(nullptr);
-std::atomic<bool> StaticRunner::m_bInterruptibleCommand(true);
static bool initialJavaHooks = false;
void StaticRunner::sendExecDoneSignal()
{
- switch (getCurrentRunner()->getCommandOrigin())
+ switch (m_CurrentRunner.load()->getCommandOrigin())
{
case DEBUGGER :
{
break;
}
case CONSOLE :
- case TCLSCI :
- case NONE :
- default :
{
ThreadManagement::SendConsoleExecDoneSignal();
break;
}
+ case TCLSCI :
+ case NONE :
+ default : {}
}
}
}
int iRet = 0;
+
+ // save current runner
+ Runner* pRunSave = m_CurrentRunner.load();
+
// get the runner to execute
std::unique_ptr<Runner> runMe(getRunner());
- // set if the current command is interruptible
- setInterruptibleCommand(runMe->isInterruptible());
+
debugger::DebuggerManager* manager = debugger::DebuggerManager::getInstance();
ConfigVariable::resetExecutionBreak();
if (ConfigVariable::getPauseLevel())
{
ConfigVariable::DecreasePauseLevel();
+ // set back the runner wich have been overwritten in StaticRunner::getRunner
+ m_CurrentRunner.store(pRunSave);
throw ia;
}
// send the good signal about the end of execution
sendExecDoneSignal();
+ // set back the runner wich have been overwritten in StaticRunner::getRunner
+ m_CurrentRunner.store(pRunSave);
throw ia;
}
//clean debugger step flag if debugger is not interrupted ( end of debug )
manager->resetStep();
+
+ // set back the runner wich have been overwritten in StaticRunner::getRunner
+ m_CurrentRunner.store(pRunSave);
+
return iRet;
}
m_RunMe = _RunMe;
}
-void StaticRunner::setCurrentRunner(Runner* _RunMe)
-{
- m_CurrentRunner = _RunMe;
-}
-
Runner* StaticRunner::getRunner(void)
{
- Runner* tmp = m_RunMe.exchange(nullptr);
- setCurrentRunner(tmp);
+ m_CurrentRunner.store(m_RunMe.exchange(nullptr));
ThreadManagement::SendAvailableRunnerSignal();
- return tmp;
-}
-
-Runner* StaticRunner::getCurrentRunner(void)
-{
return m_CurrentRunner.load();
}
return m_RunMe.load() != nullptr;
}
-void StaticRunner::setInterruptibleCommand(bool _bInterruptibleCommand)
-{
- m_bInterruptibleCommand = _bInterruptibleCommand;
-}
-
bool StaticRunner::isInterruptibleCommand()
{
- return m_bInterruptibleCommand;
+ return m_CurrentRunner.load()->isInterruptible();
}
command_origin_t StaticRunner::getCommandOrigin()
return m_RunMe.load()->getCommandOrigin();
}
-command_origin_t StaticRunner::getCurrentCommandOrigin()
-{
- return m_CurrentRunner.load()->getCommandOrigin();
-}
-
-void StaticRunner::setCurrentCommandOrigin(command_origin_t origin)
+void StaticRunner::setCommandOrigin(command_origin_t _origin)
{
- m_CurrentRunner.load()->setCommandOrigin(origin);
+ m_CurrentRunner.load()->setCommandOrigin(_origin);
}
void StaticRunner::execAndWait(ast::Exp* _theProgram, ast::RunVisitor *_visitor,
return StaticRunner::isInterruptibleCommand() ? 1 : 0;
}
-void StaticRunner_setInterruptibleCommand(int val)
-{
- StaticRunner::setInterruptibleCommand(val == 1);
-}
-
command_origin_t StaticRunner_getCommandOrigin(void)
{
return StaticRunner::getCommandOrigin();
}
-command_origin_t StaticRunner_getCurrentCommandOrigin(void)
-{
- return StaticRunner::getCurrentCommandOrigin();
-}
-
-void StaticRunner_setCurrentCommandOrigin(command_origin_t _origin)
+void StaticRunner_setCommandOrigin(command_origin_t _origin)
{
- StaticRunner::setCurrentCommandOrigin(_origin);
+ StaticRunner::setCommandOrigin(_origin);
}