minor typing fixes.

codegen.ml

@@ -22,6 +22,25 @@ open Type
 open Common
 open Typecore
 
+(* -------------------------------------------------------------------------- *)
+(* TOOLS *)
+
+let field e name t p =
+	mk (TField (e,name)) t p
+
+let fcall e name el ret p =
+	let ft = tfun (List.map (fun e -> e.etype) el) ret in
+	mk (TCall (field e name ft p,el)) ret p
+
+let string com str p =
+	mk (TConst (TString str)) com.type_api.tstring p
+
+let binop op a b t p =
+	mk (TBinop (op,a,b)) t p
+
+let index com e index t p =
+	mk (TArray (e,mk (TConst (TInt (Int32.of_int index))) com.type_api.tint p)) t p
+
 (* -------------------------------------------------------------------------- *)
 (* REMOTING PROXYS *)
 
@@ -414,83 +433,100 @@ let block_vars e =
 (* -------------------------------------------------------------------------- *)
 (* STACK MANAGEMENT EMULATION *)
 
-let emk e = mk e (mk_mono()) null_pos
-
-let stack_var = "$s"
-let exc_stack_var = "$e"
-let stack_var_pos = "$spos"
-let stack_e = emk (TLocal stack_var)
-let stack_pop = emk (TCall (emk (TField (stack_e,"pop")),[]))
-
-let stack_push useadd (c,m) =
-	emk (TCall (emk (TField (stack_e,"push")),[
-		if useadd then
-			emk (TBinop (
-				OpAdd,
-				emk (TConst (TString (s_type_path c.cl_path ^ "::"))),
-				emk (TConst (TString m))
-			))
-		else
-			emk (TConst (TString (s_type_path c.cl_path ^ "::" ^ m)))
-	]))
-
-let stack_save_pos =
-	emk (TVars [stack_var_pos, t_dynamic, Some (emk (TField (stack_e,"length")))])
-
-let stack_restore_pos =
-	let ev = emk (TLocal exc_stack_var) in
-	[
-	emk (TBinop (OpAssign, ev, emk (TArrayDecl [])));
-	emk (TWhile (
-		emk (TBinop (OpGte,
-			emk (TField (stack_e,"length")),
-			emk (TLocal stack_var_pos)
-		)),
-		emk (TCall (
-			emk (TField (ev,"unshift")),
-			[emk (TCall (
-				emk (TField (stack_e,"pop")),
-				[]
-			))]
-		)),
-		NormalWhile
-	));
-	emk (TCall (emk (TField (stack_e,"push")),[ emk (TArray (ev,emk (TConst (TInt 0l)))) ]))
-	]
-
-let rec stack_block_loop e =
+type stack_context = {
+	stack_var : string;
+	stack_exc_var : string;
+	stack_pos_var : string;
+	stack_pos : pos;
+	stack_expr : texpr;
+	stack_pop : texpr;
+	stack_save_pos : texpr;
+	stack_restore : texpr list;
+	stack_push : tclass -> string -> texpr;
+	stack_return : texpr -> texpr;
+}
+
+let stack_context_init com stack_var exc_var pos_var tmp_var use_add p =
+	let t = com.type_api in
+	let st = t.tarray t.tstring in
+	let stack_e = mk (TLocal stack_var) st p in
+	let exc_e = mk (TLocal exc_var) st p in	
+	let stack_pop = fcall stack_e "pop" [] t.tstring p in
+	let stack_push c m =
+		fcall stack_e "push" [
+			if use_add then
+				binop OpAdd (string com (s_type_path c.cl_path ^ "::") p) (string com m p) t.tstring p
+			else
+				string com (s_type_path c.cl_path ^ "::" ^ m) p
+		] t.tvoid p
+	in
+	let stack_return e =
+		mk (TBlock [
+			mk (TVars [tmp_var, e.etype, Some e]) t.tvoid e.epos;
+			stack_pop;
+			mk (TReturn (Some (mk (TLocal tmp_var) e.etype e.epos))) e.etype e.epos
+		]) e.etype e.epos
+	in
+	{
+		stack_var = stack_var;
+		stack_exc_var = exc_var;
+		stack_pos_var = pos_var;
+		stack_pos = p;
+		stack_expr = stack_e;
+		stack_pop = stack_pop;
+		stack_save_pos = mk (TVars [pos_var, t.tint, Some (field stack_e "length" t.tint p)]) t.tvoid p;
+		stack_push = stack_push;
+		stack_return = stack_return;
+		stack_restore = [
+			binop OpAssign exc_e (mk (TArrayDecl []) st p) st p;
+			mk (TWhile (
+				binop OpGte	(field stack_e "length" t.tint p) (mk (TLocal pos_var) t.tint p) t.tbool p,
+				fcall exc_e "unshift" [fcall stack_e "pop" [] t.tstring p] t.tvoid p,
+				NormalWhile
+			)) t.tvoid p;
+			fcall stack_e "push" [index com exc_e 0 t.tstring p] t.tvoid p
+		];
+	}
+
+let stack_init com use_add =
+	stack_context_init com "$s" "$e" "$spos" "$tmp" use_add null_pos
+
+let rec stack_block_loop ctx e =
 	match e.eexpr with
 	| TFunction _ ->
 		e
 	| TReturn None | TReturn (Some { eexpr = TConst _ }) | TReturn (Some { eexpr = TLocal _ }) ->
 		mk (TBlock [
-			stack_pop;
+			ctx.stack_pop;
 			e;
 		]) e.etype e.epos
-	| TReturn (Some e) ->
-		mk (TBlock [
-			mk (TVars ["$tmp", t_dynamic, Some (stack_block_loop e)]) t_dynamic e.epos;
-			stack_pop;
-			mk (TReturn (Some (mk (TLocal "$tmp") t_dynamic e.epos))) t_dynamic e.epos
-		]) e.etype e.epos
+	| TReturn (Some e) ->	
+		ctx.stack_return (stack_block_loop ctx e)
 	| TTry (v,cases) ->
-		let v = stack_block_loop v in
+		let v = stack_block_loop ctx v in
 		let cases = List.map (fun (n,t,e) ->
-			let e = stack_block_loop e in
+			let e = stack_block_loop ctx e in
 			let e = (match (mk_block e).eexpr with
-				| TBlock l -> mk (TBlock (stack_restore_pos @ l)) e.etype e.epos
+				| TBlock l -> mk (TBlock (ctx.stack_restore @ l)) e.etype e.epos
 				| _ -> assert false
 			) in
 			n , t , e
 		) cases in
 		mk (TTry (v,cases)) e.etype e.epos
 	| _ ->
-		map_expr stack_block_loop e
+		map_expr (stack_block_loop ctx) e
 
-let stack_block ?(useadd=false) ctx e =	
+let stack_block ctx c m e =	
 	match (mk_block e).eexpr with
-	| TBlock l -> mk (TBlock (stack_push useadd ctx :: stack_save_pos :: List.map stack_block_loop l @ [stack_pop])) e.etype e.epos
-	| _ -> assert false
+	| TBlock l -> 
+		mk (TBlock (
+			ctx.stack_push c m ::
+			ctx.stack_save_pos :: 
+			List.map (stack_block_loop ctx) l
+			@ [ctx.stack_pop]
+		)) e.etype e.epos
+	| _ ->
+		assert false
 
 (* -------------------------------------------------------------------------- *)
 (* MISC FEATURES *)

common.ml

@@ -104,7 +104,11 @@ let create() =
 	}
 
 let defined ctx v = PMap.mem v ctx.defines
-let define ctx v = ctx.defines <- PMap.add v () ctx.defines
+
+let define ctx v =
+	ctx.defines <- PMap.add v () ctx.defines;
+	let v = String.concat "_" (ExtString.String.nsplit v "-") in
+	ctx.defines <- PMap.add v () ctx.defines
 
 let error msg p = raise (Abort (msg,p))
 

genjs.ml

@@ -23,6 +23,7 @@ type ctx = {
 	com : Common.context;
 	buf : Buffer.t;
 	packages : (string list,unit) Hashtbl.t;
+	stack : Codegen.stack_context;
 	mutable current : tclass;
 	mutable statics : (tclass * string * texpr) list;
 	mutable inits : texpr list;
@@ -72,7 +73,7 @@ let rec concat ctx s f = function
 
 let fun_block ctx f =
 	if ctx.com.debug then
-		Codegen.stack_block (ctx.current,fst ctx.curmethod) f.tf_expr
+		Codegen.stack_block ctx.stack ctx.current (fst ctx.curmethod) f.tf_expr
 	else
 		mk_block f.tf_expr
 
@@ -674,6 +675,7 @@ let generate_type ctx = function
 let generate com =
 	let ctx = {
 		com = com;
+		stack = Codegen.stack_init com false;
 		buf = Buffer.create 16000;
 		packages = Hashtbl.create 0;
 		statics = [];
@@ -694,9 +696,9 @@ let generate com =
 	print ctx "js.Boot.__res = {}";
 	newline ctx;
 	if com.debug then begin
-		print ctx "%s = []" Codegen.stack_var;
+		print ctx "%s = []" ctx.stack.Codegen.stack_var;
 		newline ctx;
-		print ctx "%s = []" Codegen.exc_stack_var;
+		print ctx "%s = []" ctx.stack.Codegen.stack_exc_var;
 		newline ctx;
 	end;
 	Hashtbl.iter (fun name data ->

genswf8.ml

@@ -27,6 +27,8 @@ type register =
 
 type context = {
 
+	stack : Codegen.stack_context;
+
 	(* segs *)
 	mutable segs : (actions * (string * bool, int) Hashtbl.t) list;
 
@@ -190,7 +192,8 @@ let rec is_protected_path path ext =
 	match path with
 	| ["flash"] , "Boot" | ["flash"] , "Lib" -> false
 	| "flash" :: _ , _ | [] , "flash" -> ext
-	| [] , "Array" | [] , "Math" | [] , "Date" | [] , "String" -> true
+	| [] , "Array" | [] , "Math" | [] , "Date" | [] , "String" | [] , "Bool" -> true
+	| [] , "Int" | [] , "Float" | [] , "Xml" -> true
 	| "_global" :: l , n -> is_protected_path (l,n) ext
 	| _ -> false
 
@@ -541,7 +544,7 @@ let rec gen_constant ctx c p =
 	| TSuper -> assert false
 
 let access_local ctx s =
-	match (try PMap.find s ctx.regs , false with Not_found -> NoReg, true) with
+	match (try PMap.find s ctx.regs , false with Not_found -> NoReg, s <> "Enum") with
 	| NoReg , flag ->
 		push ctx [VStr (s,flag)];
 		VarStr
@@ -967,14 +970,13 @@ and gen_expr_2 ctx retval e =
 		let tf = begin_func ctx reg_super (Codegen.local_find true "__arguments__" f.tf_expr) rargs in
 		ctx.fun_pargs <- (ctx.code_pos, List.rev !pargs) :: ctx.fun_pargs;
 		if ctx.com.debug then begin
-			let cur = (ctx.curclass,fst ctx.curmethod) in
-			gen_expr ctx false (Codegen.stack_push true cur);
-			gen_expr ctx false Codegen.stack_save_pos;
+			gen_expr ctx false (ctx.stack.Codegen.stack_push ctx.curclass (fst ctx.curmethod));
+			gen_expr ctx false ctx.stack.Codegen.stack_save_pos;
 			let start_try = gen_try ctx in
-			gen_expr ctx false (Codegen.stack_block_loop f.tf_expr);
+			gen_expr ctx false (Codegen.stack_block_loop ctx.stack f.tf_expr);
 			let end_try = start_try() in
 			(* if $spos == 1 , then no upper call, so report as uncaught *)
-			getvar ctx (access_local ctx Codegen.stack_var_pos);
+			getvar ctx (access_local ctx ctx.stack.Codegen.stack_pos_var);
 			push ctx [VInt 1];
 			write ctx AEqual;
 			write ctx ANot;
@@ -1314,8 +1316,9 @@ let gen_type_def ctx t =
 		push ctx [VReg 1; VStr ("__class__",false); VReg 0];
 		setvar ctx VarObj;
 		(* true if implements mt.Protect *)
-		let flag = is_protected ctx (TInst (c,[])) "" in
+		let flag = is_protected ctx ~stat:true (TInst (c,[])) "" in
 		List.iter (gen_class_static_field ctx c flag) c.cl_ordered_statics;
+		let flag = is_protected ctx (TInst (c,[])) "" in
 		PMap.iter (fun _ f -> if f.cf_get <> ResolveAccess then gen_class_field ctx flag f) c.cl_fields;
 	| TEnumDecl e when e.e_extern ->
 		()
@@ -1408,6 +1411,7 @@ let default_header ctx ver =
 let generate com =
 	let ctx = {
 		com = com;
+		stack = Codegen.stack_init com true;
 		flash6 = com.flash_version = 6;
 		segs = [];
 		opcodes = DynArray.create();
@@ -1438,10 +1442,10 @@ let generate com =
 	protect_all := not (Common.defined com "swf-mark");
 	extern_boot := true;
 	if com.debug then begin
-		push ctx [VStr (Codegen.stack_var,false); VInt 0];
+		push ctx [VStr (ctx.stack.Codegen.stack_var,false); VInt 0];
 		write ctx AInitArray;
 		write ctx ASet;
-		push ctx [VStr (Codegen.exc_stack_var,false); VInt 0];
+		push ctx [VStr (ctx.stack.Codegen.stack_exc_var,false); VInt 0];
 		write ctx AInitArray;
 		write ctx ASet;
 	end;

std/String.hx

@@ -91,4 +91,8 @@ extern class String {
 
 	static function fromCharCode( code : Int ) : String;
 
+	#if !neko
+	private function cca( pos : Int ) : Int;
+	#end
+
 }

std/Type.hx

@@ -546,15 +546,15 @@ class Type {
 			Float = __global__["Number"];
 			#end
 		#elseif flash
-			var g = _global;
-			g.Int = { __name__ : ["Int"] };
-			g.Bool = { __ename__ : ["Bool"] };
-			g.Dynamic = { __name__ : ["Dynamic"] };
-			g.Class = { __name__ : ["Class"] };
+			var g : Dynamic = _global;
+			g["Int"] = { __name__ : ["Int"] };
+			g["Bool"] = { __ename__ : ["Bool"] };
+			g.Dynamic = { __name__ : [__unprotect__("Dynamic")] };
+			g.Class = { __name__ : [__unprotect__("Class")] };
 			g.Enum = {};
-			g.Void = { __ename__ : ["Void"] };
-			g.Float = _global["Number"];
-			g.Float[__unprotect__("__name__")] = ["Float"];
+			g.Void = { __ename__ : [__unprotect__("Void")] };
+			g["Float"] = _global["Number"];
+			g["Float"][__unprotect__("__name__")] = ["Float"];
 			Array.prototype[__unprotect__("__class__")] = Array;
 			Array[__unprotect__("__name__")] = ["Array"];
 			String.prototype[__unprotect__("__class__")] = String;

std/haxe/Unserializer.hx

@@ -35,14 +35,14 @@ class Unserializer {
 	public static var DEFAULT_RESOLVER : TypeResolver = Type;
 
 	static var BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789%:";
+
+	#if !neko
 	static var CODES = null;
 
 	static function initCodes() {
 		var codes =
 			#if flash9
 				new flash.utils.ByteArray();
-			#elseif neko
-				untyped __dollar__amake(BASE64.length);
 			#else
 				new Array();
 			#end
@@ -50,6 +50,7 @@ class Unserializer {
 			codes[untyped BASE64.cca(i)] = i;
 		return codes;
 	}
+	#end
 
  	var buf : String;
  	var pos : Int;

std/haxe/remoting/SocketWrapper.hx

@@ -38,7 +38,9 @@ class SocketWrapper {
 		var ctx = new Context();
 		var cnx = haxe.remoting.ExternalConnection.jsConnect(id,ctx);
 		ctx.addObject("sock",s);
-		ctx.addObject("api",{ close : cnx.close });
+		var o = {};
+		Reflect.setField(o,"close",cnx.close);
+		ctx.addObject("api",o);
 		#if flash9
 		var connected = false;
 		s.addEventListener(flash.events.Event.CONNECT,function(_) {
@@ -73,7 +75,9 @@ class SocketWrapper {
 
 	static function init() {
 		var ctx = new Context();
-		ctx.addObject("api",{ create : create });
+		var o = {};
+		Reflect.setField(o,"create",create);
+		ctx.addObject("api",o);
 		haxe.remoting.ExternalConnection.jsConnect("SocketWrapper",ctx);
 	}
 

tests/unit/RemotingApi.hx

@@ -1,6 +1,6 @@
 package unit;
 
-class RemotingApi {
+class RemotingApi #if swf_mark implements mt.Protect #end {
 
 	var sub : RemotingApi;
 

tests/unit/Test.hx

@@ -1,6 +1,6 @@
 package unit;
 
-class Test {
+class Test #if swf_mark implements mt.Protect #end {
 
 	public function new() {
 	}
@@ -149,12 +149,13 @@ class Test {
 		#end
 		resetTimer();
 		trace("START");
-		#if flash
-		var tf = untyped flash.Boot.getTrace();
-		tf.selectable = true;
 		#if flash9
-			tf.mouseEnabled = true;
-		#end
+		var tf : flash.text.TextField = untyped flash.Boot.getTrace();
+		tf.selectable = true;
+		tf.mouseEnabled = true;
+		#elseif flash
+		var tf : flash.TextField = untyped flash.Boot.getTrace();
+		tf.selectable = true;
 		#end
 		var classes = [
 			new TestReflect(),

tests/unit/TestReflect.hx

@@ -10,11 +10,23 @@ class TestReflect extends Test {
 		Class,Enum,Void,Dynamic,
 	];
 
+	static inline function u( s : String ) : String {
+		#if (flash && !flash9)
+		return untyped __unprotect__(s);
+		#else
+		return s;
+		#end
+	}
+
+	static inline function u2( s : String, s2 ) : String {
+		return u(s)+"."+u(s2);
+	}
+
 	static var TNAMES = [
 		"null","Int","String","Bool","Float",
-		"Array","Hash","List","Date","Xml","Math",
-		"unit.MyEnum","unit.MyClass","unit.MySubClass",
-		"Class","Enum","Void","Dynamic",
+		"Array",u("Hash"),u("List"),"Date","Xml","Math",
+		u2("unit","MyEnum"),u2("unit","MyClass"),u2("unit","MySubClass"),
+		u("Class"),u("Enum"),u("Void"),u("Dynamic"),
 	];
 
 	public function testTypes() {
@@ -23,7 +35,7 @@ class TestReflect extends Test {
 			var name = TNAMES[i];
 			infos("type "+name);
 			f( t == null );
-			if( name == "Enum" ) {
+			if( name == u("Enum") ) {
 				// neither an enum or a class
 			} else if( t == MyEnum || t == Void || t == Bool ) {
 				eq( Type.getEnumName(t), name );

tests/unit/TestRemoting.hx

@@ -77,6 +77,10 @@ class TestRemoting extends Test {
 		async( doConnect, new Socket("haxeFlash9"), true );
 		#end
 
+		#if swf_mark
+		return;
+		#end
+
 		var actx = new haxe.remoting.ContextAll();
 		actx.addObject("fake",{ TestRemoting : TestRemoting },true);
 		eq( actx.call(["unit","TestRemoting","staticMethod"],[2,3]), 5 );