package abstrasy.pcfx;
import abstrasy.Interpreter;
import abstrasy.Node;
import abstrasy.PCoder;
import abstrasy.StaticHeap;
import abstrasy.interpreter.InterpreterException;
import abstrasy.interpreter.StdErrors;
/**
* Abstrasy Interpreter
*
* Copyright : Copyright (c) 2006-2012, Luc Bruninx.
*
* Concédée sous licence EUPL, version 1.1 uniquement (la «Licence»).
*
* Vous ne pouvez utiliser la présente oeuvre que conformément à la Licence.
* Vous pouvez obtenir une copie de la Licence à l’adresse suivante:
*
* http://www.osor.eu/eupl
*
* Sauf obligation légale ou contractuelle écrite, le logiciel distribué sous
* la Licence est distribué "en l’état", SANS GARANTIES OU CONDITIONS QUELLES
* QU’ELLES SOIENT, expresses ou implicites.
*
* Consultez la Licence pour les autorisations et les restrictions
* linguistiques spécifiques relevant de la Licence.
*
*
* @author Luc Bruninx
* @version 1.0
*/
public class PCFx_list extends PCFx {
/**
* boucles génératrices de listes.
*
* Respecte la protection des listes finales.
*
* -> résultat jamais final.
*
*/
public PCFx_list() {
}
final private static boolean xPC_Condition(StaticHeap global, Node cnode) throws Exception {
boolean test = false;
global.push();
test = Node.isTrueEquivalent(cnode.exec(true));
global.pull();
return test;
}
/**
* eval
*
* @param startAt Node
* @return Node
* @throws Exception
* @todo Implémenter cette méthode abstrasy.PCFx
*/
public Node eval(Node startAt) throws Exception {
/**
* forme : (list)
*/
if (startAt.size() == 1) {
return Node.createCList();
}
/**
* forme : (list n) -> [NOTHING...n*]
* (list liste) -> copie le conteneur de liste (le contenu n'est pas duppliqué)
* (list "...") -> ["." ...]
* (list deleg) -> résultat de la méthode Self:list
*
* un seul élément est fourni en argument...
*/
if (startAt.size() == 2) {
Node cnode = startAt.getSubNode(1, Node.TYPE_NUMBER | Node.TYPE_CLIST | Node.TYPE_STRING | Node.VTYPE_DELEGABLE);
return Node.node2VList(cnode);
}
/**
* forme : (list {...} while {...})
* ou : (list {...} until {...})
*
* Attention, (list {...} forever) ne devrait peut-être pas être implémenté...
* En effet, la gestion des conditions de sortie peut être oubliée et causer la création d'une liste infinie.
*/
startAt.isGoodArgsCnt(3, 4);
Node cnode = null;
Node modenode = null;
Node xnode = Node.createCList();
Node rnode = null;
if (startAt.size() == 4) {
// forme (list {...} while {...}) et (list {...} until {...})
cnode = startAt.getSubNode(3, Node.VTYPE_VALUABLE);
modenode = startAt.getSubNode(2, Node.TYPE_PCODE);
if (!(modenode.isPCode(PCoder.PC_WHILE) || modenode.isPCode(PCoder.PC_UNTIL))) {
throw new InterpreterException(StdErrors.Syntax_error);
}
boolean untilLoop = modenode.isPCode(PCoder.PC_UNTIL);
Node enode = startAt.getSubNode(1, Node.TYPE_LAZY);
Interpreter interpreter = Interpreter.mySelf();
StaticHeap global = interpreter.getGLOBAL();
boolean oldCanLoop = interpreter.isCanLoop();
boolean oldInLoop = interpreter.isInLoop();
interpreter.setCanLoop(true);
interpreter.setInLoop(true);
//
int href = global.size();
int slock = global.getOffset();
try {
//
boolean loop = true;
while (loop && interpreter.isCanIterate()) {
global.push();
rnode = enode.exec(true);
global.pull();
if (rnode != null)
xnode.addElement(rnode.secure());
loop = (untilLoop ? !xPC_Condition(global, cnode): xPC_Condition(global, cnode));
}
//
}
catch (Exception ex) {
interpreter.consumeBreakCode_onLoop();
interpreter.setCanLoop(oldCanLoop);
interpreter.setInLoop(oldInLoop);
throw ex;
}
if (global.size() != href) {
global.setOffset(slock);
global.setSize(href); // restaurer le heap à la bonne taille
}
//
interpreter.consumeBreakCode_onLoop();
interpreter.setCanLoop(oldCanLoop);
interpreter.setInLoop(oldInLoop);
return xnode;
}
else {
throw new InterpreterException(StdErrors.Syntax_error);
}
}
}