Differences between version #14358 and #14359

1,419c1
< <code haxe>
< /*
<  * Copyright (c) 2011, TouchMyPixel & contributors
<  * Original author : Tarwin Stroh-Spijer <tarwin@touchmypixel.com>
<  * Contributers: Tony Polinelli <tonyp@touchmypixel.com>
<  * 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 TOUCH MY PIXEL & CONTRIBUTERS "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 TOUCH MY PIXEL & 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.
<  */
< 
< package;
< 
< import neko.FileSystem;
< import neko.Lib;
< import neko.Sys;
< 
< using StringTools;
< using As3ToHaxe;
< 
< /**
<  * Simple Program which iterates -from folder, finds .mtt templates and compiles them to the -to folder
<  */
< class As3ToHaxe
< {
< 	public static inline var keys = ["-from", "-to", "-remove"];
< 	
< 	var to:String;
< 	var from:String;
< 	var remove:String;
< 	var sysargs:Array<String>;
< 	
< 	var items:Array<String>;
< 	
< 	public static var basePackage:String = "away3d";
< 	
< 	private var nameSpaces:Hash<Ns>;
< 	private var maxLoop:Int;
< 	
< 	static function main() 
< 	{
< 		new As3ToHaxe();
< 	}
< 	
< 	public function new()
< 	{
< 		maxLoop = 1000;
< 		
< 		if (parseArgs())
< 		{
< 		
< 			// 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
< 			recurse(from);
< 
< 			// to remember namespaces
< 			nameSpaces = new Hash();
< 			
< 			for (item in items)
< 			{
< 				// make sure we only work wtih AS fiels
< 				var ext = getExt(item);
< 				switch(ext)
< 				{
< 					case "as": 
< 						doConversion(item);
< 				}
< 			}
< 			
< 			// build namespace files
< 			buildNameSpaces();
< 		}
< 	}
< 	
< 	private function doConversion(file:String):Void
< 	{		
< 		var fromFile = file;
< 		var toFile = to + "/" + file.substr(from.length + 1, file.lastIndexOf(".") - (from.length)) + "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 = neko.io.File.getContent(fromFile);
< 		
< 		// spacse to tabs
< 		s = quickRegR(s, "    ", "\t");
< 		// undent
< 		s = quickRegR(s, "\t\t", "\t");
< 		
< 		// some quick setup, finding what we''ve got
< 		var className = quickRegM(s, "public class([ ]*)([A-Z][a-zA-Z0-9_]*)", 2)[1];
< 		var hasVectors = (quickRegM(s, "Vector([ ]*)\\.([ ]*)<([ ]*)([^>]*)([ ]*)>").length != 0);
< 
< 		// package
< 		s = quickRegR(s, "package ([a-zA-Z\\.0-9-_]*)([ \n\r]*){", "package $1;\n", "gs");
< 		// remove last 
< 		s = quickRegR(s, "\\}([\n\r\t ]*)\\}([\n\r\t ]*)$", "}", "gs");
< 
< 		// extra indentation
< 		s = quickRegR(s, "\n\t", "\n");
< 		
< 		// class
< 		s = quickRegR(s, "public class", "class");
< 
< 		// constructor
< 		s = quickRegR(s, "function " + className, "function new");
< 			
< 		// simple typing
< 		s = quickRegR(s, ":([ ]*)void", ":$1Void");
< 		s = quickRegR(s, ":([ ]*)Boolean", ":$1Bool");
< 		s = quickRegR(s, ":([ ]*)int", ":$1Int");
< 		s = quickRegR(s, ":([ ]*)uint", ":$1UInt");
< 		s = quickRegR(s, ":([ ]*)Number", ":$1Float");
< 		s = quickRegR(s, ":([ ]*)\\*", ":$1Dynamic");
< 		
< 		s = quickRegR(s, "<Number>", "<Float>");
< 		s = quickRegR(s, "<int>", "<Int>");
< 		s = quickRegR(s, "<uint>", "<UInt>");
< 		s = quickRegR(s, "<Boolean>", "<Bool>");
< 		
< 		// vector
< 		// definition
< 		s = quickRegR(s, "Vector([ ]*)\\.([ ]*)<([ ]*)([^>]*)([ ]*)>", "Vector<$3$4$5>");
< 		// new (including removing stupid spaces)
< 		s = quickRegR(s, "new Vector([ ]*)([ ]*)<([ ]*)([^>]*)([ ]*)>([ ]*)\\(([ ]*)\\)([ ]*)", "new Vector()");
< 		// and import if we have to
< 		if (hasVectors) {
< 			s = quickRegR(s, "class([ ]*)(" + className + ")", "import flash.Vector;\n\nclass$1$2");
< 		}
< 		
< 		// array
< 		s = quickRegR(s, " Array([ ]*);", " Array<Dynamic>;");
< 		
< 		// remap protected -> private & internal -> private
< 		s = quickRegR(s, "protected var", "private var");
< 		s = quickRegR(s, "internal var", "private var");
< 		s = quickRegR(s, "protected function", "private function");
< 		s = quickRegR(s, "internal function", "private function");
< 
< 		/* -----------------------------------------------------------*/
< 		// namespaces
< 		// find which namespaces are used in this class
< 		var r = new EReg("([^#])use([ ]+)namespace([ ]+)([a-zA-Z-]+)([ ]*);", "g");
< 		b = 0;
< 		while (true) {
< 			b++; if (b > maxLoop) { logLoopError("namespaces find", file); break; }
< 			if (r.match(s)) {
< 				var ns:Ns = {
< 					name : r.matched(4),
< 					classDefs : new Hash()
< 				};
< 				nameSpaces.set(ns.name, ns);
< 				s = r.replace(s, "//" + r.matched(0).replace("use", "#use") + "\nusing " + basePackage + ".namespace." + ns.name.fUpper() +  ";");
< 			}else {
< 				break;
< 			}
< 		}
< 		
< 		// collect all namespace definitions
< 		// replace them with private
< 		for (k in nameSpaces.keys()) {
< 			var n = nameSpaces.get(k);
< 			b = 0;
< 			while (true) {
< 				b++; if (b > maxLoop) { logLoopError("namespaces collect/replace var", file); break; }
< 				// vars
< 				var r = new EReg(n.name + "([ ]+)var([ ]+)", "g");
< 				s = r.replace(s, "private$1var$2");
< 				if (!r.match(s)) break;
< 			}
< 			b = 0;
< 			while (true) {
< 				b++; if (b > maxLoop) { logLoopError("namespaces collect/replace func", file); break; }
< 				// funcs
< 				var matched:Bool = false;
< 				var r = new EReg(n.name + "([ ]+)function([ ]+)", "g");
< 				if (r.match(s)) matched = true;
< 				s = r.replace(s, "private$1function$2");
< 				r = new EReg(n.name + "([ ]+)function([ ]+)get([ ]+)", "g");
< 				if (r.match(s)) matched = true;
< 				s = r.replace(s, "private$1function$2get$3");
< 				r = new EReg(n.name + "([ ]+)function([ ]+)set([ ]+)", "g");
< 				if (r.match(s)) matched = true;
< 				s = r.replace(s, "private$1function$2$3set");
< 				if (!matched) break;
< 			}
< 		}
< 		
< 		/* -----------------------------------------------------------*/
< 		// change const to inline statics
< 		s = quickRegR(s, "([\n\t ]+)(public|private)([ ]*)const([ ]+)([a-zA-Z0-9_]+)([ ]*):", "$1$2$3static inline var$4$5$6:");
< 		s = quickRegR(s, "([\n\t ]+)(public|private)([ ]*)(static)*([ ]+)const([ ]+)([a-zA-Z0-9_]+)([ ]*):", "$1$2$3$4$5inline var$6$7$8:");
< 		
< 		/* -----------------------------------------------------------*/
< 		// move variables being set from var def to top of constructor
< 		// do NOT do this for const
< 		// if they're static, leave them there
< 		// TODO!
< 		
< 		/* -----------------------------------------------------------*/
< 		// Error > flash.Error
< 		// if " Error (" then add "import flash.Error" to head
< 		var r = new EReg("([ ]+)new([ ]+)Error([ ]*)\\(", "");
< 		if (r.match(s))
< 			s = quickRegR(s, "class([ ]*)(" + className + ")", "import flash.Error;\n\nclass$1$2");
< 		
< 		/* -----------------------------------------------------------*/
< 
< 		// create getters and setters
< 		b = 0;
< 		while (true) {
< 			b++;
< 			var d = { get: null, set: null, type: null, ppg: null, pps: null, name: null };
< 			
< 			// get
< 			var r = new EReg("([\n\t ]+)([a-z]+)([ ]*)function([ ]*)get([ ]+)([a-zA-Z_][a-zA-Z0-9_]+)([ ]*)\\(([ ]*)\\)([ ]*):([ ]*)([A-Z][a-zA-Z0-9_]*)", "");
< 			var m = r.match(s);
< 			if (m) {
< 				d.ppg = r.matched(2);
< 				if (d.ppg == "") d.ppg = "public";
< 				d.name = r.matched(6);
< 				d.get = "get" + d.name.substr(0, 1).toUpperCase() + d.name.substr(1);
< 				d.type = r.matched(11);
< 			}
< 			
< 			// set
< 			var r = new EReg("([\n\t ]+)([a-z]+)([ ]*)function([ ]*)set([ ]+)([a-zA-Z_][a-zA-Z0-9_]*)([ ]*)\\(([ ]*)([a-zA-Z][a-zA-Z0-9_]*)([ ]*):([ ]*)([a-zA-Z][a-zA-Z0-9_]*)", "");
< 			var m = r.match(s);
< 			if (m) {
< 				if (r.matched(6) == d.get || d.get == null)
< 					if (d.name == null) d.name = r.matched(6);
< 				d.pps = r.matched(2);
< 				if (d.pps == "") d.pps = "public";
< 				d.set = "set" + d.name.substr(0, 1).toUpperCase() + d.name.substr(1);
< 				if (d.type == null) d.type = r.matched(12);
< 			}
< 			
< 			// ERROR
< 			if (b > maxLoop) { logLoopError("getter/setter: " + d, file); break; }
< 
< 			// replace get
< 			if (d.get != null)
< 				s = quickRegR(s, d.ppg + "([ ]+)function([ ]+)get([ ]+)" + d.name, "private function " + d.get);
< 			
< 			// replace set
< 			if (d.set != null)
< 				s = quickRegR(s, d.pps + "([ ]+)function([ ]+)set([ ]+)" + d.name, "private function " + d.set);
< 			
< 			// make haxe getter/setter OR finish
< 			if (d.get != null || d.set != null) {
< 				var gs = (d.ppg != null ? d.ppg : d.pps) + " var " + d.name + "(" + d.get + ", " + d.set + "):" + d.type + ";";
< 				s = quickRegR(s, "private function " + (d.get != null ? d.get : d.set), gs + "\n \tprivate function " + (d.get != null ? d.get : d.set));
< 			}else {
< 				break;
< 			}
< 		}
< 
< 		/* -----------------------------------------------------------*/
< 		
< 		// for loops (?)
< 		// TODO!
< 		//s = quickRegR(s, "for([ ]*)\\(([ ]*)var([ ]*)([A-Z][a-zA-Z0-9_]*)([.^;]*);([.^;]*);([.^\\)]*)\\)", "");
< 		//var t = quickRegM(s, "for([ ]*)\\(([ ]*)var([ ]*)([a-zA-Z][a-zA-Z0-9_]*)([.^;]*)", 5);
< 		//trace(t);
< 		//for (var i : Int = 0; i < len; ++i)
< 		
< 		/* -----------------------------------------------------------*/
< 
< 		var o = neko.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, ?numMatches:Int = 1, ?regOpt:String = "g"):Array<String>
< 	{
< 		var r = new EReg(reg, regOpt);
< 		var m = r.match(str);
< 		if (m) {
< 			var a = [];
< 			var i = 1;
< 			while (i <= numMatches) {
< 				a.push(r.matched(i));
< 				i++;
< 			}
< 			return a;
< 		}
< 		return [];
< 	}
< 	
< 	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
< 	{
< 		// 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 = ["as"];
< 				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:Hash<String>;
< }
< </code>
---
> Due to Haxe wiki limitation code had to be moved to pastebin: [[http://pastebin.com/s0VccheL]]