fix pause, resume, abort management 42/21342/9
Cedric Delamarre [Mon, 17 Feb 2020 14:49:40 +0000 (15:49 +0100)]
  * check there is no more VALGRIND/ASAN report when
    - abort in a pause (inside an executed script or not)
    - resume or abort after a ctrl-C in a "while %t, end"

  * check there is no more prompt when resume a paused loop

  * another test:

    uicontrol("style", "pushbutton", "string", "Default", "position", [50 50 100 30], "callback", "disp(""Default"")");
    uicontrol("style", "pushbutton", "string", "Prioritary", "position", [50 100 100 30], "callback", "disp(""Prioritary"")", "Callback_Type", 10);

    while %t,end

    click on Proritary button have to display "Prioritary"
    click on Default have to display nothing
    then Ctrl-C
    "Default" have to be displayed,
    resume must not show the prompt and abort have to go out of the loop.

Change-Id: I7c8f2a1a0a60975e6b91ac5920a79771d94114fd

scilab/modules/ast/core_Import.def
scilab/modules/ast/src/cpp/ast/debuggervisitor.cpp
scilab/modules/ast/src/cpp/ast/run_SeqExp.hpp
scilab/modules/ast/src/cpp/ast/runvisitor.cpp
scilab/modules/core/includes/runner.hxx
scilab/modules/core/src/cpp/pause.cpp
scilab/modules/core/src/cpp/runner.cpp

index 847fac8..d18b22c 100644 (file)
@@ -7,9 +7,7 @@ MyHeapAlloc
 StaticRunner_launch
 StaticRunner_isRunnerAvailable
 StaticRunner_isInterruptibleCommand
-StaticRunner_setInterruptibleCommand
-StaticRunner_getCurrentCommandOrigin
-StaticRunner_setCurrentCommandOrigin
+StaticRunner_setCommandOrigin
 StoreConsoleCommand
 StorePrioritaryCommand
 StoreDebuggerCommand
index d531309..54a98bd 100644 (file)
@@ -224,14 +224,9 @@ void DebuggerVisitor::visit(const SeqExp  &e)
         }
 
         // 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
index 8429c39..d650ecb 100644 (file)
@@ -14,6 +14,7 @@
 */
 
 #include <fstream>
+
 //file included in runvisitor.cpp
 namespace ast {
 
@@ -63,14 +64,9 @@ void RunVisitorT<T>::visitprivate(const SeqExp  &e)
         }
 
         // 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)
@@ -98,10 +94,9 @@ void RunVisitorT<T>::visitprivate(const SeqExp  &e)
         }
 
         // 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
index 2ae6d1c..78113c0 100644 (file)
@@ -914,6 +914,10 @@ void RunVisitorT<T>::visitprivate(const ReturnExp &e)
             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
index 5da7cae..a319e20 100644 (file)
@@ -81,24 +81,19 @@ class StaticRunner
 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"
@@ -106,10 +101,8 @@ 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__ */
index 3c2df7e..c1be665 100644 (file)
@@ -27,12 +27,8 @@ void pause(void)
     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)
@@ -45,10 +41,6 @@ void pause(void)
         }
     }
 
-    // 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
index 5b67e24..5b179c2 100644 (file)
@@ -31,13 +31,12 @@ extern "C"
 
 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 :
         {
@@ -45,13 +44,13 @@ void StaticRunner::sendExecDoneSignal()
             break;
         }
         case CONSOLE :
-        case TCLSCI :
-        case NONE :
-        default :
         {
             ThreadManagement::SendConsoleExecDoneSignal();
             break;
         }
+        case TCLSCI :
+        case NONE :
+        default : {}
     }
 }
 
@@ -66,10 +65,13 @@ int StaticRunner::launch()
     }
 
     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();
@@ -149,6 +151,8 @@ int StaticRunner::launch()
         if (ConfigVariable::getPauseLevel())
         {
             ConfigVariable::DecreasePauseLevel();
+            // set back the runner wich have been overwritten in StaticRunner::getRunner
+            m_CurrentRunner.store(pRunSave);
             throw ia;
         }
 
@@ -165,6 +169,8 @@ int StaticRunner::launch()
         // 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;
     }
 
@@ -196,6 +202,10 @@ int StaticRunner::launch()
 
     //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;
 }
 
@@ -204,21 +214,10 @@ void StaticRunner::setRunner(Runner* _RunMe)
     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();
 }
 
@@ -228,14 +227,9 @@ bool StaticRunner::isRunnerAvailable(void)
     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()
@@ -243,14 +237,9 @@ 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,
@@ -305,22 +294,12 @@ int StaticRunner_isInterruptibleCommand(void)
     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);
 }