removed "eval" from Remoting APIs.

std/haxe/remoting/AsyncConnection.hx

@@ -44,37 +44,13 @@ class AsyncConnection implements Dynamic<AsyncConnection> {
 	public function onError( err : Dynamic ) {
 	}
 
-	public function eval( onData : Dynamic -> Void ) : Void {
-		var h = new Http(__data);
-		var me = this;
-		h.setHeader("X-Haxe-Remoting","eval");
-		h.setParameter("__x",__path.join("."));
-		h.onData = function(data : String) {
-			var ok = true;
-			var v;
-			try {
-				if( data.length < 3 || data.substr(0,3) != "hxr" )
-					throw "Invalid response : '"+data+"'";
-				var s = new Unserializer(data.substr(3,data.length-3));
-				v = s.unserialize();
-			} catch( err : Dynamic ) {
-				ok = false;
-				me.onError(err);
-			}
-			if( ok )
-				onData(v);
-		};
-		h.onError = onError;
-		h.request(true);
-	}
-
 	public function call( params : Array<Dynamic>, onData : Dynamic -> Void ) : Void {
 		var h = new Http(__data);
 		var me = this;
 		var s = new Serializer();
 		s.serialize(__path);
 		s.serialize(params);
-		h.setHeader("X-Haxe-Remoting","call");
+		h.setHeader("X-Haxe-Remoting","1");
 		h.setParameter("__x",s.toString());
 		h.onData = function(data : String) {
 			var ok = true;

std/haxe/remoting/AsyncDebugConnection.hx

@@ -27,38 +27,59 @@ package haxe;
 class AsyncDebugConnection implements AsyncConnection, implements Dynamic<AsyncDebugConnection> {
 
 	var __data : Dynamic;
-	var __path : Array<String>; // not used here
+	var __path : Array<String>; // not used there
+	var lastCalls : List<{ path : Array<String>, params : Array<Dynamic> }>;
 
 	public function new(cnx) {
 		__data = cnx;
+		lastCalls = new List();
 		onError = cnx.onError;
 		var me = this;
 		cnx.onError = function(e) {
+			var l = me.lastCalls.pop();
+			if( l != null )
+				me.onErrorDisplay(l.path,l.params,e);
 			me.onError(e);
 		}
 	}
 
 	function __resolve(field : String) : AsyncConnection {
 		var s = new AsyncDebugConnection(__data.__resolve(field));
-		s.onError = onError;
+		s.lastCalls = lastCalls;
+		// late binding of events
+		var me = this;
+		s.onError = function(e) { me.onError(e); };
+		s.onCall = function(p,pa) { me.onCall(p,pa); };
+		s.onResult = function(p,pa,r) { me.onResult(p,pa,r); };
+		me.onErrorDisplay = function(p,pa,e) { me.onErrorDisplay(p,pa,e); };
 		return s;
 	}
 
 	public function onError( err : Dynamic ) {
 	}
 
-	public function onTrace( t : String ) {
-		trace(t);
+	public function onErrorDisplay( path : Array<String>, params : Array<Dynamic>, err : Dynamic ) {
+		trace(path.join(".")+"("+params.join(",")+") = ERROR "+Std.string(err));
+	}
+
+	public function onCall( path : Array<String>, params : Array<Dynamic> ) {
 	}
 
-	public function eval( onData : Dynamic -> Void ) : Void {
-		onTrace(__data.__path.join("."));
-		__data.eval(onData);
+	public function onResult( path : Array<String>, params : Array<Dynamic>, result : Dynamic ) {
+		trace(path.join(".")+"("+params.join(",")+") = "+Std.string(result));
 	}
 
 	public function call( params : Array<Dynamic>, onData : Dynamic -> Void ) : Void {
-		onTrace(__data.__path.join(".")+"("+params.join(",")+")");
-		__data.call(params,onData);
+		lastCalls.add({ path : __data.__path, params : params });
+		onCall(__data.__path,params);
+		var me = this;
+		__data.call(params,function(r) {
+			var x = me.lastCalls.pop();
+			if( x != null )
+				me.onResult(x.path,x.params,r);
+			if( onData != null )
+				onData(r);
+		});
 	}
 
 }

std/haxe/remoting/Connection.hx

@@ -40,23 +40,6 @@ class Connection implements Dynamic<Connection> {
 		return s;
 	}
 
-	public function eval() : Dynamic {
-	#if flash
-		return jsEval(__path.join("."));
-	#else js
-		var s = __data.asEval(__path.join("."));
-		return new Unserializer(s).unserialize();
-	#else neko
-		var cnx = AsyncConnection.urlConnect(__data);
-		var result = null;
-		untyped cnx.__path = __path;
-		cnx.onError = function(err) { throw err; };
-		cnx.eval(function(d) { result = d; });
-		return result;
-	#else error
-	#end
-	}
-
 	public function call( params : Array<Dynamic> ) : Dynamic {
 	#if flash
 		var p = __path.copy();
@@ -127,62 +110,28 @@ class Connection implements Dynamic<Connection> {
 	#if flash
 
 	static function __init__() {
-		flash.external.ExternalInterface.addCallback("asEval",null,asEval);
 		flash.external.ExternalInterface.addCallback("doCall",null,doCall);
 	}
 
-	static function asEval( s : String ) : String {
-		var v = flash.Lib.eval(s);
-		var s = new Serializer();
-		s.serialize(v);
-		return s.toString();
-	}
-
-	static function jsEval( s : String ) : Dynamic {
-		var s = flash.external.ExternalInterface.call("haxe.Connection.jsEval",s);
-		if( s == null )
-			throw "Failed to evaluate "+s;
-		return new Unserializer(s).unserialize();
-	}
-
 	public static function jsConnect() : Connection {
 		if( !flash.external.ExternalInterface.available )
 			throw "External Interface not available";
-		if( jsEval("0") != 0 )
+		if( flash.external.ExternalInterface.call("haxe.Connection.jsRemoting") != "yes" )
 			throw "haxe.Connection is not available in JavaScript";
 		return new Connection(null,[]);
 	}
 
 	#else js
 
-	static function jsEval( s : String ) : String {
-		var v;
-		var e = false;
-		try {
-			v = js.Lib.eval(s);
-		} catch( exc : Dynamic ) {
-			v = exc;
-			e = true;
-		}
-		try {
-			var s = new Serializer();
-			if( e )
-				s.serializeException(v);
-			else
-				s.serialize(v);
-			var r = s.toString();
-			return r;
-		} catch( e : Dynamic ) {
-			js.Lib.alert(e);
-			return null;
-		}
+	static function jsRemoting() {
+		return "yes";
 	}
 
 	public static function flashConnect( objId : String ) : Connection {
 		var x : Dynamic = untyped window.document[objId];
 		if( x == null )
 			throw "Could not find flash object '"+objId+"'";
-		if( x.asEval == null ) throw "The flash object is not ready or does not contain haxe.Connection";
+		if( x.doCall == null ) throw "The flash object is not ready or does not contain haxe.Connection";
 		return new Connection(x,[]);
 	}
 

std/haxe/remoting/Server.hx

@@ -57,36 +57,25 @@ class Server {
 	}
 
 	public function handleRequest() {
-		var kind = neko.Web.getClientHeader("X-Haxe-Remoting");
-		if( kind == null )
+		if( neko.Web.getClientHeader("X-Haxe-Remoting") == null )
 			return false;
 		var v = neko.Web.getParams().get("__x");
 		try {
 			if( v == null )
 				throw "Missing remoting data";
-			if( kind == "eval" ) {
-				var obj = resolvePath(v.split("."));
-				var s = new haxe.Serializer();
-				s.serialize(obj);
-				neko.Lib.print("hxr");
-				neko.Lib.print(s.toString());
-			}
-			if( kind == "call" ) {
-				var u = new haxe.Unserializer(v);
-				var path = u.unserialize();
-				var args = u.unserialize();
-				var f = path.pop();
-				var obj = resolvePath(path);
-				var funptr = Reflect.field(obj,f);
-				if( !Reflect.isFunction(funptr) )
-					throw "Calling not-a-function '"+f+"'";
-                var v = Reflect.callMethod(obj,funptr,args);
-				var s = new haxe.Serializer();
-				s.serialize(v);
-				neko.Lib.print("hxr");
-				neko.Lib.print(s.toString());
-			}
-			throw "Unsupported remoting kind '"+kind+"'";
+			var u = new haxe.Unserializer(v);
+			var path = u.unserialize();
+			var args = u.unserialize();
+			var f = path.pop();
+			var obj = resolvePath(path);
+			var funptr = Reflect.field(obj,f);
+			if( !Reflect.isFunction(funptr) )
+				throw "Calling not-a-function '"+f+"'";
+			var v = Reflect.callMethod(obj,funptr,args);
+			var s = new haxe.Serializer();
+			s.serialize(v);
+			neko.Lib.print("hxr");
+			neko.Lib.print(s.toString());
 		} catch( e : Dynamic ) {
 			var s = new haxe.Serializer();
 			s.serializeException(e);

std/haxe/remoting/SocketConnection.hx

@@ -42,19 +42,9 @@ class SocketConnection extends AsyncConnection {
 		return s;
 	}
 
-	public function eval( onData : Dynamic -> Void ) : Void {
-		var s = new haxe.Serializer();
-		s.serialize(true);
-		s.serialize(true);
-		s.serialize(__path);
-		sendMessage(__data,s.toString());
-		__funs.add(onData);
-	}
-
 	public function call( params : Array<Dynamic>, onData : Dynamic -> Void ) : Void {
 		var s = new haxe.Serializer();
 		s.serialize(true);
-		s.serialize(false);
 		s.serialize(__path);
 		s.serialize(params);
 		sendMessage(__data,s.toString());
@@ -166,29 +156,19 @@ class SocketConnection extends AsyncConnection {
 		// ---------------------------
 		var exc = false;
 		try {
-			var iseval : Bool = s.unserialize();
 			var path : Array<String> = s.unserialize();
-			if( iseval ) {
-				#if flash
-				val = flash.Lib.eval(path.join("."));
-				#else neko
-				val = sc.__r.resolvePath(path);
-				#else error
-				#end
-			} else {
-				var args = s.unserialize();
-				var fname = path.pop();
-				#if flash
-				var obj = flash.Lib.eval(path.join("."));
-				#else neko
-				var obj = sc.__r.resolvePath(path);
-				#else error
-				#end
-				var fptr = Reflect.field(obj,fname);
-				if( !Reflect.isFunction(fptr) )
-					throw "Calling not-a-function '"+fname+"'";
-				val = Reflect.callMethod(obj,fptr,args);
-			}
+			var args = s.unserialize();
+			var fname = path.pop();
+			#if flash
+			var obj = flash.Lib.eval(path.join("."));
+			#else neko
+			var obj = sc.__r.resolvePath(path);
+			#else error
+			#end
+			var fptr = Reflect.field(obj,fname);
+			if( !Reflect.isFunction(fptr) )
+				throw "Calling not-a-function '"+fname+"'";
+			val = Reflect.callMethod(obj,fptr,args);
 		} catch( e : Dynamic ) {
 			val = e;
 			exc = true;