create as3 interface from source

As3ToHaxe.hx

package;

import haxe.ds.IntMap;
import sys.db.Object;
import sys.FileSystem;
import neko.Lib;
//import neko.Sys;

using StringTools;
using As3ToHaxe;
import haxe.ds.ObjectMap;
//import Task;
//import User;

/**
 * Simple Program which iterates -from folder, finds .mtt templates and compiles them to the -to folder
 */
class As3ToHaxe
{
    public static var keys = ["-from", "-to", "-remove", "-useSpaces"];
	public var ext:String = "as";
    
    var to:String;
    var from:String; 
    var useSpaces:String;
    var remove:String;
    var sysargs:Array<String>;
    
    var items:Array<String>;
    
    public static var basePackage:String = "away3d";
    
    private var nameSpaces:Map<String,Ns>;
    private var maxLoop:Int;
    
    static function main() 
    {
		
		

		  
	
	  
	  
	
	
      new As3ToHaxe();
    }
    
    public function new()
    {
        maxLoop = 1000;
        
        if (parseArgs())
        {
        trace("start1");
            // make sure that the to directory exists
            if (!FileSystem.exists(to)) FileSystem.createDirectory(to);
            
            // delete old files
            if (remove == "true")
                removeDirectory(to);
            
            items = [];
            // fill items
			 trace("start1"+from);
            recurse(from);
trace("start2"+items);
            // to remember namespaces
            nameSpaces = new Map();
            
            for (item in items)
            {
                // make sure we only work wtih AS fiels
                var ext = getExt(item);
				trace("extens:"+ext);
                switch(ext)
                {
					
                    case ext: 
                        doConversion(item);
                }
            }
            
            // build namespace files
            buildNameSpaces();
        }
    }
    
    private function doConversion(file:String):Void
    {        
        var fromFile = file;
		var fileName:String = file.substr(from.length + 1, file.lastIndexOf(".") - (from.length));
		var firstLetter:String = fileName.substr(0, 1);
		firstLetter = firstLetter.toUpperCase();
		fileName = firstLetter + fileName.substring(1);
        var toFile = to + "/" + fileName+ "hx";
        
        var rF = "";
        var rC = "";
        
        var b = 0;
        
        /* -----------------------------------------------------------*/
        // create the folder if it doesn''t exist
        var dir = toFile.substr(0, toFile.lastIndexOf("/"));
        createFolder(dir);
        
        var s = sys.io.File.getContent(fromFile);
        
		//trace(s);
        /* -----------------------------------------------------------*/
        // space to tabs      
       
		var packName:String = quickRegM(s, "(package.*)").join("");
		var last:Array<String> = quickRegM(s, "(\\/\\*\\*[\\s\\S]*?\\*\\/\\s*.*|(public|private|proteced) function.+)");
		
		
	   s = packName+"\n {"+last.join("");
		s = quickRegR(s, "(public class.*[a-zA-Z0-9]{1,})", "$1 \n {");
		s = quickRegR(s, "(\\)\\:[^void].*[a-zA-Z0-9]{1,})", "$1 {return null;}");
		s = quickRegR(s, "(\\)\\:void)", "$1 {}");
	   s += "\n } \n}";
		
		var  o = sys.io.File.write(toFile, true);
        o.writeString(s);
        o.close();
        
        /* -----------------------------------------------------------*/
        
        // use for testing on a single file
        //Sys.exit(1);
    }
    
    private function logLoopError(type:String, file:String)
    {
        trace("ERROR: " + type + " - " + file);
    }
    
    private function buildNameSpaces()
    {
        // build friend namespaces!
        trace(nameSpaces);
    }
    
    public static function quickRegR(str:String, reg:String, rep:String, ?regOpt:String = "g"):String
    {
        return new EReg(reg, regOpt).replace(str, rep);
    }
    
    public static function quickRegM(str:String, reg:String,  ?regOpt:String = "g"):Array<String>
    {
        var rgx = new EReg(reg, regOpt);
       
		
		var arr:Array<String> = [];
		
		rgx.match(str);
		
		
		  while (rgx.match(str)) {
           arr.push(rgx.matched(1));
            str = rgx.matchedRight();
        }
		return arr;
       
    }
    
    private function createFolder(path:String):Void
    {
        var parts = path.split("/");
        var folder = "";
        for (part in parts)
        {
            if (folder == "") folder += part;
            else folder += "/" + part;
            if (!FileSystem.exists(folder)) FileSystem.createDirectory(folder);
        }
    }
    
    private function parseArgs():Bool
    {
		trace("start");
        // Parse args
        var args = Sys.args();
        for (i in 0...args.length)
            if (Lambda.has(keys, args[i]))
                Reflect.setField(this, args[i].substr(1), args[i + 1]);
            
        // Check to see if argument is missing
        if (to == null) { Lib.println("Missing argument '-to'"); return false; }
        if (from == null) { Lib.println("Missing argument '-from'"); return false; }
        
        return true;
    }
    
    public function recurse(path:String)
    {
        var dir = FileSystem.readDirectory(path);
        
        for (item in dir)
        {
            var s = path + "/" + item;
            if (FileSystem.isDirectory(s))
            {
                recurse(s);
            }
            else
            {
                var exts = [ext];
                if(Lambda.has(exts, getExt(item)))
                    items.push(s);
            }
        }
    }
    
    public function getExt(s:String)
    {
        return s.substr(s.lastIndexOf(".") + 1).toLowerCase();
    }
    
    public function removeDirectory(d, p = null)
    {
        if (p == null) p = d;
        var dir = FileSystem.readDirectory(d);

        for (item in dir)
        {
            item = p + "/" + item;
            if (FileSystem.isDirectory(item)) {
                removeDirectory(item);
            }else{
                FileSystem.deleteFile(item);
            }
        }
        
        FileSystem.deleteDirectory(d);
    }
    
    public static function fUpper(s:String)
    {
        return s.charAt(0).toUpperCase() + s.substr(1);
    }
}

typedef Ns = {
    var name:String;
    var classDefs:Map<String,String>;
}