flash9 core api classes

genswf9.ml

@@ -211,6 +211,8 @@ let rec type_id ctx t =
 		type_path ctx path
 	| TEnum ({ e_path = ("flash" :: _,name); e_extern = true },_) ->
 		HMPath ([],if is_int_enum name then "int" else "String")
+	| TEnum ({ e_path = [],"XmlType"; e_extern = true },_) ->
+		HMPath ([],"String")
 	| _ ->
 		HMPath ([],"Object")
 

std/flash9/_std/EReg.hx

@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2005, The haXe Project Contributors
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   - Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   - Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE HAXE PROJECT CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE HAXE PROJECT CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+
+@:core_api class EReg {
+
+	var r : Dynamic;
+	var result : {> Array<String>, index : Int, input : String };
+
+	public function new( r : String, opt : String ) : Void {
+		this.r = untyped __new__(__global__["RegExp"],r,opt);
+	}
+
+	public function match( s : String ) : Bool {
+		result = untyped r.exec(s);
+		return (result != null);
+	}
+
+	public function matched( n : Int ) : String {
+		return untyped if( result != null && n >= 0 && n < result.length ) result[n] else throw "EReg::matched";
+	}
+
+	public function matchedLeft() : String {
+		if( result == null ) throw "No string matched";
+		var s = result.input;
+		return s.substr(0,result.index);
+	}
+
+	public function matchedRight() : String {
+		if( result == null ) throw "No string matched";
+		var rl = result.index + result[0].length;
+		var s = result.input;
+		return s.substr(rl,s.length - rl);
+	}
+
+	public function matchedPos() : { pos : Int, len : Int } {
+		if( result == null ) throw "No string matched";
+		return { pos : result.index, len : result[0].length };
+	}
+
+	public function split( s : String ) : Array<String> {
+		// we can't use directly s.split because it's ignoring the 'g' flag
+		var d = "#__delim__#";
+		return untyped s.replace(r,d).split(d);
+	}
+
+	public function replace( s : String, by : String ) : String {
+		return untyped s.replace(r,by);
+	}
+
+	public function customReplace( s : String, f : EReg -> String ) : String {
+		var buf = new StringBuf();
+		while( true ) {
+			if( !match(s) )
+				break;
+			buf.add(matchedLeft());
+			buf.add(f(this));
+			s = matchedRight();
+		}
+		buf.add(s);
+		return buf.toString();
+	}
+
+}

std/flash9/_std/Hash.hx

@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2005, The haXe Project Contributors
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   - Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   - Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE HAXE PROJECT CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE HAXE PROJECT CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+
+@:core_api class Hash<T> {
+
+	private var h :flash.utils.Dictionary;
+
+	public function new() : Void {
+		h = new flash.utils.Dictionary();
+	}
+
+	public function set( key : String, value : T ) : Void {
+		untyped h["$"+key] = value;
+	}
+
+	public function get( key : String ) : Null<T> {
+		return untyped h["$"+key];
+	}
+
+	public function exists( key : String ) : Bool {
+		return untyped h.hasOwnProperty("$"+key);
+	}
+
+	public function remove( key : String ) : Bool {
+		key = "$"+key;
+		if( untyped !h.hasOwnProperty(key) ) return false;
+		untyped __delete__(h,key);
+		return true;
+	}
+
+	public function keys() : Iterator<String> {
+		return untyped (__hkeys__(h)).iterator();
+	}
+
+	public function iterator() : Iterator<T> {
+		return untyped {
+			ref : h,
+			it : __keys__(h).iterator(),
+			hasNext : function() { return this.it.hasNext(); },
+			next : function() { var i : Dynamic = this.it.next(); return this.ref[i]; }
+		};
+	}
+
+	public function toString() : String {
+		var s = new StringBuf();
+		s.add("{");
+		var it = keys();
+		for( i in it ) {
+			s.add(i);
+			s.add(" => ");
+			s.add(Std.string(get(i)));
+			if( it.hasNext() )
+				s.add(", ");
+		}
+		s.add("}");
+		return s.toString();
+	}
+
+}

std/flash9/_std/IntHash.hx

@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2005, The haXe Project Contributors
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   - Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   - Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE HAXE PROJECT CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE HAXE PROJECT CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+
+@:core_api class IntHash<T> {
+
+	private var h : flash.utils.Dictionary;
+
+	public function new() : Void {
+		h = new flash.utils.Dictionary();
+	}
+
+	public function set( key : Int, value : T ) : Void {
+		untyped h[key] = value;
+	}
+
+	public function get( key : Int ) : Null<T> {
+		return untyped h[key];
+	}
+
+	public function exists( key : Int ) : Bool {
+		return untyped h.hasOwnProperty(key);
+	}
+
+	public function remove( key : Int ) : Bool {
+		if( untyped !h.hasOwnProperty(key) ) return false;
+		untyped __delete__(h,key);
+		return true;
+	}
+
+	public function keys() : Iterator<Int> {
+		return untyped (__keys__(h)).iterator();
+	}
+
+	public function iterator() : Iterator<T> {
+		return untyped {
+			ref : h,
+			it : keys(),
+			hasNext : function() { return this.it.hasNext(); },
+			next : function() { var i = this.it.next(); return this.ref[i]; }
+		};
+	}
+
+	public function toString() : String {
+		var s = new StringBuf();
+		s.add("{");
+		var it = keys();
+		for( i in it ) {
+			s.add(i);
+			s.add(" => ");
+			s.add(Std.string(get(i)));
+			if( it.hasNext() )
+				s.add(", ");
+		}
+		s.add("}");
+		return s.toString();
+	}
+
+}

std/flash9/_std/Reflect.hx

@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 2005, The haXe Project Contributors
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   - Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   - Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE HAXE PROJECT CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE HAXE PROJECT CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+
+@:core_api class Reflect {
+
+	public static function hasField( o : Dynamic, field : String ) : Bool untyped {
+		return o.hasOwnProperty( field );
+	}
+
+	public inline static function field( o : Dynamic, field : String ) : Dynamic untyped {
+		return (o == null) ? null : o[field];
+	}
+
+	public inline static function setField( o : Dynamic, field : String, value : Dynamic ) : Void untyped {
+		o[field] = value;
+	}
+
+	public inline static function callMethod( o : Dynamic, func : Dynamic, args : Array<Dynamic> ) : Dynamic untyped {
+		return func.apply(o,args);
+	}
+
+	public static function fields( o : Dynamic ) : Array<String> untyped {
+		if( o == null ) return new Array();
+		var a : Array<String> = __keys__(o);
+		var i = 0;
+		while( i < a.length ){
+			if( !o.hasOwnProperty(a[i]) )
+				a.splice(i,1);
+			else
+				++i;
+		}
+		return a;
+	}
+
+	public static function isFunction( f : Dynamic ) : Bool untyped {
+		return __typeof__(f) == "function";
+	}
+
+	public static function compare<T>( a : T, b : T ) : Int {
+		var a : Dynamic = a;
+		var b : Dynamic = b;
+		return ( a == b ) ? 0 : ((a > b) ? 1 : -1);
+	}
+
+	public static function compareMethods( f1 : Dynamic, f2 : Dynamic ) : Bool {
+		return f1 == f2; // VM-level closures
+	}
+
+	public static function isObject( v : Dynamic ) : Bool untyped {
+		if( v == null )
+			return false;
+		var t = __typeof__(v);
+		if( t == "object" ) {
+			try {
+				if( v.__enum__ == true )
+					return false;
+			} catch( e : Dynamic ) {
+			}
+			return true;
+		}
+		return (t == "string");
+	}
+
+	public static function deleteField( o : Dynamic, f : String ) : Bool untyped {
+		if( o.hasOwnProperty(f) != true ) return false;
+		__delete__(o,f);
+		return true;
+	}
+
+	public static function copy<T>( o : T ) : T {
+		var o2 : Dynamic = {};
+		for( f in Reflect.fields(o) )
+			Reflect.setField(o2,f,Reflect.field(o,f));
+		return o2;
+	}
+
+	public static function makeVarArgs( f : Array<Dynamic> -> Dynamic ) : Dynamic {
+		return function(__arguments__) { return f(__arguments__); };
+	}
+
+}

std/flash9/_std/Std.hx

@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2005, The haXe Project Contributors
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   - Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   - Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE HAXE PROJECT CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE HAXE PROJECT CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+
+@:core_api class Std {
+
+	public static function is( v : Dynamic, t : Dynamic ) : Bool {
+		return untyped flash.Boot.__instanceof(v,t);
+	}
+
+	public static function string( s : Dynamic ) : String {
+		return untyped flash.Boot.__string_rec(s,"");
+	}
+
+	public inline static function int( x : Float ) : Int {
+		return untyped __int__(x);
+	}
+
+	public static function parseInt( x : String ) : Null<Int> untyped {
+		var v = __global__["parseInt"](x);
+		if( __global__["isNaN"](v) )
+			return null;
+		return v;
+	}
+
+	public static function parseFloat( x : String ) : Float {
+		return untyped __global__["parseFloat"](x);
+	}
+
+	public static function random( x : Int ) : Int {
+		return untyped Math.floor(Math.random()*x);
+	}
+
+}

std/flash9/_std/Type.hx

@@ -0,0 +1,274 @@
+/*
+ * Copyright (c) 2005, The haXe Project Contributors
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   - Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   - Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE HAXE PROJECT CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE HAXE PROJECT CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+
+enum ValueType {
+	TNull;
+	TInt;
+	TFloat;
+	TBool;
+	TObject;
+	TFunction;
+	TClass( c : Class<Dynamic> );
+	TEnum( e : Enum<Dynamic> );
+	TUnknown;
+}
+
+@:core_api class Type {
+
+	public static function getClass<T>( o : T ) : Class<T> untyped {
+		var cname = __global__["flash.utils.getQualifiedClassName"](o);
+		if( cname == "null" || cname == "Object" || cname == "int" || cname == "Number" || cname == "Boolean" )
+			return null;
+		if( o.hasOwnProperty("prototype") )
+			return null;
+		var c = __as__(__global__["flash.utils.getDefinitionByName"](cname),Class);
+		if( c.__isenum )
+			return null;
+		return c;
+	}
+
+	public static function getEnum( o : Dynamic ) : Enum<Dynamic> untyped {
+		var cname = __global__["flash.utils.getQualifiedClassName"](o);
+		if( cname == "null" || cname.substr(0,8) == "builtin." )
+			return null;
+		// getEnum(Enum) should be null
+		if( o.hasOwnProperty("prototype") )
+			return null;
+		var c = __as__(__global__["flash.utils.getDefinitionByName"](cname),Class);
+		if( !c.__isenum )
+			return null;
+		return c;
+	}
+
+
+	public static function getSuperClass( c : Class<Dynamic> ) : Class<Dynamic> untyped {
+		var cname = __global__["flash.utils.getQualifiedSuperclassName"](c);
+		if( cname == "Object" )
+			return null;
+		return __as__(__global__["flash.utils.getDefinitionByName"](cname),Class);
+	}
+
+	public static function getClassName( c : Class<Dynamic> ) : String {
+		if( c == null )
+			return null;
+		var str : String = untyped __global__["flash.utils.getQualifiedClassName"](c);
+		switch( str ) {
+		case "int": return "Int";
+		case "Number": return "Float";
+		case "Boolean": return "Bool";
+		default:
+		}
+		return str.split("::").join(".");
+	}
+
+	public static function getEnumName( e : Enum<Dynamic> ) : String {
+		return getClassName(cast e);
+	}
+
+	public static function resolveClass( name : String ) : Class<Dynamic> untyped {
+		var cl : Class<Dynamic>;
+		try {
+			cl = __as__(__global__["flash.utils.getDefinitionByName"](name),Class);
+			if( cl.__isenum )
+				return null;
+			return cl; // skip test below
+		} catch( e : Dynamic ) {
+			switch( name ) {
+			case "Int": return Int;
+			case "Float": return Float;
+			}
+			return null;
+		}
+		// ensure that this is a class
+		if( cl == null || cl.__name__ == null )
+			return null;
+		return cl;
+	}
+
+
+	public static function resolveEnum( name : String ) : Enum<Dynamic> untyped {
+		var e : Dynamic;
+		try {
+			e = __global__["flash.utils.getDefinitionByName"](name);
+			if( !e.__isenum )
+				return null;
+			return e;
+		} catch( e : Dynamic ) {
+			if( name == "Bool" ) return Bool;
+			return null;
+		}
+		// ensure that this is an enum
+		if( e == null || e.__ename__ == null )
+			return null;
+		return e;
+	}
+
+	public static function createInstance<T>( cl : Class<T>, args : Array<Dynamic> ) : T untyped {
+		return switch( args.length ) {
+		case 0: __new__(cl);
+		case 1: __new__(cl,args[0]);
+		case 2: __new__(cl,args[0],args[1]);
+		case 3: __new__(cl,args[0],args[1],args[2]);
+		case 4: __new__(cl,args[0],args[1],args[2],args[3]);
+		case 5: __new__(cl,args[0],args[1],args[2],args[3],args[4]);
+		case 6: __new__(cl,args[0],args[1],args[2],args[3],args[4],args[5]);
+		case 7: __new__(cl,args[0],args[1],args[2],args[3],args[4],args[5],args[6]);
+		case 8: __new__(cl,args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7]);
+		case 9: __new__(cl,args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8]);
+		case 10: __new__(cl,args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9]);
+		case 11: __new__(cl,args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10]);
+		case 12: __new__(cl,args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11]);
+		case 13: __new__(cl,args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12]);
+		case 14: __new__(cl,args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12],args[13]);
+		default: throw "Too many arguments";
+		}
+	}
+
+	public static function createEmptyInstance<T>( cl : Class<T> ) : T untyped {
+		try {
+			flash.Boot.skip_constructor = true;
+			var i = __new__(cl);
+			flash.Boot.skip_constructor = false;
+			return i;
+		} catch( e : Dynamic ) {
+			flash.Boot.skip_constructor = false;
+			throw e;
+		}
+		return null;
+	}
+
+	public static function createEnum<T>( e : Enum<T>, constr : String, ?params : Array<Dynamic> ) : T {
+		var f = Reflect.field(e,constr);
+		if( f == null ) throw "No such constructor "+constr;
+		if( Reflect.isFunction(f) ) {
+			if( params == null ) throw "Constructor "+constr+" need parameters";
+			return Reflect.callMethod(e,f,params);
+		}
+		if( params != null && params.length != 0 )
+			throw "Constructor "+constr+" does not need parameters";
+		return f;
+	}
+
+	public static function createEnumIndex<T>( e : Enum<T>, index : Int, ?params : Array<Dynamic> ) : T {
+		var c = Type.getEnumConstructs(e)[index];
+		if( c == null ) throw index+" is not a valid enum constructor index";
+		return createEnum(e,c,params);
+	}
+
+	static function describe( t : Dynamic, fact : Bool ) : Array<String> untyped {
+		var fields = new Array();
+		var xml : flash.xml.XML = __global__["flash.utils.describeType"](t);
+		if( fact )
+			xml = xml.factory[0];
+		var methods = xml.child("method");
+		for( i in 0...methods.length() )
+			fields.push( Std.string(methods[i].attribute("name")) );
+		var vars = xml.child("variable");
+		for( i in 0...vars.length() )
+			fields.push( Std.string(vars[i].attribute("name")) );
+		var accs = xml.child("accessor");
+		for( i in 0...accs.length() )
+			fields.push( Std.string(accs[i].attribute("name")) );
+		return fields;
+	}
+
+	public static function getInstanceFields( c : Class<Dynamic> ) : Array<String> {
+		return describe(c,true);
+	}
+
+	public static function getClassFields( c : Class<Dynamic> ) : Array<String> {
+		var a = describe(c,false);
+		a.remove("__construct__");
+		a.remove("prototype");
+		return a;
+	}
+
+	public static function getEnumConstructs( e : Enum<Dynamic> ) : Array<String> untyped {
+		return untyped e.__constructs__;
+	}
+
+	public static function typeof( v : Dynamic ) : ValueType untyped {
+		var cname = __global__["flash.utils.getQualifiedClassName"](v);
+		switch(cname) {
+		case "null": return TNull;
+		case "void": return TNull; // undefined
+		case "int": return TInt;
+		case "Number":
+			// integers >28 bits are stored as Numbers in avm2
+			if( (v < -0x10000000 || v >= 0x10000000) && Std.int(v) == v )
+				return TInt;
+			return TFloat;
+		case "Boolean": return TBool;
+		case "Object": return TObject;
+		case "Function": return TFunction;
+		default:
+			var c : Dynamic = null;
+			try {
+				c = __global__["flash.utils.getDefinitionByName"](cname);
+				if( v.hasOwnProperty("prototype") )
+					return TObject;
+				if( c.__isenum )
+					return TEnum(c);
+				return TClass(c);
+			} catch( e : Dynamic ) {
+				if( cname == "builtin.as$0::MethodClosure" || cname.indexOf("-") != -1 )
+					return TFunction;
+				return if( c == null ) TFunction else TClass(c);
+			}
+		}
+		return null;
+	}
+
+	public static function enumEq<T>( a : T, b : T ) : Bool untyped {
+		if( a == b )
+			return true;
+		try {
+			if( a.index != b.index )
+				return false;
+			var ap : Array<Dynamic> = a.params;
+			var bp : Array<Dynamic> = b.params;
+			for( i in 0...ap.length )
+				if( !enumEq(ap[i],bp[i]) )
+					return false;
+		} catch( e : Dynamic ) {
+			return false;
+		}
+		return true;
+	}
+
+	public static function enumConstructor( e : Dynamic ) : String {
+		return e.tag;
+	}
+
+	public static function enumParameters( e : Dynamic ) : Array<Dynamic> {
+		return if( e.params == null ) [] else e.params;
+	}
+
+	public inline static function enumIndex( e : Dynamic ) : Int {
+		return e.index;
+	}
+
+}
+

std/flash9/FlashXml__.hx → std/flash9/_std/Xml.hx

@@ -22,31 +22,32 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
  * DAMAGE.
  */
-package flash;
 
-import Xml;
 import flash.xml.XML;
 import flash.xml.XMLList;
 
-class FlashXml__ {
+enum XmlType {
+}
+
+@:core_api class Xml {
 
-	public static var Element : String;
-	public static var PCData : String;
-	public static var CData : String;
-	public static var Comment : String;
-	public static var DocType : String;
-	public static var Prolog : String;
-	public static var Document : String;
+	public static var Element(default,null) : XmlType;
+	public static var PCData(default,null) : XmlType;
+	public static var CData(default,null) : XmlType;
+	public static var Comment(default,null) : XmlType;
+	public static var DocType(default,null) : XmlType;
+	public static var Prolog(default,null) : XmlType;
+	public static var Document(default,null) : XmlType;
 
 	public var nodeType(default,null) : XmlType;
 	public var nodeName(getNodeName,setNodeName) : String;
 	public var nodeValue(getNodeValue,setNodeValue) : String;
-	public var parent(getParent,null) : FlashXml__;
+	public var parent(getParent,null) : Xml;
 
-	public static var _map : flash.utils.Dictionary;
+	static var _map : flash.utils.Dictionary;
 	var _node : flash.xml.XML;
 
-	public static function parse( str : String ) : FlashXml__ {
+	public static function parse( str : String ) : Xml {
 		XML.ignoreWhitespace = false;
 		XML.ignoreProcessingInstructions = false;
 		XML.ignoreComments = false;
@@ -54,36 +55,36 @@ class FlashXml__ {
 		return wrap( root, Xml.Document );
 	}
 
-	private function new() {}
+	private function new() : Void {}
 
-	public static function createElement( name : String ) : FlashXml__ {
+	public static function createElement( name : String ) : Xml {
 		return wrap( new flash.xml.XML("<"+name+"/>"), Xml.Element );
 	}
 
-	public static function createPCData( data : String ) : FlashXml__ {
+	public static function createPCData( data : String ) : Xml {
 		XML.ignoreWhitespace = false;
 		return wrap( new flash.xml.XML(data), Xml.PCData );
 	}
 
-	public static function createCData( data : String ) : FlashXml__ {
+	public static function createCData( data : String ) : Xml {
 		return wrap( new flash.xml.XML("<![CDATA[ "+data+" ]]>"), Xml.CData );
 	}
 
-	public static function createComment( data : String ) : FlashXml__ {
+	public static function createComment( data : String ) : Xml {
 		XML.ignoreComments = false;
 		return wrap( new flash.xml.XML("<!-- "+data+" -->"), Xml.Comment );
 	}
 
-	public static function createDocType( data : String ) : FlashXml__ {
+	public static function createDocType( data : String ) : Xml {
 		return wrap( new flash.xml.XML("<!DOCTYPE "+data+">"), Xml.DocType );
 	}
 
-	public static function createProlog( data : String ) : FlashXml__ {
+	public static function createProlog( data : String ) : Xml {
 		XML.ignoreProcessingInstructions = false;
 		return wrap( new flash.xml.XML("<?"+data+"?>"), Xml.Prolog );
 	}
 
-	public static function createDocument() : FlashXml__ {
+	public static function createDocument() : Xml {
 		return wrap( new flash.xml.XML("<__document/>"), Xml.Document );
 	}
 
@@ -138,11 +139,11 @@ class FlashXml__ {
 		return v;
 	}
 
-	private function getParent() :FlashXml__ {
+	private function getParent() :Xml {
 		return wrap( _node.parent() );
 	}
 
-	private static function wrap( node : XML, ?type : XmlType ) : FlashXml__ {
+	private static function wrap( node : XML, ?type : XmlType ) : Xml {
 		var map : Dynamic = _map;
 		if( map == null ) {
 			map = new flash.utils.Dictionary(true);
@@ -150,7 +151,7 @@ class FlashXml__ {
 		}
 		var x = untyped map[node];
 		if( x == null ) {
-			x = new FlashXml__();
+			x = new Xml();
 			x._node = node;
 			x.nodeType = (type != null) ? type : getNodeType( node );
 			untyped map[node] = x;
@@ -158,14 +159,14 @@ class FlashXml__ {
 		return x;
 	}
 
-	private function wraps( xList : XMLList ) : Array<FlashXml__> {
-		var out = new Array<FlashXml__>();
+	private function wraps( xList : XMLList ) : Array<Xml> {
+		var out = new Array<Xml>();
 		for( i in 0...xList.length() )
 			out.push( wrap(xList[i]) );
 		return out;
 	}
 
-	function getAttribNS( ns : Array<String> ) {
+	function getAttribNS( ns : Array<String> ) : XMLList {
 		return _node.attribute(new flash.utils.QName(_node.namespace(ns[0]).uri,ns[1]));
 	}
 
@@ -229,11 +230,11 @@ class FlashXml__ {
 		}
 	}
 
-	public function iterator() {
+	public function iterator() : Iterator<Xml> {
 		var children:XMLList = _node.children();
 		if( children == null )
 			throw "bad nodetype";
-		var wrappers :Array<FlashXml__> = wraps(children);
+		var wrappers :Array<Xml> = wraps(children);
 		var cur = 0;
 		return {
 			hasNext : function(){
@@ -245,11 +246,11 @@ class FlashXml__ {
 		};
 	}
 
-	public function elements() {
+	public function elements() : Iterator<Xml> {
 		var elements:XMLList = _node.elements();
 		if( elements == null )
 			throw "bad nodetype";
-		var wrappers :Array<FlashXml__> = wraps(elements);
+		var wrappers :Array<Xml> = wraps(elements);
 		var cur = 0;
 		return {
 			hasNext : function(){
@@ -261,7 +262,7 @@ class FlashXml__ {
 		};
 	}
 
-	public function elementsNamed( name : String ) {
+	public function elementsNamed( name : String ) : Iterator<Xml> {
 		var ns = name.split(":");
 		var elements:XMLList;
 		if( ns.length == 1 )
@@ -270,7 +271,7 @@ class FlashXml__ {
 			elements = _node.elements();
 		if( elements == null )
 			throw "bad nodetype";
-		var wrappers :Array<FlashXml__> = wraps(elements);
+		var wrappers :Array<Xml> = wraps(elements);
 		if( ns.length != 1 )
 			for( w in wrappers.copy() )
 				if( w._node.localName() != ns[1] || w._node.namespace().prefix != ns[0] )
@@ -286,7 +287,7 @@ class FlashXml__ {
 		};
 	}
 
-	public function firstChild() : FlashXml__ {
+	public function firstChild() : Xml {
 		var children:XMLList = _node.children();
 		if( children == null )
 			throw "bad nodetype";
@@ -295,7 +296,7 @@ class FlashXml__ {
 		return wrap( children[0] );
 	}
 
-	public function firstElement() : FlashXml__ {
+	public function firstElement() : Xml {
 		var elements:XMLList = _node.elements();
 		if( elements == null )
 			throw "bad nodetype";
@@ -304,14 +305,14 @@ class FlashXml__ {
 		return wrap( elements[0] );
 	}
 
-	public function addChild( x : FlashXml__ ) : Void {
+	public function addChild( x : Xml ) : Void {
 		var children:XMLList = _node.children();
 		if( children == null )
 			throw "bad nodetype";
 		_node.appendChild(x._node);
 	}
 
-	public function removeChild( x : FlashXml__ ) : Bool {
+	public function removeChild( x : Xml ) : Bool {
 		var children:XMLList = _node.children();
 		if( children == null )
 			throw "bad nodetype";
@@ -322,7 +323,7 @@ class FlashXml__ {
 		return true;
 	}
 
-	public function insertChild( x : FlashXml__, pos : Int ) : Void {
+	public function insertChild( x : Xml, pos : Int ) : Void {
 		var children:XMLList = _node.children();
 		if( children == null )
 			throw "bad nodetype";
@@ -332,7 +333,7 @@ class FlashXml__ {
 			_node.appendChild(x._node);
 	}
 
-	public function toString() {
+	public function toString() : String {
 		XML.prettyPrinting = false;
 		if( nodeType == Xml.Document ) {
 			var str = "";
@@ -344,4 +345,15 @@ class FlashXml__ {
 		return _node.toXMLString();
 	}
 
+	static function __init__() : Void untyped {
+		Element = "element";
+		PCData = "pcdata";
+		CData = "cdata";
+		Comment = "comment";
+		DocType = "doctype";
+		Prolog = "prolog";
+		Document = "document";
+	}
+
+
 }

std/haxe/ImportAll.hx

@@ -120,7 +120,6 @@ import haxe.unit.TestStatus;
 // generated by haxe
 import flash.Boot;
 import flash.Lib;
-import flash.FlashXml__;
 import flash.accessibility.Accessibility;
 import flash.accessibility.AccessibilityImplementation;
 import flash.accessibility.AccessibilityProperties;