Amélioration gestion d'erreur + reset define

src/migl/lisp/LispElement.java

@@ -173,9 +173,18 @@ public class LispElement {
 	public static LispElement getElement(Object elt) throws LispError {
 		if(elt instanceof ConsList) {
 			return LispImpl.evaluateList((ConsList<Object>) elt);
+		} else if(elt instanceof String) {
+			//Si c'est un string qui n'est pas un nom reservé
+			String str = (String) elt;
+			boolean skip = false;
+			try {
+				LispImpl.verifyForbiddenName(str);
+			} catch (LispError ex) {
+				skip = true;
+			}
+			if(!skip) return DefineOperator.eval(elt);
 		}
-		//return generate(elt);
-		return DefineOperator.eval(elt);
+		return generate(elt);
 	}
 
 }

src/migl/lisp/LispFactory.java

@@ -1,5 +1,7 @@
 package migl.lisp;
 
+import migl.lisp.operator.DefineOperator;
+
 /**
  * Simple factory to access the interpreter implementation.
  * 
@@ -20,6 +22,7 @@ public class LispFactory {
      * @return a new lisp interpreter.
      */
     public static Lisp makeIntepreter() {
+    	DefineOperator.clear();
     	if(interpreter == null) {
     		interpreter = new LispImpl();
     	}

src/migl/lisp/LispImpl.java

@@ -182,7 +182,7 @@ public class LispImpl implements Lisp {
 		//Si element seul on évalue directement sa valeur
 		try {
 			//return LispElement.generate(lisp);
-			return DefineOperator.eval(lisp);
+			return LispElement.getElement(lisp);
 		} catch (IllegalArgumentException ex) {
 			throw new LispError(ex.getMessage(), ex);
 		}
@@ -329,7 +329,7 @@ public class LispImpl implements Lisp {
 		String operator = LispElement.generate(lisp.car()).toStr();
 		LispOperator op = operators.get(operator);
 		if(op == null) {
-			throw new LispError(new UnsupportedOperationException(operator + LispError.ERR_UNKNOW));
+			throw new LispError(operator + LispError.ERR_UNKNOW, new UnsupportedOperationException("Unknow operator"));
 		}
 		try {
 			return op.apply(operator, lisp.cdr());

src/migl/lisp/operator/DefineOperator.java

@@ -13,24 +13,34 @@ public class DefineOperator implements LispOperator {
 	
 	private static Map<String, ConsList<Object>> define = new HashMap<>();
 	
+	/**
+	 * Vide la liste des variable et expression lambda definit
+	 */
+	public static void clear() {
+		define.clear();
+	}
+	
 	@SuppressWarnings("unchecked")
-	public static LispElement eval(Object elt) {
+	public static LispElement eval(Object elt) throws LispError {
 		if(elt instanceof ConsList) {
 			return eval((ConsList<Object>) elt);
 		}
-		LispElement le = LispElement.generate(elt);
+		//Recup la valeur de l'element
+		LispElement lelt = LispElement.generate(elt);
+		String key;
 		try {
-			ConsList<Object> cl = define.get(le.toStr());
-			if(cl != null) {
-				LispElement lelt = LispElement.generate(cl.car());
-				if(!lelt.toString().contains("lambda")) {
-					return lelt;
-				}
-			}
+			key = lelt.toStr();
 		} catch(IllegalStateException ex) {
-			//Rien 
+			throw new LispError(lelt.toString() + LispError.ERR_UNKNOW);
+		}
+		//Recup la valeur dans la map
+		ConsList<Object> cl = define.get(key);
+		if(cl == null) {
+			//Si aucune valeur alors erreur
+			throw new LispError(key + LispError.ERR_UNKNOW);
 		}
-		return le;
+		//ToDo verifier si ce n'est pas une lambda expression
+		return LispElement.generate(cl.car());
 	}
 	
 	public static LispElement eval(ConsList<Object> lisp) {