tabsify

std/python/Boot.hx

@@ -26,8 +26,8 @@ import builtins as _hx_builtin
 _hx_classes = dict()
 
 class _hx_AnonObject(object):
-    def __init__(self, fields):
-        self.__dict__ = fields
+	def __init__(self, fields):
+		self.__dict__ = fields
 
 _hx_c = _hx_AnonObject({})
 
@@ -49,16 +49,16 @@ import math as _hx_math
 	static function mkSet <T>(a:Array<T>):Set<T> return Syntax.callField(builtin, "set", a);
 
 	static var keywords:Set<String> = mkSet(
-    [
-        "and",       "del",       "from",      "not",       "while",
-        "as",        "elif",      "global",    "or",        "with",
-        "assert",    "else",      "if",        "pass",      "yield",
-        "break",     "except",    "import",    "print",     "float",
-        "class",     "exec",      "in",        "raise",
-        "continue",  "finally",   "is",        "return",
-        "def",       "for",       "lambda",    "try",
-        "None",      "list"
-    ]);
+	[
+		"and",	   "del",	   "from",	  "not",	   "while",
+		"as",		"elif",	  "global",	"or",		"with",
+		"assert",	"else",	  "if",		"pass",	  "yield",
+		"break",	 "except",	"import",	"print",	 "float",
+		"class",	 "exec",	  "in",		"raise",
+		"continue",  "finally",   "is",		"return",
+		"def",	   "for",	   "lambda",	"try",
+		"None",	  "list"
+	]);
 
 	static function arrayJoin <T>(x:Array<T>, sep:String):String {
 		return Syntax.field(sep, "join")(x.map(python.Boot.toString));
@@ -124,25 +124,25 @@ import math as _hx_math
 
 	@:keep static inline function isClass(o:Dynamic) : Bool {
 		return o != null && (o == String || inspectIsClass(o));
-        //return untyped __define_feature__("python.Boot.isClass", o._hx_class);
-    }
+		//return untyped __define_feature__("python.Boot.isClass", o._hx_class);
+	}
 
-    @:keep static function isAnonObject (o:Dynamic) {
-    	return isInstance(o, AnonObject);
-    }
+	@:keep static function isAnonObject (o:Dynamic) {
+		return isInstance(o, AnonObject);
+	}
 
 
-    @:keep private static function _add_dynamic(a:Dynamic,b:Dynamic):Dynamic
-    {
+	@:keep private static function _add_dynamic(a:Dynamic,b:Dynamic):Dynamic
+	{
 		if (isInstance(a, String) || isInstance(b, String)) {
 			return toString1(a,"") + toString1(b,"");
 		}
 		return Syntax.binop(a, "+", b);
-    }
+	}
 
-    @:keep static function toString (o:Dynamic) {
-    	return toString1(o, "");
-    }
+	@:keep static function toString (o:Dynamic) {
+		return toString1(o, "");
+	}
 
 	@:keep private static function toString1(o:Dynamic,s:String):String {
 
@@ -443,20 +443,20 @@ import math as _hx_math
 
 
 	static inline function handleKeywords(name:String):String
-    {
-        if (keywords.has(name)) {
-            return "_hx_" + name;
-        }
-        return name;
-    }
-
-    static function unhandleKeywords(name:String):String
-    {
-    	if (name.substr(0,4) == "_hx_") {
-    		var real = name.substr(4);
-    		if (keywords.has(real)) return real;
-    	}
-    	return name;
-    }
+	{
+		if (keywords.has(name)) {
+			return "_hx_" + name;
+		}
+		return name;
+	}
+
+	static function unhandleKeywords(name:String):String
+	{
+		if (name.substr(0,4) == "_hx_") {
+			var real = name.substr(4);
+			if (keywords.has(real)) return real;
+		}
+		return name;
+	}
 
 }

std/python/Syntax.hx

@@ -12,100 +12,100 @@ using haxe.macro.Tools;
 
 extern class Syntax {
 
-    #if macro
-    static var self = macro python.Syntax;
-    #end
+	#if macro
+	static var self = macro python.Syntax;
+	#end
 
 	@:noUsing macro public static function importModule (module:String):haxe.macro.Expr {
 		return macro ($self.untypedPython($v{"import " + module}):Void);
 	}
 
 	@:noUsing macro public static function importAs (module:String, className : String):haxe.macro.Expr
-    {
-        var n = className.split(".").join("_");
-        var e = "import " + module + " as " + n;
-        var e1 = "_hx_c."+n+" = "+n;
-
-	    return macro ({
-            $self.untypedPython($v{e});
-            $self.untypedPython($v{e1});
-        }:Void);
-    }
-
-    @:noUsing
+	{
+		var n = className.split(".").join("_");
+		var e = "import " + module + " as " + n;
+		var e1 = "_hx_c."+n+" = "+n;
+
+		return macro ({
+			$self.untypedPython($v{e});
+			$self.untypedPython($v{e1});
+		}:Void);
+	}
+
+	@:noUsing
 	macro public static function newInstance (c:Expr, params:Array<Expr>):haxe.macro.Expr {
-        return macro $self._newInstance($c, $a{params});
-    }
+		return macro $self._newInstance($c, $a{params});
+	}
 
 	static function _newInstance(c:Dynamic, args:Array<Dynamic>):Dynamic { return null; }
 
-    @:noUsing
+	@:noUsing
 	public static function isIn(a:Dynamic, b:Dynamic):Bool { return false; }
 
-    @:noUsing
+	@:noUsing
 	public static function delete(a:Dynamic):Void { }
 
-    @:noUsing
+	@:noUsing
 	public static function binop(a:Dynamic, op:String, b:Dynamic):Dynamic { return null; }
 
-    @:noUsing
+	@:noUsing
 	public static function assign(a:Dynamic, b:Dynamic):Void { }
 
-    @:noUsing
-    public static function untypedPython<T>(b:String):T { return null; };
+	@:noUsing
+	public static function untypedPython<T>(b:String):T { return null; };
 
-    @:noUsing
+	@:noUsing
 	macro public static function arrayAccess(x:Expr, rest:Array<Expr>):ExprOf<Dynamic> {
 		return macro $self._arrayAccess($x, $a{rest});
-    }
+	}
 
 	static function _arrayAccess(a:Dynamic, args:Array<Dynamic>):Dynamic { return null; }
 
 	static function arraySet(a:Dynamic, i:Dynamic, v:Dynamic):Dynamic { return null; }
 
-    @:noUsing macro public static function arrayAccessWithLeadingColon<T>(x:Expr, rest:Array<Expr>):haxe.macro.ExprOf<Dynamic>
-    {
-        return macro ((untyped __python_array_access_leading_colon__)($a{[x].concat(rest)}):Dynamic);
-    }
-
-    @:noUsing macro public static function pyFor <T>(v:Expr, it:Expr, b:Expr):haxe.macro.Expr
-    {
-        var id = switch (v.expr) {
-            case EConst(CIdent(x)):x;
-            case _ : Context.error("unexpected " + ExprTools.toString(v) + ": const ident expected", v.pos);
-        }
-
-        var res = macro @:pos(it.pos) {
-            var $id = $it.getNativeIterator().__next__();
-            $it;
-            $b;
-        }
-        return macro ((untyped __python_for__)($res):Void);
-    }
-
-    @:noUsing macro public static function importFromAs (from:String, module:String, className : String):haxe.macro.Expr {
-
-        var n = className.split(".").join("_");
-
-        var e = "from " + from + " import " + module + " as " + n;
-        var e1 = "_hx_c."+n+" = " + n;
-	    return macro ({
-            $self.untypedPython($v{e});
-            $self.untypedPython($v{e1});
-        }:Void);
-    }
-
-    @:noUsing
+	@:noUsing macro public static function arrayAccessWithLeadingColon<T>(x:Expr, rest:Array<Expr>):haxe.macro.ExprOf<Dynamic>
+	{
+		return macro ((untyped __python_array_access_leading_colon__)($a{[x].concat(rest)}):Dynamic);
+	}
+
+	@:noUsing macro public static function pyFor <T>(v:Expr, it:Expr, b:Expr):haxe.macro.Expr
+	{
+		var id = switch (v.expr) {
+			case EConst(CIdent(x)):x;
+			case _ : Context.error("unexpected " + ExprTools.toString(v) + ": const ident expected", v.pos);
+		}
+
+		var res = macro @:pos(it.pos) {
+			var $id = $it.getNativeIterator().__next__();
+			$it;
+			$b;
+		}
+		return macro ((untyped __python_for__)($res):Void);
+	}
+
+	@:noUsing macro public static function importFromAs (from:String, module:String, className : String):haxe.macro.Expr {
+
+		var n = className.split(".").join("_");
+
+		var e = "from " + from + " import " + module + " as " + n;
+		var e1 = "_hx_c."+n+" = " + n;
+		return macro ({
+			$self.untypedPython($v{e});
+			$self.untypedPython($v{e1});
+		}:Void);
+	}
+
+	@:noUsing
 	macro public static function callField(o:Expr, field:ExprOf<String>, params:Array<Expr>):haxe.macro.Expr {
-        var e = macro $self.call($self.field($o, $field), $a{params});
+		var e = macro $self.call($self.field($o, $field), $a{params});
 		e = macro untyped $e; // check "Dynamic should be Void" cases
 		return e;
-    }
+	}
 
 	static function call(e:Dynamic, args:Array<Dynamic>):Dynamic { return null; }
 
-    @:noUsing
-    public static function field (o:Dynamic, field:String):Dynamic { return null; }
+	@:noUsing
+	public static function field (o:Dynamic, field:String):Dynamic { return null; }
 
 	@:noUsing
 	macro public static function tuple(args:Array<Expr>):Dynamic {
@@ -118,35 +118,35 @@ extern class Syntax {
 	@:noUsing
 	public static function varArgs(args:Array<Dynamic>):Dynamic { return null; }
 
-    @:noUsing
-    #if !macro macro #end
-    public static function callNamed (e:Expr, args:Expr):haxe.macro.Expr {
-
-        var fArgs = switch (Context.typeof(e)) {
-            case TFun(args, ret): args;
-            case _ : haxe.macro.Context.error("e must be of type function", e.pos);
-        }
-
-        switch (args.expr) {
-            case EObjectDecl(fields):
-                for (f in fields) {
-                    var found = false;
-                    for (a in fArgs) {
-                        found = a.name == f.field;
-                        if (found) break;
-                    }
-                    if (!found) {
-                        haxe.macro.Context.error("field " + f.field + " is not a valid argument (valid names " + [for (a in fArgs) a.name].join(",") + ")", args.pos);
-                    }
-                }
-                // TODO check at least if fields are valid (maybe if types match);
-            case _ : haxe.macro.Context.error("args must be an ObjectDeclaration like { name : 1 }", args.pos);
-        }
-        return macro @:pos(e.pos) ((untyped __named__)($e, $args):Dynamic);
-    }
-
-    macro public static function callNamedUntyped (e:Expr, args:Expr):haxe.macro.Expr
-    {
-        return macro @:pos(e.pos) ((untyped __named__)($e, $args):Dynamic);
-    }
+	@:noUsing
+	#if !macro macro #end
+	public static function callNamed (e:Expr, args:Expr):haxe.macro.Expr {
+
+		var fArgs = switch (Context.typeof(e)) {
+			case TFun(args, ret): args;
+			case _ : haxe.macro.Context.error("e must be of type function", e.pos);
+		}
+
+		switch (args.expr) {
+			case EObjectDecl(fields):
+				for (f in fields) {
+					var found = false;
+					for (a in fArgs) {
+						found = a.name == f.field;
+						if (found) break;
+					}
+					if (!found) {
+						haxe.macro.Context.error("field " + f.field + " is not a valid argument (valid names " + [for (a in fArgs) a.name].join(",") + ")", args.pos);
+					}
+				}
+				// TODO check at least if fields are valid (maybe if types match);
+			case _ : haxe.macro.Context.error("args must be an ObjectDeclaration like { name : 1 }", args.pos);
+		}
+		return macro @:pos(e.pos) ((untyped __named__)($e, $args):Dynamic);
+	}
+
+	macro public static function callNamedUntyped (e:Expr, args:Expr):haxe.macro.Expr
+	{
+		return macro @:pos(e.pos) ((untyped __named__)($e, $args):Dynamic);
+	}
 }

std/python/_std/Reflect.hx

@@ -35,12 +35,12 @@ class Reflect {
 
 
 	static inline function handleKeywords(name:String):String {
-        return python.Boot.handleKeywords(name);
-    }
+		return python.Boot.handleKeywords(name);
+	}
 
-    static function unhandleKeywords(name:String):String {
-    	return python.Boot.unhandleKeywords(name);
-    }
+	static function unhandleKeywords(name:String):String {
+		return python.Boot.unhandleKeywords(name);
+	}
 
 	public static function hasField( o : Dynamic, field : String ) : Bool
 	{

std/python/_std/Std.hx

@@ -29,190 +29,190 @@ import python.Boot;
 @:keepInit
 @:coreApi /*extern*/ class Std {
 
-    public static inline function instance<T:{}, S:T>( value : T, c : Class<S> ) : S {
-        try {
-            return Builtin.isinstance(value,c) ? cast value : null;
-        } catch (e:Dynamic) {
-            return null;
-        }
-
-
-    }
-    public static function is( v : Dynamic, t : Dynamic ) : Bool {
-
-        if (v == null && t == null) {
-            return false;
-        }
-        if (t == null) {
-
-            return false;
-        }
-        if (t == (untyped __python__("Dynamic"))) {
-            return true;
-        }
-        var isBool = Builtin.isinstance(v, (untyped __python__("bool")));
-
-        if (t == (untyped __python__("Bool")) && isBool) {
-            return true;
-        }
-        if (!isBool && t != (untyped __python__("Bool")) && t ==  (untyped __python__("Int")) && Builtin.isinstance(v, (untyped __python__("int")) )) {
-            return true;
-        }
-        var vIsFloat = Builtin.isinstance(v, (untyped __python__("float")));
-
-        if (!isBool && vIsFloat && t == (untyped __python__("Int")) && Math.isFinite(v) && v == Std.int(v)) {
-            return true;
-        }
-
-        if (!isBool &&  t == (untyped __python__("Float")) && ( Builtin.isinstance(v, (untyped __python__("(float,int)"))))) {
-            return true;
-        }
-
-        if ( t == (untyped __python__("str"))) {
-            return Builtin.isinstance(v, String);
-        }
-        if (t == Enum && Inspect.isclass(v) && Builtin.hasattr(v, "_hx_constructs")) return true;
-
-        if (t == Enum) return false;
-
-        if (t == Date && Builtin.isinstance(v, Date)) return true;
-
-        if (t == Date) return false;
-
-        if (Builtin.isinstance(v, Date)) return false;
-
-        if (t == Class && !Builtin.isinstance(v, untyped Enum) && Inspect.isclass(v) && Builtin.hasattr(v, "_hx_class_name") && !Builtin.hasattr(v, "_hx_constructs")) return true;
-
-        if (t == Class) return false; // && !Builtin.isinstance(v, untyped Enum) && Builtin.hasattr(v, "__class__") && untyped Builtin.hasattr(v.__class__, "_hx_class_name") && !untyped Builtin.hasattr(v.__class__, "_hx_constructs")) return true;
-
-        if (try Builtin.isinstance(v, t) catch (e:Dynamic) false) {
-            return true;
-        }
-        if (Inspect.isclass(t)) {
-
-            function loop (intf)
-            {
-                var f:Array<Dynamic> = if (Builtin.hasattr(intf,"_hx_interfaces")) Builtin.getattr(intf, "_hx_interfaces") else [];
-                if (f != null) {
-                    for (i in f) {
-                        if ( i == t) {
-                            return true;
-                        } else {
-                            var l = loop(i);
-                            if (l) {
-                                return true;
-                            }
-                        }
-                    }
-                    return false;
-                } else {
-                    return false;
-                }
-            }
-            return loop(untyped v.__class__);
-
-
-        } else {
-            return false;
-        }
-    }
-
-    @:access(python.Boot)
-    @:keep
-    public static function string( s : Dynamic ) : String
-    {
-        return python.Boot.toString(s);
-    }
-
-    public static inline function int( x : Float ) : Int
-    {
-        try {
-            return (untyped __python__("int"))(x);
-        } catch (e:Dynamic) {
-            return null;
-        }
-    }
-
-    public static function parseInt( x : String ) : Null<Int> {
-        if (x == null) return null;
-        try {
-            return (untyped __python__("int"))(x);
-        } catch (e:Dynamic) {
-            try {
-                var prefix = x.substr(0,2).toLowerCase();
-
-                if (prefix == "0x") {
-                    return (untyped __python__("int"))(x,16);
-                }
-                throw "fail";
-            } catch (e:Dynamic) {
-
-
-                var r = int(parseFloat(x));
-
-                if (r == null) {
-                    var r1 = shortenPossibleNumber(x);
-                    if (r1 != x) {
-                        return parseInt(r1);
-                    } else {
-                        return null;
-                    }
-                }
-                return r;
-            }
-        }
-    }
-
-    static function shortenPossibleNumber (x:String):String
-    {
-        var r = "";
-        for (i in 0...x.length) {
-            var c = x.charAt(i);
-            switch (c.charCodeAt(0)) {
-                case "0".code
-                | "1".code
-                | "2".code
-                | "3".code
-                | "4".code
-                | "5".code
-                | "6".code
-                | "7".code
-                | "8".code
-                | "9".code
-                | ".".code : r += c;
-                case _ : break;
-            }
-        }
-        return r;
-    }
-
-    public static function parseFloat( x : String ) : Float
-    {
-        try {
-            return untyped __python__("float")(x);
-        } catch (e:Dynamic) {
-
-            if (x != null) {
-                var r1 = shortenPossibleNumber(x);
-                if (r1 != x) {
-                    return parseFloat(r1);
-                }
-            }
-            return Math.NaN;
-
-        }
-
-    }
-
-
-    public static inline function random( x : Int ) : Int {
-        if (x <= 0) {
-            return 0;
-        } else {
-            return int(Math.random()*x);
-        }
-
-        //return dart.Lib.random(x);
-//        return untyped __cascade__(new dartt.math.Random(), nextInt(x));// //untyped x <= 0 ? 0 : Math.floor(Math.random()*x);        import 'dart:marth'; new Random()..nextInt(x);
-    }
+	public static inline function instance<T:{}, S:T>( value : T, c : Class<S> ) : S {
+		try {
+			return Builtin.isinstance(value,c) ? cast value : null;
+		} catch (e:Dynamic) {
+			return null;
+		}
+
+
+	}
+	public static function is( v : Dynamic, t : Dynamic ) : Bool {
+
+		if (v == null && t == null) {
+			return false;
+		}
+		if (t == null) {
+
+			return false;
+		}
+		if (t == (untyped __python__("Dynamic"))) {
+			return true;
+		}
+		var isBool = Builtin.isinstance(v, (untyped __python__("bool")));
+
+		if (t == (untyped __python__("Bool")) && isBool) {
+			return true;
+		}
+		if (!isBool && t != (untyped __python__("Bool")) && t ==  (untyped __python__("Int")) && Builtin.isinstance(v, (untyped __python__("int")) )) {
+			return true;
+		}
+		var vIsFloat = Builtin.isinstance(v, (untyped __python__("float")));
+
+		if (!isBool && vIsFloat && t == (untyped __python__("Int")) && Math.isFinite(v) && v == Std.int(v)) {
+			return true;
+		}
+
+		if (!isBool &&  t == (untyped __python__("Float")) && ( Builtin.isinstance(v, (untyped __python__("(float,int)"))))) {
+			return true;
+		}
+
+		if ( t == (untyped __python__("str"))) {
+			return Builtin.isinstance(v, String);
+		}
+		if (t == Enum && Inspect.isclass(v) && Builtin.hasattr(v, "_hx_constructs")) return true;
+
+		if (t == Enum) return false;
+
+		if (t == Date && Builtin.isinstance(v, Date)) return true;
+
+		if (t == Date) return false;
+
+		if (Builtin.isinstance(v, Date)) return false;
+
+		if (t == Class && !Builtin.isinstance(v, untyped Enum) && Inspect.isclass(v) && Builtin.hasattr(v, "_hx_class_name") && !Builtin.hasattr(v, "_hx_constructs")) return true;
+
+		if (t == Class) return false; // && !Builtin.isinstance(v, untyped Enum) && Builtin.hasattr(v, "__class__") && untyped Builtin.hasattr(v.__class__, "_hx_class_name") && !untyped Builtin.hasattr(v.__class__, "_hx_constructs")) return true;
+
+		if (try Builtin.isinstance(v, t) catch (e:Dynamic) false) {
+			return true;
+		}
+		if (Inspect.isclass(t)) {
+
+			function loop (intf)
+			{
+				var f:Array<Dynamic> = if (Builtin.hasattr(intf,"_hx_interfaces")) Builtin.getattr(intf, "_hx_interfaces") else [];
+				if (f != null) {
+					for (i in f) {
+						if ( i == t) {
+							return true;
+						} else {
+							var l = loop(i);
+							if (l) {
+								return true;
+							}
+						}
+					}
+					return false;
+				} else {
+					return false;
+				}
+			}
+			return loop(untyped v.__class__);
+
+
+		} else {
+			return false;
+		}
+	}
+
+	@:access(python.Boot)
+	@:keep
+	public static function string( s : Dynamic ) : String
+	{
+		return python.Boot.toString(s);
+	}
+
+	public static inline function int( x : Float ) : Int
+	{
+		try {
+			return (untyped __python__("int"))(x);
+		} catch (e:Dynamic) {
+			return null;
+		}
+	}
+
+	public static function parseInt( x : String ) : Null<Int> {
+		if (x == null) return null;
+		try {
+			return (untyped __python__("int"))(x);
+		} catch (e:Dynamic) {
+			try {
+				var prefix = x.substr(0,2).toLowerCase();
+
+				if (prefix == "0x") {
+					return (untyped __python__("int"))(x,16);
+				}
+				throw "fail";
+			} catch (e:Dynamic) {
+
+
+				var r = int(parseFloat(x));
+
+				if (r == null) {
+					var r1 = shortenPossibleNumber(x);
+					if (r1 != x) {
+						return parseInt(r1);
+					} else {
+						return null;
+					}
+				}
+				return r;
+			}
+		}
+	}
+
+	static function shortenPossibleNumber (x:String):String
+	{
+		var r = "";
+		for (i in 0...x.length) {
+			var c = x.charAt(i);
+			switch (c.charCodeAt(0)) {
+				case "0".code
+				| "1".code
+				| "2".code
+				| "3".code
+				| "4".code
+				| "5".code
+				| "6".code
+				| "7".code
+				| "8".code
+				| "9".code
+				| ".".code : r += c;
+				case _ : break;
+			}
+		}
+		return r;
+	}
+
+	public static function parseFloat( x : String ) : Float
+	{
+		try {
+			return untyped __python__("float")(x);
+		} catch (e:Dynamic) {
+
+			if (x != null) {
+				var r1 = shortenPossibleNumber(x);
+				if (r1 != x) {
+					return parseFloat(r1);
+				}
+			}
+			return Math.NaN;
+
+		}
+
+	}
+
+
+	public static inline function random( x : Int ) : Int {
+		if (x <= 0) {
+			return 0;
+		} else {
+			return int(Math.random()*x);
+		}
+
+		//return dart.Lib.random(x);
+//		return untyped __cascade__(new dartt.math.Random(), nextInt(x));// //untyped x <= 0 ? 0 : Math.floor(Math.random()*x);		import 'dart:marth'; new Random()..nextInt(x);
+	}
 }

std/python/_std/StringBuf.hx

@@ -25,10 +25,10 @@ import python.lib.io.StringIO;
 /**
 	A String buffer is an efficient way to build a big string by appending small
 	elements together.
-	
+
 	Its cross-platform implementation uses String concatenation internally, but
 	StringBuf may be optimized for different targets.
-	
+
 	Unlike String, an instance of StringBuf is not immutable in the sense that
 	it can be passed as argument to functions which modify it by appending more
 	values. However, the internal buffer cannot be modified.
@@ -39,72 +39,72 @@ class StringBuf {
 
 	/**
 		Creates a new StringBuf instance.
-		
+
 		This may involve initialization of the internal buffer.
 	**/
 
 	private var b : StringIO;
 
-    public function new():Void {
-    	this.b = new StringIO();
-    }
+	public function new():Void {
+		this.b = new StringIO();
+	}
 
-    public var length(get, never):Int;
+	public var length(get, never):Int;
 
-    public inline function get_length ():Int {
-    	// TODO improve implementation
-    	return toString().length;
-    }
+	public inline function get_length ():Int {
+		// TODO improve implementation
+		return toString().length;
+	}
 
 	/**
 		Appends the representation of [x] to [this] StringBuf.
-		
+
 		The exact representation of [x] may vary per platform. To get more
 		consistent behavior, this function should be called with
 		Std.string(x).
-		
+
 		If [x] is null, the String "null" is appended.
 	**/
-    public inline function add<T>( x : T ) : Void {
-        add1(Std.string(x));
-    }
+	public inline function add<T>( x : T ) : Void {
+		add1(Std.string(x));
+	}
 
-    inline function add1(s:String):Void {
-    	untyped b.write(s);
-    }
+	inline function add1(s:String):Void {
+		untyped b.write(s);
+	}
 
 /**
 		Appends the character identified by [c] to [this] StringBuf.
-		
+
 		If [c] is negative or has another invalid value, the result is
 		unspecified.
 	**/
-    public inline function addChar( c : Int ) : Void {
-        add1(String.fromCharCode(c));
-    }
+	public inline function addChar( c : Int ) : Void {
+		add1(String.fromCharCode(c));
+	}
 
 /**
 		Appends a substring of [s] to [this] StringBuf.
-		
+
 		This function expects [pos] and [len] to describe a valid substring of
 		[s], or else the result is unspecified. To get more robust behavior,
 		[this].add(s.substr(pos,len)) can be used instead.
-		
+
 		If [s] or [pos] are null, the result is unspecified.
-		
+
 		If [len] is omitted or null, the substring ranges from [pos] to the end
 		of [s].
 	**/
-    public inline function addSub( s : String, pos : Int, ?len : Int) : Void {
-        add1((len == null ? s.substr(pos) : s.substr(pos, len)));
-    }
+	public inline function addSub( s : String, pos : Int, ?len : Int) : Void {
+		add1((len == null ? s.substr(pos) : s.substr(pos, len)));
+	}
 
 /**
 		Returns the content of [this] StringBuf as String.
-		
+
 		The buffer is not emptied by this operation.
 	**/
-    public inline function toString() : String {
-    	return untyped b.getvalue();
-    }
+	public inline function toString() : String {
+		return untyped b.getvalue();
+	}
 }

std/python/_std/Type.hx

@@ -107,10 +107,10 @@ enum ValueType {
 		if (name == "Math") return Math;
 		if (name == "String") return String;
 		var cl : Class<Dynamic> = (untyped _hx_classes : python.lib.Types.Dict<String, Class<Dynamic>>).get(name, null);
-        // ensure that this is a class
-        if( cl == null || !python.Boot.isClass(cl) )
-                return null;
-        return cl;
+		// ensure that this is a class
+		if( cl == null || !python.Boot.isClass(cl) )
+				return null;
+		return cl;
 	}
 
 	public static function resolveEnum( name : String ) : Enum<Dynamic> {
@@ -275,17 +275,17 @@ enum ValueType {
 	}
 
 	public static function allEnums<T>( e : Enum<T> ) : Array<T>
-    {
-            var ctors = getEnumConstructs(e);
-            var ret = [];
-            for (ctor in ctors)
-            {
-                    var v = Reflect.field(e, ctor);
-                    if (Std.is(v, e))
-                            ret.push(v);
-            }
-
-            return ret;
-    }
+	{
+			var ctors = getEnumConstructs(e);
+			var ret = [];
+			for (ctor in ctors)
+			{
+					var v = Reflect.field(e, ctor);
+					if (Std.is(v, e))
+							ret.push(v);
+			}
+
+			return ret;
+	}
 
 }

std/python/_std/sys/FileSystem.hx

@@ -34,17 +34,17 @@ class FileSystem {
 	public static function stat( path : String ) : sys.FileStat {
 		var s = Os.stat(path);
 		return {
-	        gid : s.st_gid,
-	        uid : s.st_uid,
-	        atime : Date.fromTime(s.st_atime),
-	        mtime : Date.fromTime(s.st_mtime),
-	        ctime : Date.fromTime(s.st_ctime),
-	        size : s.st_size,
-	        dev : s.st_dev,
-	        ino : s.st_ino,
-	        nlink : s.st_nlink,
-	        rdev : s.st_rdev,
-	        mode : s.st_mode
+			gid : s.st_gid,
+			uid : s.st_uid,
+			atime : Date.fromTime(s.st_atime),
+			mtime : Date.fromTime(s.st_mtime),
+			ctime : Date.fromTime(s.st_ctime),
+			size : s.st_size,
+			dev : s.st_dev,
+			ino : s.st_ino,
+			nlink : s.st_nlink,
+			rdev : s.st_rdev,
+			mode : s.st_mode
 		}
 	}
 

std/python/internal/AnonObject.hx

@@ -4,6 +4,4 @@ package python.internal;
 @:native("_hx_AnonObject")
 extern class AnonObject {
 
-
-
 }

std/python/internal/KeywordHandler.hx

@@ -8,32 +8,32 @@ class KeywordHandler {
 
 
 	static var keywords:Set<String> = new Set(
-    [
-        "and",       "del",       "from",      "not",       "while",
-        "as",        "elif",      "global",    "or",        "with",
-        "assert",    "else",      "if",        "pass",      "yield",
-        "break",     "except",    "import",    "print",     "float",
-        "class",     "exec",      "in",        "raise",
-        "continue",  "finally",   "is",        "return",
-        "def",       "for",       "lambda",    "try",
-        "None",      "list"
-    ]);
+	[
+		"and",	   "del",	   "from",	  "not",	   "while",
+		"as",		"elif",	  "global",	"or",		"with",
+		"assert",	"else",	  "if",		"pass",	  "yield",
+		"break",	 "except",	"import",	"print",	 "float",
+		"class",	 "exec",	  "in",		"raise",
+		"continue",  "finally",   "is",		"return",
+		"def",	   "for",	   "lambda",	"try",
+		"None",	  "list"
+	]);
 
 	public static inline function handleKeywords(name:String)
-    {
-        if (keywords.has(name)) {
-            return "_hx_" + name;
-        }
-        return name;
-    }
-
-    public static function unhandleKeywords(name:String)
-    {
-    	if (name.substr(0,4) == "_hx_") {
-    		var real = name.substr(4);
-    		if (keywords.has(real)) return real;
-    	}
-    	return name;
-    }
+	{
+		if (keywords.has(name)) {
+			return "_hx_" + name;
+		}
+		return name;
+	}
+
+	public static function unhandleKeywords(name:String)
+	{
+		if (name.substr(0,4) == "_hx_") {
+			var real = name.substr(4);
+			if (keywords.has(real)) return real;
+		}
+		return name;
+	}
 
 }

std/python/lib/Re.hx

@@ -138,25 +138,25 @@ extern class Re
 
 	public static function search (pattern:Pattern, string:String, flags:Int = 0):Null<MatchObject>;
 
-	public static function split(pattern:Pattern, string:String, 	   maxsplit:Int=0, flags:Int=0):Array<String>;
+	public static function split(pattern:Pattern, string:String, maxsplit:Int=0, flags:Int=0):Array<String>;
 
-	public static inline function findallDynamic(pattern:Pattern, string:String,    flags:Int=0):Array<Dynamic>
+	public static inline function findallDynamic(pattern:Pattern, string:String, flags:Int=0):Array<Dynamic>
 	{
 		return python.Syntax.field(pattern, "findall")(string, flags);
 	}
 
 
-	public static inline function findallString(pattern:Pattern, string:String,    flags:Int=0):Array<String>
+	public static inline function findallString(pattern:Pattern, string:String,	flags:Int=0):Array<String>
 	{
 		return python.Syntax.field(pattern, "findall")(string, flags);
 	}
 
-	public static inline function findallTuple(pattern:Pattern, string:String,    flags:Int=0):Array<Tuple<String>>
+	public static inline function findallTuple(pattern:Pattern, string:String, flags:Int=0):Array<Tuple<String>>
 	{
 		return python.Syntax.field(pattern, "findall")(string, flags);
 	}
 
-	public static inline function findallArray(pattern:Pattern, string:String,    flags:Int=0):Array<Array<String>>
+	public static inline function findallArray(pattern:Pattern, string:String, flags:Int=0):Array<Array<String>>
 	{
 		return findallTuple(pattern, string,flags).map(function (t) return t.toArray());
 	}