Node res = null;
/*
* obtenir les paramètres avant le début de l'exécution de la section insure{...} ...
*/
Interpreter interpreter = Interpreter.mySelf();
BaseContextSnapshot contextSnapshot=new BaseContextSnapshot(interpreter);
Exception allExcep = null;
/*
* exécuter la section hook et capturer une éventuelle exception...
*/
try {
Heap.push();
res = xnode.exec(true);
Heap.pull();
}
catch (Exception ex) {
allExcep = ex;
}
/*
* On doit rétablir un environnement exécutable suffisament stable même en cas de
* suppression ou d'exception grave...
*
* La premère chose à faire consiste à bloquer temporairement l'action, si on est
* dans une section temporisée...
*/
long old_deadlockTime_after = interpreter.getDeadlockTime();
boolean old_timeOutCheck_after = interpreter.isTimeOutCheck();
boolean old_timeOutTimerStatus_after = interpreter.getTimeOutTimer().isRunning();
if (old_timeOutCheck_after || old_timeOutTimerStatus_after) {
interpreter.setTimeOutCheck(false);
interpreter.getTimeOutTimer().stop();
}
boolean canloop_after = interpreter.isCanLoop();
boolean inloop_after = interpreter.isInLoop();
long callerSignature_after = interpreter.getCallerSignature();
boolean tailNode_after = interpreter.isTailNode();
boolean terminalNode_after = interpreter.isTerminalNode();
Node oldThisNode_after = interpreter.getThisFunction();
Node oldWrapperNode_after = interpreter.getWrapperFunction();
Node oldSelfNode_after = interpreter.getSelf();
Node oldRootNode_after = interpreter.getRoot();
Node oldIfaceNode_after = interpreter.getIface();
boolean stop_status_after = interpreter.isThreadStopped();
boolean breakingFromSemaphore_after = interpreter.isBreakingFromSEMAPHORE();
boolean endingFromSemaphore_after = interpreter.isEndingFromSEMAPHORE();
int old_equStackLock_A = interpreter.getEquStack_A().lock();
int old_equStackLock_B = interpreter.getEquStack_B().lock();
int old_compareStackLock_A = interpreter.getCompareStack_A().lock();
int old_compareStackLock_B = interpreter.getCompareStack_B().lock();
/*
* Restaurer les paramètres qui ont précédé l'exécution de la section insure...
*
* En cas de problème grave on rétabli les fonctionnlité de base...
*/
contextSnapshot.restore();
/*
* Si l'acteur est en état de suppression...
*
* Passe en mode Fail-over...
*/
boolean old_failOver=interpreter.isFailOver();
interpreter.setFailOver(true);
/*
* exécuter termination{...}...
*/
Node tres=null;
try{
Heap.push();
tres=enode.exec(true);
Heap.pull();
}
catch(Exception e){
Interpreter.Log("Exception in termination:\n"+e);
}
if(tres!=null){
Interpreter.Log("Result value of termination:\n"+tres.toString());
}
/*
* De nouveau, si la pile n'est pas correctement rétablie...
*/
contextSnapshot.restoreGlobalOnly();
/*
* restaurer les paramètres qui ont précédé l'exécution de la section A...
*
* Ceux-ci peuvent être traités par un (try{...} catch{...})
*/
interpreter.setCanLoop(canloop_after);
interpreter.setInLoop(inloop_after);
interpreter.setCallerSignature(callerSignature_after);
interpreter.setTailNode(tailNode_after);
interpreter.setTerminalNode(terminalNode_after);
interpreter.setThisFunction(oldThisNode_after);
interpreter.setWrapperFunction(oldWrapperNode_after);
interpreter.setSelf(oldSelfNode_after);
interpreter.setRoot(oldRootNode_after);
interpreter.setIface(oldIfaceNode_after);
interpreter.getEquStack_A().unlock(old_equStackLock_A);
interpreter.getEquStack_B().unlock(old_equStackLock_B);
interpreter.getCompareStack_A().unlock(old_compareStackLock_A);
interpreter.getCompareStack_B().unlock(old_compareStackLock_B);
/*
* Restaurer le système de timer...
*/
interpreter.setDeadlockTime(old_deadlockTime_after);
interpreter.setTimeOutCheck(old_timeOutCheck_after);
if (old_timeOutCheck_after || old_timeOutTimerStatus_after) {
interpreter.setTimeOutCheck(true);
interpreter.getTimeOutTimer().start();
}
/*
* Rétablir les états de suppression de l'acteur...
*
* Cette partie doit notamment tenir compte de (exit).
*
* Combinaison des états avant/après inclusive...
*
*/
interpreter.setThreadStopped(stop_status_after || interpreter.isThreadStopped());
interpreter.setBreakingFromSEMAPHORE(breakingFromSemaphore_after || interpreter.isBreakingFromSEMAPHORE());
interpreter.setEndingFromSEMAPHORE(endingFromSemaphore_after || interpreter.isEndingFromSEMAPHORE());
interpreter.setTimeOutRaising(old_timeOutCheck_after);
/*
* enlever le fail-over...
*/
interpreter.setFailOver(old_failOver);
/*
* Reporter l'exception initiale...
*/
if(allExcep!=null){
/*
* déclencher l'exception capturée...
*/
throw allExcep;
}
else{
interpreter.throwInterThreadException();
}
/*
* Si tout s'est bien passé, on continue sans souci...
*/