View difference between Paste ID: 4HUED2bT and m6FDiiJU

-("-swf-script-limits",Arg.String (fun sl ->
+(*
  *  Haxe Compiler
-				swf_script_limits := Some (match ExtString.String.nsplit sl ":" with
+ *  Copyright (c)2005-2008 Nicolas Cannasse
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
-		),"<swf script limits> : define SWF script limits (recursion depth:script timeout)");
+ *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  *)
 open Printf
 open Genswf
 open Common
 open Type
 
 type context = {
 	com : Common.context;
 	mutable flush : unit -> unit;
 	mutable setup : unit -> unit;
 	mutable messages : string list;
 	mutable has_next : bool;
 	mutable has_error : bool;
 }
 
 type cache = {
 	mutable c_haxelib : (string list, string list) Hashtbl.t;
 	mutable c_files : (string, float * Ast.package) Hashtbl.t;
 	mutable c_modules : (path * string, module_def) Hashtbl.t;
 }
 
 exception Abort
 exception Completion of string
 
 let version = 211
 
 let measure_times = ref false
 let prompt = ref false
 let start_time = ref (get_time())
 let global_cache = ref None
 
 let executable_path() =
 	Extc.executable_path()
 
 let format msg p =
 	if p = Ast.null_pos then
 		msg
 	else begin
 		let error_printer file line = sprintf "%s:%d:" file line in
 		let epos = Lexer.get_error_pos error_printer p in
 		let msg = String.concat ("\n" ^ epos ^ " : ") (ExtString.String.nsplit msg "\n") in
 		sprintf "%s : %s" epos msg
 	end
 
 let ssend sock str =
 	let rec loop pos len =
 		if len = 0 then
 			()
 		else
 			let s = Unix.send sock str pos len [] in
 			loop (pos + s) (len - s)
 	in
 	loop 0 (String.length str)
 
 let message ctx msg p =
 	ctx.messages <- format msg p :: ctx.messages
 
 let error ctx msg p =
 	message ctx msg p;
 	ctx.has_error <- true
 
 let htmlescape s =
 	let s = String.concat "&amp;" (ExtString.String.nsplit s "&") in
 	let s = String.concat "&lt;" (ExtString.String.nsplit s "<") in
 	let s = String.concat "&gt;" (ExtString.String.nsplit s ">") in
 	s
 
 let reserved_flags = [
 	"cross";"flash8";"js";"neko";"flash";"php";"cpp";"cs";"java";
 	"as3";"swc";"macro";"sys"
 	]
 
 let complete_fields fields =
 	let b = Buffer.create 0 in
 	Buffer.add_string b "<list>\n";
 	List.iter (fun (n,t,d) ->
 		Buffer.add_string b (Printf.sprintf "<i n=\"%s\"><t>%s</t><d>%s</d></i>\n" n (htmlescape t) (htmlescape d))
 	) (List.sort (fun (a,_,_) (b,_,_) -> compare a b) fields);
 	Buffer.add_string b "</list>\n";
 	raise (Completion (Buffer.contents b))
 
 let report_times print =
 	let tot = ref 0. in
 	Hashtbl.iter (fun _ t -> tot := !tot +. t.total) Common.htimers;
 	print (Printf.sprintf "Total time : %.3fs" !tot);
 	if !tot > 0. then begin
 		print "------------------------------------";
 		let timers = List.sort (fun t1 t2 -> compare t1.name t2.name) (Hashtbl.fold (fun _ t acc -> t :: acc) Common.htimers []) in
 		List.iter (fun t -> print (Printf.sprintf "  %s : %.3fs, %.0f%%" t.name t.total (t.total *. 100. /. !tot))) timers
 	end
 
 let make_path f =
 	let f = String.concat "/" (ExtString.String.nsplit f "\\") in
 	let cl = ExtString.String.nsplit f "." in
 	let cl = (match List.rev cl with
 		| ["hx";path] -> ExtString.String.nsplit path "/"
 		| _ -> cl
 	) in
 	let error() = failwith ("Invalid class name " ^ f) in
 	let invalid_char x =
 		for i = 1 to String.length x - 1 do
 			match x.[i] with
 			| 'A'..'Z' | 'a'..'z' | '0'..'9' | '_' -> ()
 			| _ -> error()
 		done;
 		false
 	in
 	let rec loop = function
 		| [] -> error()
 		| [x] -> if String.length x = 0 || not (x.[0] = '_' || (x.[0] >= 'A' && x.[0] <= 'Z')) || invalid_char x then error() else [] , x
 		| x :: l ->
 			if String.length x = 0 || x.[0] < 'a' || x.[0] > 'z' || invalid_char x then error() else
 				let path , name = loop l in
 				x :: path , name
 	in
 	loop cl
 
 let unique l =
 	let rec _unique = function
 		| [] -> []
 		| x1 :: x2 :: l when x1 = x2 -> _unique (x2 :: l)
 		| x :: l -> x :: _unique l
 	in
 	_unique (List.sort compare l)
 
 let rec read_type_path com p =
 	let classes = ref [] in
 	let packages = ref [] in
 	let p = (match p with
 		| x :: l ->
 			(try
 				match PMap.find x com.package_rules with
 				| Directory d -> d :: l
 				| Remap s -> s :: l
 				| _ -> p
 			with
 				Not_found -> p)
 		| _ -> p
 	) in
 	List.iter (fun path ->
 		let dir = path ^ String.concat "/" p in
 		let r = (try Sys.readdir dir with _ -> [||]) in
 		Array.iter (fun f ->
 			if (try (Unix.stat (dir ^ "/" ^ f)).Unix.st_kind = Unix.S_DIR with _ -> false) then begin
 				if f.[0] >= 'a' && f.[0] <= 'z' then begin
 					if p = ["."] then
 						match read_type_path com [f] with
 						| [] , [] -> ()
 						| _ ->
 							try
 								match PMap.find f com.package_rules with
 								| Forbidden -> ()
 								| Remap f -> packages := f :: !packages
 								| Directory _ -> raise Not_found
 							with Not_found ->
 								packages := f :: !packages
 					else
 						packages := f :: !packages
 				end;
 			end else if file_extension f = "hx" then begin
 				let c = Filename.chop_extension f in
 				if String.length c < 2 || String.sub c (String.length c - 2) 2 <> "__" then classes := c :: !classes;
 			end;
 		) r;
 	) com.class_path;
 	List.iter (fun (_,_,extract) ->
 		Hashtbl.iter (fun (path,name) _ ->
 			if path = p then classes := name :: !classes else
 			let rec loop p1 p2 =
 				match p1, p2 with
 				| [], _ -> ()
 				| x :: _, [] -> packages := x :: !packages
 				| a :: p1, b :: p2 -> if a = b then loop p1 p2
 			in
 			loop path p
 		) (extract());
 	) com.swf_libs;
 	unique !packages, unique !classes
 
 let delete_file f = try Sys.remove f with _ -> ()
 
 let expand_env ?(h=None) path  =
 	let r = Str.regexp "%\\([A-Za-z0-9_]+\\)%" in
 	Str.global_substitute r (fun s ->
 		let key = Str.matched_group 1 s in
 		try
 			Sys.getenv key
 		with Not_found -> try
 			match h with
 			| None -> raise Not_found
 			| Some h -> Hashtbl.find h key
 		with Not_found ->
 			"%" ^ key ^ "%"
 	) path
 
 let unquote v =
 	let len = String.length v in
 	if len > 0 && v.[0] = '"' && v.[len - 1] = '"' then String.sub v 1 (len - 2) else v
 
 let parse_hxml_data data =
 	let lines = Str.split (Str.regexp "[\r\n]+") data in
 	List.concat (List.map (fun l ->
 		let l = unquote (ExtString.String.strip l) in
 		if l = "" || l.[0] = '#' then
 			[]
 		else if l.[0] = '-' then
 			try
 				let a, b = ExtString.String.split l " " in
 				[unquote a; unquote (ExtString.String.strip b)]
 			with
 				_ -> [l]
 		else
 			[l]
 	) lines)
 
 let parse_hxml file =
 	let ch = IO.input_channel (try open_in_bin file with _ -> failwith ("File not found " ^ file)) in
 	let data = IO.read_all ch in
 	IO.close_in ch;
 	parse_hxml_data data
 
 let lookup_classes com spath =
 	let rec loop = function
 		| [] -> []
 		| cp :: l ->
 			let cp = (if cp = "" then "./" else cp) in
 			let c = normalize_path (Extc.get_real_path (Common.unique_full_path cp)) in
 			let clen = String.length c in
 			if clen < String.length spath && String.sub spath 0 clen = c then begin
 				let path = String.sub spath clen (String.length spath - clen) in
 				(try
 					let path = make_path path in
 					(match loop l with
 					| [x] when String.length (Ast.s_type_path x) < String.length (Ast.s_type_path path) -> [x]
 					| _ -> [path])
 				with _ -> loop l)
 			end else
 				loop l
 	in
 	loop com.class_path
 
 let add_libs com libs =
 	let call_haxelib() =
 		let t = Common.timer "haxelib" in
 		let cmd = "haxelib path " ^ String.concat " " libs in
 		let pin, pout, perr = Unix.open_process_full cmd (Unix.environment()) in
 		let lines = Std.input_list pin in
 		let err = Std.input_list perr in
 		let ret = Unix.close_process_full (pin,pout,perr) in
 		if ret <> Unix.WEXITED 0 then failwith (match lines, err with
 			| [], [] -> "Failed to call haxelib (command not found ?)"
 			| [], [s] when ExtString.String.ends_with (ExtString.String.strip s) "Module not found : path" -> "The haxelib command has been strip'ed, please install it again"
 			| _ -> String.concat "\n" (lines@err));
 		t();
 		lines
 	in
 	match libs with
 	| [] -> []
 	| _ ->
 		let lines = match !global_cache with
 			| Some cache ->
 				(try
 					(* if we are compiling, really call haxelib since library path might have changed *)
 					if not com.display then raise Not_found;
 					Hashtbl.find cache.c_haxelib libs
 				with Not_found ->
 					let lines = call_haxelib() in
 					Hashtbl.replace cache.c_haxelib libs lines;
 					lines)
 			| _ -> call_haxelib()
 		in
 		let extra_args = ref [] in
 		let lines = List.fold_left (fun acc l ->
 			let l = ExtString.String.strip l in
 			if l = "" then acc else
 			if l.[0] <> '-' then l :: acc else
 			match (try ExtString.String.split l " " with _ -> l, "") with
 			| ("-L",dir) ->
 				com.neko_libs <- String.sub l 3 (String.length l - 3) :: com.neko_libs;
 				acc
 			| param, value ->
 				extra_args := param :: !extra_args;
 				if value <> "" then extra_args := value :: !extra_args;
 				acc
 		) [] lines in
 		com.class_path <- lines @ com.class_path;
 		List.rev !extra_args
 
 let run_command ctx cmd =
 	let h = Hashtbl.create 0 in
 	Hashtbl.add h "__file__" ctx.com.file;
 	Hashtbl.add h "__platform__" (platform_name ctx.com.platform);
 	let t = Common.timer "command" in
 	let cmd = expand_env ~h:(Some h) cmd in
 	let len = String.length cmd in
 	if len > 3 && String.sub cmd 0 3 = "cd " then
 		Sys.chdir (String.sub cmd 3 (len - 3))
 	else
 	let binary_string s =
 		if Sys.os_type <> "Win32" && Sys.os_type <> "Cygwin" then s else String.concat "\n" (Str.split (Str.regexp "\r\n") s)
 	in
 	let pout, pin, perr = Unix.open_process_full cmd (Unix.environment()) in
 	let iout = Unix.descr_of_in_channel pout in
 	let ierr = Unix.descr_of_in_channel perr in
 	let berr = Buffer.create 0 in
 	let bout = Buffer.create 0 in
 	let tmp = String.create 1024 in
 	let result = ref None in
 	(*
 		we need to read available content on process out/err if we want to prevent
 		the process from blocking when the pipe is full
 	*)
 	let is_process_running() =
 		let pid, r = Unix.waitpid [Unix.WNOHANG] (-1) in
 		if pid = 0 then
 			true
 		else begin
 			result := Some r;
 			false;
 		end
 	in
 	let rec loop ins =
 		let (ch,_,_), timeout = (try Unix.select ins [] [] 0.02, true with _ -> ([],[],[]),false) in
 		match ch with
 		| [] ->
 			(* make sure we read all *)
 			if timeout && is_process_running() then
 				loop ins
 			else begin
 				Buffer.add_string berr (IO.read_all (IO.input_channel perr));
 				Buffer.add_string bout (IO.read_all (IO.input_channel pout));
 			end
 		| s :: _ ->
 			let n = Unix.read s tmp 0 (String.length tmp) in
 			Buffer.add_substring (if s == iout then bout else berr) tmp 0 n;
 			loop (if n = 0 then List.filter ((!=) s) ins else ins)
 	in
 	(try loop [iout;ierr] with Unix.Unix_error _ -> ());
 	let serr = binary_string (Buffer.contents berr) in
 	let sout = binary_string (Buffer.contents bout) in
 	if serr <> "" then ctx.messages <- (if serr.[String.length serr - 1] = '\n' then String.sub serr 0 (String.length serr - 1) else serr) :: ctx.messages;
 	if sout <> "" then ctx.com.print sout;
 	(match (try Unix.close_process_full (pout,pin,perr) with Unix.Unix_error (Unix.ECHILD,_,_) -> (match !result with None -> assert false | Some r -> r)) with
 	| Unix.WEXITED e -> if e <> 0 then failwith ("Command failed with error " ^ string_of_int e)
 	| Unix.WSIGNALED s | Unix.WSTOPPED s -> failwith ("Command stopped with signal " ^ string_of_int s));
 	t()
 
 let default_flush ctx =
 	List.iter prerr_endline (List.rev ctx.messages);
 	if ctx.has_error && !prompt then begin
 		print_endline "Press enter to exit...";
 		ignore(read_line());
 	end;
 	if ctx.has_error then exit 1
 
 let create_context params =
 	let ctx = {
 		com = Common.create version params;
 		flush = (fun()->());
 		setup = (fun()->());
 		messages = [];
 		has_next = false;
 		has_error = false;
 	} in
 	ctx.flush <- (fun() -> default_flush ctx);
 	ctx
 
 let rec process_params create pl =
 	let each_params = ref [] in
 	let rec loop acc = function
 		| [] ->
 			let ctx = create (!each_params @ (List.rev acc)) in
 			init ctx;
 			ctx.flush()
 		| "--next" :: l when acc = [] -> (* skip empty --next *)
 			loop [] l
 		| "--next" :: l ->
 			let ctx = create (!each_params @ (List.rev acc)) in
 			ctx.has_next <- true;
 			init ctx;
 			ctx.flush();
 			loop [] l
 		| "--each" :: l ->
 			each_params := List.rev acc;
 			loop [] l
 		| "--cwd" :: dir :: l ->
 			(* we need to change it immediately since it will affect hxml loading *)
 			(try Unix.chdir dir with _ -> ());
 			loop (dir :: "--cwd" :: acc) l
 		| "--connect" :: hp :: l ->
 			(match !global_cache with
 			| None ->
 				let host, port = (try ExtString.String.split hp ":" with _ -> "127.0.0.1", hp) in
 				do_connect host (try int_of_string port with _ -> raise (Arg.Bad "Invalid port")) ((List.rev acc) @ l)
 			| Some _ ->
 				(* already connected : skip *)
 				loop acc l)
 		| arg :: l ->
 			match List.rev (ExtString.String.nsplit arg ".") with
 			| "hxml" :: _ when (match acc with "-cmd" :: _ -> false | _ -> true) -> loop acc (parse_hxml arg @ l)
 			| _ -> loop (arg :: acc) l
 	in
 	(* put --display in front if it was last parameter *)
 	let pl = (match List.rev pl with
 		| file :: "--display" :: pl -> "--display" :: file :: List.rev pl
 		| "use_rtti_doc" :: "-D" :: file :: "--display" :: pl -> "--display" :: file :: List.rev pl
 		| _ -> pl
 	) in
 	loop [] pl
 
 and wait_loop boot_com host port =
 	let sock = Unix.socket Unix.PF_INET Unix.SOCK_STREAM 0 in
 	(try Unix.bind sock (Unix.ADDR_INET (Unix.inet_addr_of_string host,port)) with _ -> failwith ("Couldn't wait on " ^ host ^ ":" ^ string_of_int port));
 	Unix.listen sock 10;
 	Sys.catch_break false;
 	let verbose = boot_com.verbose in
 	let has_parse_error = ref false in
 	if verbose then print_endline ("Waiting on " ^ host ^ ":" ^ string_of_int port);
 	let bufsize = 1024 in
 	let tmp = String.create bufsize in
 	let cache = {
 		c_haxelib = Hashtbl.create 0;
 		c_files = Hashtbl.create 0;
 		c_modules = Hashtbl.create 0;
 	} in
 	global_cache := Some cache;
 	Typeload.parse_hook := (fun com2 file p ->
 		let sign = get_signature com2 in
 		let ffile = Common.unique_full_path file in
 		let ftime = file_time ffile in
 		let fkey = ffile ^ "!" ^ sign in
 		try
 			let time, data = Hashtbl.find cache.c_files fkey in
 			if time <> ftime then raise Not_found;
 			data
 		with Not_found ->
 			has_parse_error := false;
 			let data = Typeload.parse_file com2 file p in
 			if verbose then print_endline ("Parsed " ^ ffile);
 			if not !has_parse_error && ffile <> (!Parser.resume_display).Ast.pfile then Hashtbl.replace cache.c_files fkey (ftime,data);
 			data
 	);
 	let cache_module m =
 		Hashtbl.replace cache.c_modules (m.m_path,m.m_extra.m_sign) m;
 	in
 	let check_module_path com m p =
 		m.m_extra.m_file = Common.unique_full_path (Typeload.resolve_module_file com m.m_path (ref[]) p)
 	in
 	let compilation_step = ref 0 in
 	let compilation_mark = ref 0 in
 	let mark_loop = ref 0 in
 	Typeload.type_module_hook := (fun (ctx:Typecore.typer) mpath p ->
 		let t = Common.timer "module cache check" in
 		let com2 = ctx.Typecore.com in
 		let sign = get_signature com2 in
 		let dep = ref None in
 		incr mark_loop;
 		let mark = !mark_loop in
 		let start_mark = !compilation_mark in
 		let rec check m =
 			if m.m_extra.m_dirty then begin
 				dep := Some m;
 				false
 			end else if m.m_extra.m_mark = mark then
 				true
 			else try
 				if m.m_extra.m_mark <= start_mark then begin
 					(match m.m_extra.m_kind with
 					| MFake -> () (* don't get classpath *)
 					| MCode -> if not (check_module_path com2 m p) then raise Not_found;
 					| MMacro when ctx.Typecore.in_macro -> if not (check_module_path com2 m p) then raise Not_found;
 					| MMacro ->
 						let _, mctx = Typer.get_macro_context ctx p in
 						if not (check_module_path mctx.Typecore.com m p) then raise Not_found;
 					);
 					if file_time m.m_extra.m_file <> m.m_extra.m_time then begin
 						if m.m_extra.m_kind = MFake then Hashtbl.remove Typecore.fake_modules m.m_extra.m_file;
 						raise Not_found;
 					end;
 				end;
 				m.m_extra.m_mark <- mark;
 				PMap.iter (fun _ m2 -> if not (check m2) then begin dep := Some m2; raise Not_found end) m.m_extra.m_deps;
 				true
 			with Not_found ->
 				m.m_extra.m_dirty <- true;
 				false
 		in
 		let rec add_modules m0 m =
 			if m.m_extra.m_added < !compilation_step then begin
 				(match m0.m_extra.m_kind, m.m_extra.m_kind with
 				| MCode, MMacro | MMacro, MCode ->
 					(* this was just a dependency to check : do not add to the context *)
 					()
 				| _ ->
 					if verbose then print_endline ("Reusing  cached module " ^ Ast.s_type_path m.m_path);
 					m.m_extra.m_added <- !compilation_step;
 					List.iter (fun t ->
 						match t with
 						| TClassDecl c -> c.cl_restore()
 						| TEnumDecl e ->
 							let rec loop acc = function
 								| [] -> ()
 								| (":realPath",[Ast.EConst (Ast.String path),_],_) :: l ->
 									e.e_path <- Ast.parse_path path;
 									e.e_meta <- (List.rev acc) @ l;
 								| x :: l -> loop (x::acc) l
 							in
 							loop [] e.e_meta
 						| _ -> ()
 					) m.m_types;
 					Typeload.add_module ctx m p;
 					PMap.iter (Hashtbl.add com2.resources) m.m_extra.m_binded_res;
 					PMap.iter (fun _ m2 -> add_modules m0 m2) m.m_extra.m_deps);
 					List.iter (Typer.call_init_macro ctx) m.m_extra.m_macro_calls
 			end
 		in
 		try
 			let m = Hashtbl.find cache.c_modules (mpath,sign) in
 			if not (check m) then begin
 				if verbose then print_endline ("Skipping cached module " ^ Ast.s_type_path mpath ^ (match !dep with None -> "" | Some m -> "(" ^ Ast.s_type_path m.m_path ^ ")"));
 				raise Not_found;
 			end;
 			add_modules m m;
 			t();
 			Some m
 		with Not_found ->
 			t();
 			None
 	);
 	let run_count = ref 0 in
 	while true do
 		let sin, _ = Unix.accept sock in
 		let t0 = get_time() in
 		Unix.set_nonblock sin;
 		if verbose then print_endline "Client connected";
 		let b = Buffer.create 0 in
 		let rec read_loop() =
 			try
 				let r = Unix.recv sin tmp 0 bufsize [] in
 				if verbose then Printf.printf "Reading %d bytes\n" r;
 				Buffer.add_substring b tmp 0 r;
 				if r > 0 && tmp.[r-1] = '\000' then Buffer.sub b 0 (Buffer.length b - 1) else read_loop();
 			with Unix.Unix_error((Unix.EWOULDBLOCK|Unix.EAGAIN),_,_) ->
 				if verbose then print_endline "Waiting for data...";
 				ignore(Unix.select [] [] [] 0.1);
 				read_loop()
 		in
 		let rec cache_context com =
 			if not com.display then begin
 				List.iter cache_module com.modules;
 				if verbose then print_endline ("Cached " ^ string_of_int (List.length com.modules) ^ " modules");
 			end;
 			match com.get_macros() with
 			| None -> ()
 			| Some com -> cache_context com
 		in
 		let create params =
 			let ctx = create_context params in
 			ctx.flush <- (fun() ->
 				incr compilation_step;
 				compilation_mark := !mark_loop;
 				List.iter (fun s -> ssend sin (s ^ "\n"); if verbose then print_endline ("> " ^ s)) (List.rev ctx.messages);
 				if ctx.has_error then ssend sin "\x02\n" else cache_context ctx.com;
 			);
 			ctx.setup <- (fun() ->
 				Parser.display_error := (fun e p -> has_parse_error := true; ctx.com.error (Parser.error_msg e) p);
 				if ctx.com.display then begin
 					let file = (!Parser.resume_display).Ast.pfile in
 					let fkey = file ^ "!" ^ get_signature ctx.com in
 					(* force parsing again : if the completion point have been changed *)
 					Hashtbl.remove cache.c_files fkey;
 					(* force module reloading (if cached) *)
 					Hashtbl.iter (fun _ m -> if m.m_extra.m_file = file then m.m_extra.m_dirty <- true) cache.c_modules
 				end
 			);
 			ctx.com.print <- (fun str -> ssend sin ("\x01" ^ String.concat "\x01" (ExtString.String.nsplit str "\n") ^ "\n"));
 			ctx
 		in
 		(try
 			let data = parse_hxml_data (read_loop()) in
 			Unix.clear_nonblock sin;
 			if verbose then print_endline ("Processing Arguments [" ^ String.concat "," data ^ "]");
 			(try
 				Common.display_default := false;
 				Parser.resume_display := Ast.null_pos;
 				Typeload.return_partial_type := false;
 				measure_times := false;
 				close_times();
 				stats.s_files_parsed := 0;
 				stats.s_classes_built := 0;
 				stats.s_methods_typed := 0;
 				stats.s_macros_called := 0;
 				Hashtbl.clear Common.htimers;
 				let _ = Common.timer "other" in
 				incr compilation_step;
 				compilation_mark := !mark_loop;
 				start_time := get_time();
 				process_params create data;
 				close_times();
 				if !measure_times then report_times (fun s -> ssend sin (s ^ "\n"))
 			with Completion str ->
 				if verbose then print_endline ("Completion Response =\n" ^ str);
 				ssend sin str
 			);
 			if verbose then begin
 				print_endline (Printf.sprintf "Stats = %d files, %d classes, %d methods, %d macros" !(stats.s_files_parsed) !(stats.s_classes_built) !(stats.s_methods_typed) !(stats.s_macros_called));
 				print_endline (Printf.sprintf "Time spent : %.3fs" (get_time() -. t0));
 			end
 		with Unix.Unix_error _ ->
 			if verbose then print_endline "Connection Aborted");
 		Unix.close sin;
 		(* prevent too much fragmentation by doing some compactions every X run *)
 		incr run_count;
 		if !run_count mod 1 = 50 then begin
 			let t0 = get_time() in
 			Gc.compact();
 			if verbose then begin
 				let stat = Gc.quick_stat() in
 				let size = (float_of_int stat.Gc.heap_words) *. 4. in
 				print_endline (Printf.sprintf "Compacted memory %.3fs %.1fMB" (get_time() -. t0) (size /. (1024. *. 1024.)));
 			end
 		end else Gc.minor();
 	done
 
 and do_connect host port args =
 	let sock = Unix.socket Unix.PF_INET Unix.SOCK_STREAM 0 in
 	(try Unix.connect sock (Unix.ADDR_INET (Unix.inet_addr_of_string host,port)) with _ -> failwith ("Couldn't connect on " ^ host ^ ":" ^ string_of_int port));
 	let args = ("--cwd " ^ Unix.getcwd()) :: args in
 	ssend sock (String.concat "" (List.map (fun a -> a ^ "\n") args) ^ "\000");
 	let buf = Buffer.create 0 in
 	let tmp = String.create 100 in
 	let rec loop() =
 		let b = Unix.recv sock tmp 0 100 [] in
 		Buffer.add_substring buf tmp 0 b;
 		if b > 0 then loop()
 	in
 	loop();
 	let has_error = ref false in
 	let rec print line =
 		match (if line = "" then '\x00' else line.[0]) with
 		| '\x01' ->
 			print_string (String.concat "\n" (List.tl (ExtString.String.nsplit line "\x01")))
 		| '\x02' ->
 			has_error := true;
 		| _ ->
 			prerr_endline line;
 	in
 	let lines = ExtString.String.nsplit (Buffer.contents buf) "\n" in
 	let lines = (match List.rev lines with "" :: l -> List.rev l | _ -> lines) in
 	List.iter print lines;
 	if !has_error then exit 1
 
 and init ctx =
 	let usage = Printf.sprintf
 		"Haxe Compiler %d.%.2d - (c)2005-2012 Haxe Foundation\n Usage : haxe%s -main <class> [-swf|-js|-neko|-php|-cpp|-cs|-java|-as3] <output> [options]\n Options :"
 		(version / 100) (version mod 100) (if Sys.os_type = "Win32" then ".exe" else "")
 	in
 	let com = ctx.com in
 	let classes = ref [([],"Std")] in
 try
 	let xml_out = ref None in
 	let swf_header = ref None in
 	let swf_script_limits = ref None in
 	let cmds = ref [] in
 	let config_macros = ref [] in
 	let cp_libs = ref [] in
 	let gen_as3 = ref false in
 	let no_output = ref false in
 	let did_something = ref false in
 	let force_typing = ref false in
 	let pre_compilation = ref [] in
 	let interp = ref false in
 	if version < 300 then begin
 		for i = 0 to 4 do
 			let v = version - i in
 			Common.raw_define com ("haxe_" ^ string_of_int v);
 		done;
 	end else begin
 		Common.define com Define.Haxe3;
 		Common.define_value com Define.HaxeVer (string_of_float (float_of_int version /. 100.));
 	end;
 	Common.define_value com Define.Dce "std";
 	com.warning <- (fun msg p -> message ctx ("Warning : " ^ msg) p);
 	com.error <- error ctx;
 	Parser.display_error := (fun e p -> com.error (Parser.error_msg e) p);
 	Parser.use_doc := !Common.display_default || (!global_cache <> None);
 	(try
 		let p = Sys.getenv "HAXE_LIBRARY_PATH" in
 		let rec loop = function
 			| drive :: path :: l ->
 				if String.length drive = 1 && ((drive.[0] >= 'a' && drive.[0] <= 'z') || (drive.[0] >= 'A' && drive.[0] <= 'Z')) then
 					(drive ^ ":" ^ path) :: loop l
 				else
 					drive :: loop (path :: l)
 			| l ->
 				l
 		in
 		let parts = "" :: Str.split_delim (Str.regexp "[;:]") p in
 		com.class_path <- List.map normalize_path (loop parts)
 	with
 		Not_found ->
 			if Sys.os_type = "Unix" then
 				com.class_path <- ["/usr/lib/haxe/std/";"/usr/local/lib/haxe/std/";"/usr/lib/haxe/std/libs/";"/usr/local/lib/haxe/std/libs/";"";"/"]
 			else
 				let base_path = normalize_path (Extc.get_real_path (try executable_path() with _ -> "./")) in
 				com.class_path <- [base_path ^ "std/";base_path ^ "std/libs/";""]);
 	com.std_path <- List.filter (fun p -> ExtString.String.ends_with p "std/" || ExtString.String.ends_with p "std\\") com.class_path;
 	let set_platform pf file =
 		if com.platform <> Cross then failwith "Multiple targets";
 		Common.init_platform com pf;
 		com.file <- file;
 		if (pf = Flash8 || pf = Flash) && file_extension file = "swc" then Common.define com Define.Swc;
 	in
 	let define f = Arg.Unit (fun () -> Common.define com f) in
 	let extra_args = ref [] in
 	let basic_args_spec = [
 		("-cp",Arg.String (fun path ->
 			extra_args := !extra_args @ (add_libs com (!cp_libs));
 			cp_libs := [];
 			com.class_path <- normalize_path path :: com.class_path
 		),"<path> : add a directory to find source files");
 		("-js",Arg.String (set_platform Js),"<file> : compile code to JavaScript file");
 		("-swf",Arg.String (set_platform Flash),"<file> : compile code to Flash SWF file");
 		("-as3",Arg.String (fun dir ->
 			set_platform Flash dir;
 			gen_as3 := true;
 			Common.define com Define.As3;
 			Common.define com Define.NoInline;
 		),"<directory> : generate AS3 code into target directory");
 		("-neko",Arg.String (set_platform Neko),"<file> : compile code to Neko Binary");
 		("-php",Arg.String (fun dir ->
 			classes := (["php"],"Boot") :: !classes;
 			set_platform Php dir;
 		),"<directory> : generate PHP code into target directory");
 		("-cpp",Arg.String (fun dir ->
 			set_platform Cpp dir;
 		),"<directory> : generate C++ code into target directory");
 		("-cs",Arg.String (fun dir ->
 			set_platform Cs dir;
 		),"<directory> : generate C# code into target directory");
 		("-java",Arg.String (fun dir ->
 			set_platform Java dir;
 		),"<directory> : generate Java code into target directory");
 		("-xml",Arg.String (fun file ->
 			Parser.use_doc := true;
 			xml_out := Some file
 		),"<file> : generate XML types description");
 		("-main",Arg.String (fun cl ->
 			if com.main_class <> None then raise (Arg.Bad "Multiple -main");
 			let cpath = make_path cl in
 			com.main_class <- Some cpath;
 			classes := cpath :: !classes
 		),"<class> : select startup class");
 		("-lib",Arg.String (fun l ->
 			cp_libs := l :: !cp_libs;
 			Common.raw_define com l;
 		),"<library[:version]> : use a haxelib library");
 		("-D",Arg.String (fun var ->
 			if var = fst (Define.infos Define.UseRttiDoc) then Parser.use_doc := true;
 			if var = fst (Define.infos Define.NoOpt) then com.foptimize <- false;
 			if List.mem var reserved_flags then raise (Arg.Bad (var ^ " is a reserved compiler flag and cannot be defined from command line"));
 			Common.raw_define com var
 		),"<var> : define a conditional compilation flag");
 		("-v",Arg.Unit (fun () ->
 			com.verbose <- true
 		),": turn on verbose mode");
 		("-debug", Arg.Unit (fun() ->
 			Common.define com Define.Debug;
 			com.debug <- true;
 		), ": add debug informations to the compiled code");
 	] in
 	let adv_args_spec = [
 		("-swf-version",Arg.Float (fun v ->
 			com.flash_version <- v;
 		),"<version> : change the SWF version (6 to 10)");
 		("-swf-header",Arg.String (fun h ->
 			try
 				swf_header := Some (match ExtString.String.nsplit h ":" with
 				| [width; height; fps] ->
 					(int_of_string width,int_of_string height,float_of_string fps,0xFFFFFF)
 				| [width; height; fps; color] ->
 					(int_of_string width, int_of_string height, float_of_string fps, int_of_string ("0x" ^ color))
 				| _ -> raise Exit)
 			with
 				_ -> raise (Arg.Bad "Invalid SWF header format")
 		),"<header> : define SWF header (width:height:fps:color)");
 		("-swf-script-limits",Arg.String (fun sl ->
 			try
 				com.swf_script_limits := Some (match ExtString.String.nsplit sl ":" with
 				| [recursion_depth; script_timeout] -> (int_of_string recursion_depth, int_of_string script_timeout)
 				| _ -> raise Exit)
 			with
 				_ -> raise (Arg.Bad "Invalid SWF ScriptLimits format")
 		),"<swf script limits> : define SWF script limits (recursion depth:script timeout)");
 		("-swf-lib",Arg.String (fun file ->
 			Genswf.add_swf_lib com file
 		),"<file> : add the SWF library to the compiled SWF");
 		("-java-lib",Arg.String (fun file ->
 			Genjava.add_java_lib com file
 		),"<file> : add an external JAR or class directory library");
 		("-x", Arg.String (fun file ->
 			let neko_file = file ^ ".n" in
 			set_platform Neko neko_file;
 			if com.main_class = None then begin
 				let cpath = make_path file in
 				com.main_class <- Some cpath;
 				classes := cpath :: !classes
 			end;
 			cmds := ("neko " ^ neko_file) :: !cmds;
 		),"<file> : shortcut for compiling and executing a neko file");
 		("-resource",Arg.String (fun res ->
 			let file, name = (match ExtString.String.nsplit res "@" with
 				| [file; name] -> file, name
 				| [file] -> file, file
 				| _ -> raise (Arg.Bad "Invalid Resource format : should be file@name")
 			) in
 			let file = (try Common.find_file com file with Not_found -> file) in
 			let data = (try
 				let s = Std.input_file ~bin:true file in
 				if String.length s > 12000000 then raise Exit;
 				s;
 			with
 				| Sys_error _ -> failwith ("Resource file not found : " ^ file)
 				| _ -> failwith ("Resource '" ^ file ^ "' excess the maximum size of 12MB")
 			) in
 			if Hashtbl.mem com.resources name then failwith ("Duplicate resource name " ^ name);
 			Hashtbl.add com.resources name data
 		),"<file>[@name] : add a named resource file");
 		("-prompt", Arg.Unit (fun() -> prompt := true),": prompt on error");
 		("-cmd", Arg.String (fun cmd ->
 			cmds := unquote cmd :: !cmds
 		),": run the specified command after successful compilation");
 		("--flash-strict", define Define.FlashStrict, ": more type strict flash API");
 		("--no-traces", define Define.NoTraces, ": don't compile trace calls in the program");
 		("--gen-hx-classes", Arg.Unit (fun() ->
 			force_typing := true;
 			pre_compilation := (fun() ->
 				List.iter (fun (_,_,extract) ->
 					Hashtbl.iter (fun n _ -> classes := n :: !classes) (extract())
 				) com.swf_libs;
 			) :: !pre_compilation;
 			xml_out := Some "hx"
 		),": generate hx headers for all input classes");
 		("--next", Arg.Unit (fun() -> assert false), ": separate several haxe compilations");
 		("--display", Arg.String (fun file_pos ->
 			match file_pos with
 			| "classes" ->
 				pre_compilation := (fun() -> raise (Parser.TypePath (["."],None))) :: !pre_compilation;
 			| "keywords" ->
 				complete_fields (Hashtbl.fold (fun k _ acc -> (k,"","") :: acc) Lexer.keywords [])
 			| _ ->
 				let file, pos = try ExtString.String.split file_pos "@" with _ -> failwith ("Invalid format : " ^ file_pos) in
 				let file = unquote file in
 				let pos = try int_of_string pos with _ -> failwith ("Invalid format : "  ^ pos) in
 				com.display <- true;
 				Common.display_default := true;
 				Common.define com Define.Display;
 				Parser.use_doc := true;
 				Parser.resume_display := {
 					Ast.pfile = Common.unique_full_path file;
 					Ast.pmin = pos;
 					Ast.pmax = pos;
 				};
 		),": display code tips");
 		("--no-output", Arg.Unit (fun() -> no_output := true),": compiles but does not generate any file");
 		("--times", Arg.Unit (fun() -> measure_times := true),": measure compilation times");
 		("--no-inline", define Define.NoInline, ": disable inlining");
 		("--no-opt", Arg.Unit (fun() ->
 			com.foptimize <- false;
 			Common.define com Define.NoOpt;
 		), ": disable code optimizations");
 		("--js-modern", Arg.Unit (fun() ->
 			Common.define com Define.JsModern;
 		), ": wrap JS output in a closure, strict mode, and other upcoming features");
 		("--php-front",Arg.String (fun f ->
 			if com.php_front <> None then raise (Arg.Bad "Multiple --php-front");
 			com.php_front <- Some f;
 		),"<filename> : select the name for the php front file");
 		("--php-lib",Arg.String (fun f ->
  			if com.php_lib <> None then raise (Arg.Bad "Multiple --php-lib");
  			com.php_lib <- Some f;
  		),"<filename> : select the name for the php lib folder");
 		("--php-prefix", Arg.String (fun f ->
 			if com.php_prefix <> None then raise (Arg.Bad "Multiple --php-prefix");
 			com.php_prefix <- Some f;
 			Common.define com Define.PhpPrefix;
 		),"<name> : prefix all classes with given name");
 		("--remap", Arg.String (fun s ->
 			let pack, target = (try ExtString.String.split s ":" with _ -> raise (Arg.Bad "Invalid format")) in
 			com.package_rules <- PMap.add pack (Remap target) com.package_rules;
 		),"<package:target> : remap a package to another one");
 		("--interp", Arg.Unit (fun() ->
 			Common.define com Define.Interp;
 			set_platform Neko "";
 			no_output := true;
 			interp := true;
 		),": interpret the program using internal macro system");
 		("--macro", Arg.String (fun e ->
 			force_typing := true;
 			config_macros := e :: !config_macros
 		)," : call the given macro before typing anything else");
 		("--dce", Arg.String (fun mode ->
 			(match mode with
 			| "std" | "full" | "no" -> ()
 			| _ -> raise (Arg.Bad "Invalid DCE mode"));
 			Common.define_value com Define.Dce mode
 		),"[std|full|no] : set the dead code elimination mode");
 		("--wait", Arg.String (fun hp ->
 			let host, port = (try ExtString.String.split hp ":" with _ -> "127.0.0.1", hp) in
 			wait_loop com host (try int_of_string port with _ -> raise (Arg.Bad "Invalid port"))
 		),"<[host:]port> : wait on the given port for commands to run)");
 		("--connect",Arg.String (fun _ ->
 			assert false
 		),"<[host:]port> : connect on the given port and run commands there)");
 		("--cwd", Arg.String (fun dir ->
 			(try Unix.chdir dir with _ -> raise (Arg.Bad "Invalid directory"))
 		),"<dir> : set current working directory");
 		("--help-defines", Arg.Unit (fun() ->
 			let rec loop i =
 				let d = Obj.magic i in
 				if d <> Define.Last then begin
 					let t, doc = Define.infos d in
 					message ctx (String.concat "-" (ExtString.String.nsplit t "_") ^ " : " ^ doc) Ast.null_pos;
 					loop (i + 1)
 				end
 			in
 			loop 0;
 			did_something := true
 		),": print help for all compiler specific defines");
 		("-swf9",Arg.String (fun file ->
 			set_platform Flash file;
 		),"<file> : [deprecated] compile code to Flash9 SWF file");
 	] in
 	let args_callback cl = classes := make_path cl :: !classes in
 	let process args =
 		let current = ref 0 in
 		Arg.parse_argv ~current (Array.of_list ("" :: List.map expand_env args)) (basic_args_spec @ adv_args_spec) args_callback usage
 	in
 	process ctx.com.args;
 	let rec loop() =
 		extra_args := !extra_args @ add_libs com (!cp_libs);
 		cp_libs := [];
 		match !extra_args with
 		| [] -> ()
 		| l ->
 			extra_args := [];
 			process l;
 			loop()
 	in
 	loop();
 	(try ignore(Common.find_file com "mt/Include.hx"); Common.raw_define com "mt"; with Not_found -> ());
 	if com.display then begin
 		com.warning <- message ctx;
 		com.error <- error ctx;
 		com.main_class <- None;
 		let real = Extc.get_real_path (!Parser.resume_display).Ast.pfile in
 		classes := lookup_classes com real;
 		Common.log com ("Display file : " ^ real);
 		Common.log com ("Classes found : ["  ^ (String.concat "," (List.map Ast.s_type_path !classes)) ^ "]");
 	end;
 	let add_std dir =
 		com.class_path <- List.filter (fun s -> not (List.mem s com.std_path)) com.class_path @ List.map (fun p -> p ^ dir ^ "/_std/") com.std_path @ com.std_path
 	in
 	let ext = (match com.platform with
 		| Cross ->
 			(* no platform selected *)
 			set_platform Cross "";
 			"?"
 		| Flash8 | Flash ->
 			if com.flash_version >= 9. then begin
 				let rec loop = function
 					| [] -> ()
 					| (v,_) :: _ when v > com.flash_version -> ()
 					| (v,def) :: l ->
 						Common.raw_define com ("flash" ^ def);
 						loop l
 				in
 				loop Common.flash_versions;
 				Common.raw_define com "flash";
 				com.defines <- PMap.remove "flash8" com.defines;
 				com.package_rules <- PMap.remove "flash" com.package_rules;
 				add_std "flash";
 			end else begin
 				com.package_rules <- PMap.add "flash" (Directory "flash8") com.package_rules;
 				com.package_rules <- PMap.add "flash8" Forbidden com.package_rules;
 				Common.raw_define com "flash";
 				Common.raw_define com ("flash" ^ string_of_int (int_of_float com.flash_version));
 				com.platform <- Flash8;
 				add_std "flash8";
 			end;
 			"swf"
 		| Neko ->
 			add_std "neko";
 			"n"
 		| Js ->
 			add_std "js";
 			"js"
 		| Php ->
 			add_std "php";
 			"php"
 		| Cpp ->
 			add_std "cpp";
 			"cpp"
 		| Cs ->
 			Gencs.before_generate com;
 			add_std "cs"; "cs"
 		| Java ->
 			Genjava.before_generate com;
 			add_std "java"; "java"
 	) in
 	(* if we are at the last compilation step, allow all packages accesses - in case of macros or opening another project file *)
 	if com.display && not ctx.has_next then com.package_rules <- PMap.foldi (fun p r acc -> match r with Forbidden -> acc | _ -> PMap.add p r acc) com.package_rules PMap.empty;
 	com.config <- get_config com; (* make sure to adapt all flags changes defined after platform *)
 
 	(* check file extension. In case of wrong commandline, we don't want
 		to accidentaly delete a source file. *)
 	if not !no_output && file_extension com.file = ext then delete_file com.file;
 	List.iter (fun f -> f()) (List.rev (!pre_compilation));
 	if !classes = [([],"Std")] && not !force_typing then begin
 		if !cmds = [] && not !did_something then Arg.usage basic_args_spec usage;
 	end else begin
 		ctx.setup();
 		Common.log com ("Classpath : " ^ (String.concat ";" com.class_path));
 		Common.log com ("Defines : " ^ (String.concat ";" (PMap.foldi (fun v _ acc -> v :: acc) com.defines [])));
 		let t = Common.timer "typing" in
 		Typecore.type_expr_ref := (fun ctx e need_val -> Typer.type_expr ~need_val ctx e);
 		let tctx = Typer.create com in
 		List.iter (Typer.call_init_macro tctx) (List.rev !config_macros);
 		List.iter (fun cpath -> ignore(tctx.Typecore.g.Typecore.do_load_module tctx cpath Ast.null_pos)) (List.rev !classes);
 		Typer.finalize tctx;
 		t();
 		if ctx.has_error then raise Abort;
 		if com.display then begin
 			if ctx.has_next then raise Abort;
 			failwith "No completion point was found";
 		end;
 		let t = Common.timer "filters" in
 		let main, types, modules = Typer.generate tctx in
 		com.main <- main;
 		com.types <- types;
 		com.modules <- modules;
 		let filters = [
 			if com.foptimize then Optimizer.reduce_expression tctx else Optimizer.sanitize tctx;
 			Codegen.check_local_vars_init;
 			Codegen.captured_vars com;
 			Codegen.rename_local_vars com;
 		] in
 		List.iter (Codegen.post_process filters) com.types;
 		Codegen.post_process_end();
 		List.iter (fun f -> f()) (List.rev com.filters);
 		List.iter (Codegen.save_class_state tctx) com.types;
 		let dce_mode = (try Common.defined_value com Define.Dce with _ -> "no") in
 		if not (!gen_as3 || dce_mode = "no" || Common.defined com Define.DocGen) then Dce.run com main (dce_mode = "full" && not !interp);
 		let type_filters = [
 			Codegen.check_private_path;
 			Codegen.remove_generic_base;
 			Codegen.apply_native_paths;
 			Codegen.add_rtti;
 			Codegen.remove_extern_fields;
 			Codegen.add_field_inits;
 			Codegen.add_meta_field;
 			Codegen.check_remove_metadata;
 		] in
 		List.iter (fun t -> List.iter (fun f -> f tctx t) type_filters) com.types;
 		if ctx.has_error then raise Abort;
 		(match !xml_out with
 		| None -> ()
 		| Some "hx" ->
 			Genxml.generate_hx com
 		| Some file ->
 			Common.log com ("Generating xml : " ^ file);
 			Genxml.generate com file);
 		if com.platform = Flash || com.platform = Cpp || com.platform = Cs then List.iter (Codegen.fix_overrides com) com.types;
 		if Common.defined com Define.Dump then Codegen.dump_types com;
 		if Common.defined com Define.DumpDependencies then Codegen.dump_dependencies com;
 		t();
 		(match com.platform with
 		| _ when !no_output ->
 			if !interp then begin
 				let ctx = Interp.create com (Typer.make_macro_api tctx Ast.null_pos) in
 				Interp.add_types ctx com.types (fun t -> ());
 				(match com.main with
 				| None -> ()
 				| Some e -> ignore(Interp.eval_expr ctx e));
 			end;
 		| Cross ->
 			()
 		| Flash8 | Flash when !gen_as3 ->
 			Common.log com ("Generating AS3 in : " ^ com.file);
 			Genas3.generate com;
 		| Flash8 | Flash ->
 			Common.log com ("Generating swf : " ^ com.file);
 			Genswf.generate com !swf_header;
 		| Neko ->
 			Common.log com ("Generating neko : " ^ com.file);
 			Genneko.generate com;
 		| Js ->
 			Common.log com ("Generating js : " ^ com.file);
 			Genjs.generate com
 		| Php ->
 			Common.log com ("Generating PHP in : " ^ com.file);
 			Genphp.generate com;
 		| Cpp ->
 			Common.log com ("Generating Cpp in : " ^ com.file);
 			Gencpp.generate com;
 		| Cs ->
 			if com.verbose then print_endline ("Generating C# in : " ^ com.file);
 			Gencs.generate com;
 		| Java ->
 			if com.verbose then print_endline ("Generating Java in : " ^ com.file);
 			Genjava.generate com;
 		);
 	end;
 	Sys.catch_break false;
 	if not !no_output then List.iter (run_command ctx) (List.rev !cmds)
 with
 	| Abort | Typecore.Fatal_error ->
 		()
 	| Common.Abort (m,p) ->
 		error ctx m p
 	| Lexer.Error (m,p) ->
 		error ctx (Lexer.error_msg m) p
 	| Parser.Error (m,p) ->
 		error ctx (Parser.error_msg m) p
 	| Typecore.Forbid_package ((pack,m,p),pl,pf)  ->
 		if !Common.display_default && ctx.has_next then
 			()
 		else begin
 			error ctx (Printf.sprintf "You cannot access the %s package while %s (for %s)" pack (if pf = "macro" then "in a macro" else "targeting " ^ pf) (Ast.s_type_path m) ) p;
 			List.iter (error ctx "    referenced here") (List.rev pl);
 		end
 	| Typecore.Error (m,p) ->
 		error ctx (Typecore.error_msg m) p
 	| Interp.Error (msg,p :: l) ->
 		message ctx msg p;
 		List.iter (message ctx "Called from") l;
 		error ctx "Aborted" Ast.null_pos;
 	| Failure msg | Arg.Bad msg ->
 		error ctx ("Error : " ^ msg) Ast.null_pos
 	| Arg.Help msg ->
 		message ctx msg Ast.null_pos
 	| Typer.DisplayFields fields ->
 		let ctx = print_context() in
 		let fields = List.map (fun (name,t,doc) -> name, s_type ctx t, (match doc with None -> "" | Some d -> d)) fields in
 		let fields = if !measure_times then begin
 			close_times();
 			let tot = ref 0. in
 			Hashtbl.iter (fun _ t -> tot := !tot +. t.total) Common.htimers;
 			let fields = ("@TOTAL", Printf.sprintf "%.3fs" (get_time() -. !start_time), "") :: fields in
 			if !tot > 0. then
 				Hashtbl.fold (fun _ t acc ->
 					("@TIME " ^ t.name, Printf.sprintf "%.3fs (%.0f%%)" t.total (t.total *. 100. /. !tot), "") :: acc
 				) Common.htimers fields
 			else fields
 		end else
 			fields
 		in
 		complete_fields fields
 	| Typer.DisplayTypes tl ->
 		let ctx = print_context() in
 		let b = Buffer.create 0 in
 		List.iter (fun t ->
 			Buffer.add_string b "<type>\n";
 			Buffer.add_string b (htmlescape (s_type ctx t));
 			Buffer.add_string b "\n</type>\n";
 		) tl;
 		raise (Completion (Buffer.contents b))
 	| Parser.TypePath (p,c) ->
 		(match c with
 		| None ->
 			let packs, classes = read_type_path com p in
 			if packs = [] && classes = [] then
 				error ctx ("No classes found in " ^ String.concat "." p) Ast.null_pos
 			else
 				complete_fields (List.map (fun f -> f,"","") (packs @ classes))
 		| Some (c,cur_package) ->
 			try
 				let ctx = Typer.create com in
 				let rec lookup p =
 					try
 						Typeload.load_module ctx (p,c) Ast.null_pos
 					with e ->
 						if cur_package then
 							match List.rev p with
 							| [] -> raise e
 							| _ :: p -> lookup (List.rev p)
 						else
 							raise e
 				in
 				let m = lookup p in
 				complete_fields (List.map (fun t -> snd (t_path t),"","") (List.filter (fun t -> not (t_infos t).mt_private) m.m_types))
 			with Completion c ->
 				raise (Completion c)
 			| _ ->
 				error ctx ("Could not load module " ^ (Ast.s_type_path (p,c))) Ast.null_pos)
 	| e when (try Sys.getenv "OCAMLRUNPARAM" <> "b" || !global_cache <> None with _ -> true) ->
 		error ctx (Printexc.to_string e) Ast.null_pos
 
 ;;
 let other = Common.timer "other" in
 Sys.catch_break true;
 let args = List.tl (Array.to_list Sys.argv) in
 (try
 	let server = Sys.getenv "HAXE_COMPILATION_SERVER" in
 	let host, port = (try ExtString.String.split server ":" with _ -> "127.0.0.1", server) in
 	do_connect host (try int_of_string port with _ -> failwith "Invalid HAXE_COMPILATION_SERVER port") args
 with Not_found -> try
 	process_params create_context args
 with Completion c ->
 	prerr_endline c;
 	exit 0
 );
 other();
 if !measure_times then report_times prerr_endline