package abstrasy.externals;
import abstrasy.Node;
import abstrasy.PCoder;
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 AExtTools {
public AExtTools() {
}
/* public static final void requireArgs(Node commande, int argsCnt) throws Exception {
commande.isGoodArgsLength(true, argsCnt);
}*/
/*public static final void requireMoreThenArgs(Node commande, int argsCnt) throws Exception {
commande.isGoodArgsLength(false, argsCnt);
}*/
/* public static final double getArgNumber(Node commande, int argindex) throws Exception {
return commande.getSubNode(argindex, Node.TYPE_NUMBER).getNumber();
}*/
/* public static final String getArgString(Node commande, int argindex) throws Exception {
return commande.getSubNode(argindex, Node.TYPE_STRING).getString();
}*/
/* public static final Node getArgVObject(Node commande, int argindex) throws Exception {
// retourne l'argument Objet (VObject)
return commande.getSubNode(argindex, Node.TYPE_NAMESPACE);
}*/
/* public static final Node getArgBlock(Node commande, int argindex) throws Exception {
// retourne l'argument Function (NType.Function)
return commande.getSubNode(argindex, Node.TYPE_LAZY);
}*/
/* public static final Node getArgList(Node commande, int argindex) throws Exception {
// retourne l'argument Function (NType.Function)
return commande.getSubNode(argindex, Node.TYPE_LIST);
}*/
/*public static final long getArgType(Node commande, int argindex) {
if (argindex < commande.size() && argindex >= 0) {
return commande.elementAt(argindex).getType();
}
return 0; // pas trouvé le noeud...
}*/
/*public static final long getArgType(Node commande, String key) {
Node node = commande.getPairValue(key);
if (node != null) {
return node.getType();
}
return 0; // pas trouvé le noeud...
}*/
/* public static final double getArgNumber(Node commande, String key) throws Exception {
Node node = commande.getPairValue(key);
node.requireNodeType(Node.TYPE_NUMBER);
return node.getNumber();
}*/
/* public static final String getArgString(Node commande, String key) throws Exception {
Node node = commande.getPairValue(key);
node.requireNodeType(Node.TYPE_STRING);
return node.getString();
}*/
/*public static final Node getArgVObject(Node commande, String key) throws Exception {
Node node = commande.getPairValue(key);
node.requireNodeType(Node.TYPE_NAMESPACE);
return node;
}*/
/*public static final Node getArgLazy(Node commande, String key) throws Exception {
Node node = commande.getPairValue(key);
node.requireNodeType(Node.TYPE_LAZY);
return node;
}*/
/*public static final Node getArgList(Node commande, String key) throws Exception {
Node node = commande.getPairValue(key);
node.requireNodeType(Node.TYPE_LIST);
return node;
}*/
/*public static final boolean throws_ExternalInstanceException(Object obj, Class<?> instance) throws InterpreterException {
throw new InterpreterException(StdErrors.extend(StdErrors.Invalid_parameter, "Object (" + obj.getClass().getName() + ") required " + instance.getName()));
}*/
/* public static final boolean throws_BagArgsValueException(String message) throws InterpreterException {
throw new InterpreterException(StdErrors.extend(StdErrors.Invalid_parameter, message));
}*/
/**
*
*Retourne l'objet correspondant à l'instance external du vobject fourni en argument de la commande à
* la position argindex...
*
* @param commande
* @param argindex
* @return
* @throws Exception
*/
private static final Object getArgExternalInstance(Node commande, int argindex, int accessType) throws Exception {
// retourne l'argument Objet (VObject)
Node src = commande.getSubNode(argindex, Node.TYPE_NAMESPACE);
src.requireAccessType(accessType);
// objet client externe...
return src.getExternalInstanceOf();
}
public static final Object getObjectFromExternalInstance(Node vobject, Class<?> instance, int accessType) throws Exception {
vobject.requireAccessType(accessType);
return vobject.getExternalInstanceOf(instance);
}
/**
* Comme getArgExternalInstance(commande, argindex), mais en ajoutant un test de validité du type
* d'objet à récupérer.
*
* @param commande
* @param argindex
* @param instance
* @return
* @throws Exception
*/
public static final Object getArgExternalInstance(Node commande, int argindex, Class<?> instance, int accessType) throws Exception {
Object obj = getArgExternalInstance(commande, argindex, accessType);
if (instance.isInstance(obj)) {
return obj;
}
else {
throw new InterpreterException(StdErrors.extend(StdErrors.Invalid_parameter, "Object (" + obj.getClass().getName() + ") required " + instance.getName()));
}
}
/*
* N'est plus utilisée...
*
public static void setVar(String symbol, Node value) throws Exception {
// exemple: accès à la variable x dans l'objet virtuel d'interface -> Self:x...
abstrasy.Heap.setv(symbol, value);
}
public static StaticHeap getGlobalHeap() {
return Interpreter.mySelf().getGLOBAL();
}
*/
/* public static String getCurrentInterpreterThreadName() {
return Interpreter.mySelf().getName();
}*/
/* public static boolean isInterpreterThreadIsAlive(String interThreadName) {
return Interpreter.getSemaphore().isThreadsExists(interThreadName);
}*/
/* public static boolean sendMSG_ext2int(String interThreadName, Node msg) {
synchronized (Interpreter.getSemaphore()) {
Interpreter thread = Interpreter.getSemaphore().getThread(interThreadName);
if (thread != null) {
thread.actor_RESUME();
thread.actor_PUTMSG(msg);
Thread.yield();
return true;
}
else {
return false;
}
}
}*/
/*
* N'est plus utilisée...
*
public static Node getVar(String symbol) throws Exception {
return abstrasy.Heap.getv(symbol);
}
*
*/
public static Node createSExpression(String symbol, Node[] args) throws Exception {
// crée un link de la forme (symbol arg0 arg1 arg2 ... argn)
Node res = Node.createExpr();
res.addElement(Node.createSymbol(symbol));
for (int i = 0; i < args.length; i++) {
res.addElement(args[i]);
}
return res;
}
/* public static Node createSExpression(String symbol, Node args) throws Exception {
// crée un link de la forme (symbol arg0 arg1 arg2 ... argn)
Node res = Node.createExpr();
res.addElement(Node.createSymbol(symbol));
for (int i = 0; i < args.size(); i++) {
res.addElement(args.elementAt(i));
}
return res;
}*/
public static Node createNewExpr(Node classNode) throws Exception {
// crée un link de la forme (new |symbol ou "string"|)
return Node.createQExpr().append(Node.createPCode(PCoder.PC_NEW)).append(classNode);
}
public static Node createNewExpr(Node classNode, Node withFunction) throws Exception {
return Node.createQExpr().append(Node.createPCode(PCoder.PC_NEW)).append(classNode).append(Node.createPCode(PCoder.PC_USING)).append(withFunction);
}
private static final Node unImbric_(Node node) {
if (node.size() == 1 && (node.isExpr() || node.isLazy())) {
return unImbric_(node.elementAt(0));
}
else {
return node;
}
}
/**
* Offre la possibilité de pré-compiler du code source abstrasy et de retourner la structure abstraite.
* Notez cependant que cette fonction est à utiliser de préférence dans le cadre d'une évaluation paresseuse:
*
* Exemple:
* --------
*
* Node pcfx=null;
*
* ...
*
* if(pcfx==null){
* try{
* pcfx=External.precompile("{...}");
* catch(Exception ex){
* // gérer les problèmes éventuels...
* }
*
* @param source
* @return Node
* @throws Exception
*/
public static final Node precompile(String source) throws Exception {
Node cnode = Node.compile(source);
cnode = unImbric_(cnode); // transforme en fonction systématiquement...
if (!cnode.isLazy()) {
cnode = Node.createLazy().append(cnode);
}
return cnode;
}
public static final class SerializationTK {
private static final Node OPN_NEW = Node.createPCode(PCoder.PC_NEW).letFinal(true);
/**
* Permet de générer facilement une expression '((new classname) 'init arg0 arg1 ...)...
*
* @param className (String) Nom de la classe Abstrasy
* @param args (Node) liste des arguments
* @return Node correspondant à l'expression forgée
* @throws Exception
*/
public static final Node createInitExpr(Node classNode, Node... args) throws Exception {
// générer l'expression (new className)...
Node expr_new = Node.createExpr().append(OPN_NEW).append(classNode);
// générer l'expression ((new className) ':init! ...)...
Node expr_init = Node.createExpr().append(expr_new).append(Node.createQSymbol(":init!"));
// ajouter les arguments...
for (int i = 0; i < args.length; i++)
expr_init.addElement(args[i]);
return expr_init.letQuoted(true);
}
}
}