Update README.rst

.gitignore

@@ -1 +1,9 @@
-*.pyc
+# Compiled python modules.
+*.pyc
+
+# Setuptools distribution folder.
+/dist/
+/build/
+
+# Python egg metadata, regenerated from source files by setuptools.
+/*.egg-info

MANIFEST.in

@@ -0,0 +1 @@
+include README.rst

README.rst

@@ -1,29 +1,47 @@
-build
+Lutin
 =====
 
-`lutin` is a generic package maker is a FREE software tool.
+`lutin` is a generic builder and package maker is a FREE software tool.
 
 Instructions
-============
+------------
 
 This is a tool to generate the binary, shared library, static library and package independently of the OS
+
+This software builds C, C++, m, m++, to object file and generate associated libraries (.so & .a) end create final Executable file
+
 This tool can generate package for Linux, MacOs, Android
 
 
-Create a lutin module
-=====================
+Lutin is under a FREE license that can be found in the COPYING file.
+Any contribution is more than welcome ;)
 
-Set the lutin module maker with the name :
-	lutin_xxxxx.py
-	xxx : represent the name of the module/binary/package and must be lower case and no special characters
+git repository
+--------------
+
+http://github.com/HeeroYui/lutin/
+
+Documentation
+-------------
+
+http://github.io/HeeroYui/lutin/
+
+Installation
+------------
+
+Requirements: ``Python >= 2.7`` and ``pip``
+
+Just run::
+
+  pip install lutin
+
+On mac-os you may install pip before:
+
+  sudo easy_install pip
 
-you can see exemple for some type in :
-	ewol : library
-	edn : package
-	glew : prebuild
 
 License (APACHE v2.0)
-=====================
+---------------------
 
 Copyright lutin Edouard DUPIN
 

bin/lutin

@@ -0,0 +1,210 @@
+#!/usr/bin/python
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+
+# for path inspection:
+import sys
+import os
+import lutin.debug as debug
+import lutin.arg as arguments
+import lutin.host as host
+import lutin.module as module
+import lutin.target as target
+import lutin.multiprocess as multiprocess
+
+myArgs = arguments.LutinArg()
+myArgs.add(arguments.ArgDefine("h", "help", desc="display this help"))
+myArgs.add_section("option", "Can be set one time in all case")
+myArgs.add(arguments.ArgDefine("v", "verbose", list=[["0","None"],["1","error"],["2","warning"],["3","info"],["4","debug"],["5","verbose"],["6","extreme_verbose"]], desc="display makefile debug level (verbose) default =2"))
+myArgs.add(arguments.ArgDefine("C", "color", desc="display makefile output in color"))
+myArgs.add(arguments.ArgDefine("f", "force", desc="Force the rebuild without checking the dependency"))
+myArgs.add(arguments.ArgDefine("P", "pretty", desc="print the debug has pretty display"))
+myArgs.add(arguments.ArgDefine("j", "jobs", haveParam=True, desc="Specifies the number of jobs (commands) to run simultaneously"))
+myArgs.add(arguments.ArgDefine("s", "force-strip", desc="Force the stripping of the compile elements"))
+
+myArgs.add_section("properties", "keep in the sequency of the cible")
+myArgs.add(arguments.ArgDefine("t", "target", haveParam=True, desc="Select a target (by default the platform is the computer that compile this) To know list : 'lutin.py --list-target'"))
+myArgs.add(arguments.ArgDefine("c", "compilator", list=[["clang",""],["gcc",""]], desc="Compile with clang or Gcc mode (by default gcc will be used)"))
+myArgs.add(arguments.ArgDefine("m", "mode", list=[["debug",""],["release",""]], desc="Compile in release or debug mode (default release)"))
+myArgs.add(arguments.ArgDefine("a", "arch", list=[["auto","Automatic choice"],["arm","Arm processer"],["x86","Generic PC : AMD/Intel"],["ppc","Power PC"]], desc="Architecture to compile"))
+myArgs.add(arguments.ArgDefine("b", "bus", list=[["auto","Automatic choice"],["32","32 bits"],["64","64 bits"]], desc="Adressing size (Bus size)"))
+myArgs.add(arguments.ArgDefine("p", "package", desc="Disable the package generation (usefull when just compile for test on linux ...)"))
+myArgs.add(arguments.ArgDefine("g", "gcov", desc="Enable code coverage intrusion in code"))
+myArgs.add(arguments.ArgDefine("", "simulation", desc="simulater mode (availlable only for IOS)"))
+myArgs.add(arguments.ArgDefine("", "list-target", desc="list all availlables targets ==> for auto completion"))
+myArgs.add(arguments.ArgDefine("", "list-module", desc="list all availlables module ==> for auto completion"))
+
+myArgs.add_section("cible", "generate in order set")
+localArgument = myArgs.parse()
+
+"""
+	display the help of this makefile
+"""
+def usage():
+	# generic argument displayed : 
+	myArgs.display()
+	print("		All target can finish with '?clean' '?dump' ... ?action")
+	print("		all")
+	print("			build all (only for the current selected board) (bynary and packages)")
+	print("		clean")
+	print("			clean all (same as previous)")
+	print("		dump")
+	print("			Dump all the module dependency and properties")
+	listOfAllModule = module.list_all_module_with_desc()
+	for mod in listOfAllModule:
+		print("		" + mod[0])
+		if mod[1] != "":
+			print("			" + mod[1])
+	print("	ex: " + sys.argv[0] + " all --target=Android all -t Windows -m debug all")
+	exit(0)
+
+# preparse the argument to get the verbose element for debug mode
+def parseGenericArg(argument, active):
+	if argument.get_option_nName() == "help":
+		#display help
+		if active==False:
+			usage()
+		return True
+	if argument.get_option_nName() == "list-module":
+		if active==False:
+			listOfModule = module.list_all_module()
+			retValue = ""
+			for moduleName in listOfModule:
+				if retValue != "":
+					retValue += " "
+				retValue += moduleName
+			print(retValue)
+			exit(0)
+		return True
+	if argument.get_option_nName() == "list-target":
+		if active==False:
+			listOfTarget = target.list_all_target()
+			retValue = ""
+			for targetName in listOfTarget:
+				if retValue != "":
+					retValue += " "
+				retValue += targetName
+			print(retValue)
+			exit(0)
+		return True
+	elif argument.get_option_nName()=="jobs":
+		if active==True:
+			multiprocess.set_core_number(int(argument.get_arg()))
+		return True
+	elif argument.get_option_nName() == "verbose":
+		if active==True:
+			debug.set_level(int(argument.get_arg()))
+		return True
+	elif argument.get_option_nName() == "color":
+		if active==True:
+			debug.enable_color()
+		return True
+	elif argument.get_option_nName() == "force":
+		if active==True:
+			lutinEnv.set_force_mode(True)
+		return True
+	elif argument.get_option_nName() == "pretty":
+		if active==True:
+			lutinEnv.set_print_pretty_mode(True)
+		return True
+	elif argument.get_option_nName() == "force-strip":
+		if active==True:
+			lutinEnv.set_force_strip_mode(True)
+		return True
+	return False
+
+# parse default unique argument:
+for argument in localArgument:
+	parseGenericArg(argument, True)
+
+
+import lutin
+
+
+import lutin.host as lutinHost
+import lutin.tools as lutinTools
+
+#available target : Linux / MacOs / Windows / Android ...
+targetName = host.OS
+config = {
+	"compilator":"gcc",
+	"mode":"release",
+	"bus-size":"auto",
+	"arch":"auto",
+	"generate-package":True,
+	"simulation":False,
+	"gcov":False
+	}
+# load the default target :
+my_target = None
+actionDone=False
+# parse all argument
+for argument in localArgument:
+	if parseGenericArg(argument, False) == True:
+		continue
+	elif argument.get_option_nName() == "package":
+		config["generate-package"]=False
+	elif argument.get_option_nName() == "simulation":
+		config["simulation"]=True
+	elif argument.get_option_nName() == "gcov":
+		config["gcov"]=True
+	elif argument.get_option_nName() == "bus":
+		config["bus-size"]=argument.get_arg()
+	elif argument.get_option_nName() == "arch":
+		config["arch"]=argument.get_arg()
+	elif argument.get_option_nName() == "compilator":
+		if config["compilator"] != argument.get_arg():
+			debug.debug("change compilator ==> " + argument.get_arg())
+			config["compilator"] = argument.get_arg()
+			#remove previous target
+			my_target = None
+	elif argument.get_option_nName() == "target":
+		# No check input ==> this will be verify automaticly chen the target will be loaded
+		if targetName != argument.get_arg():
+			targetName = argument.get_arg()
+			debug.debug("change target ==> '" + targetName + "' & reset mode : gcc&release")
+			#reset properties by defauult:
+			config = {
+			             "compilator":"gcc",
+			             "mode":"release",
+			             "bus-size":"auto",
+			             "arch":"auto",
+			             "generate-package":True,
+			             "simulation":False,
+			             "gcov":False
+			          }
+			#remove previous target
+			my_target = None
+	elif argument.get_option_nName() == "mode":
+		if config["mode"] != argument.get_arg():
+			config["mode"] = argument.get_arg()
+			debug.debug("change mode ==> " + config["mode"])
+			#remove previous target
+			my_target = None
+	else:
+		if argument.get_option_nName() != "":
+			debug.warning("Can not understand argument : '" + argument.get_option_nName() + "'")
+			usage()
+		else:
+			#load the target if needed :
+			if my_target == None:
+				my_target = target.load_target(targetName, config)
+			my_target.build(argument.get_arg())
+			actionDone=True
+
+# if no action done : we do "all" ...
+if actionDone==False:
+	#load the target if needed :
+	if my_target == None:
+		my_target = target.load_target(targetName, config)
+	my_target.build("all")
+
+# stop all started threads;
+multiprocess.un_init()
+
+

lutin.py

@@ -1,238 +0,0 @@
-#!/usr/bin/python
-##
-## @author Edouard DUPIN
-##
-## @copyright 2012, Edouard DUPIN, all right reserved
-##
-## @license APACHE v2.0 (see license file)
-##
-
-# for path inspection:
-import sys
-import os
-import inspect
-import fnmatch
-import lutinDebug as debug
-import lutinEnv
-import lutinModule
-import lutinMultiprocess
-import lutinArg
-
-myLutinArg = lutinArg.LutinArg()
-myLutinArg.add(lutinArg.ArgDefine("h", "help", desc="display this help"))
-myLutinArg.add_section("option", "Can be set one time in all case")
-myLutinArg.add(lutinArg.ArgDefine("v", "verbose", list=[["0","None"],["1","error"],["2","warning"],["3","info"],["4","debug"],["5","verbose"],["6","extreme_verbose"]], desc="display makefile debug level (verbose) default =2"))
-myLutinArg.add(lutinArg.ArgDefine("C", "color", desc="display makefile output in color"))
-myLutinArg.add(lutinArg.ArgDefine("f", "force", desc="Force the rebuild without checking the dependency"))
-myLutinArg.add(lutinArg.ArgDefine("P", "pretty", desc="print the debug has pretty display"))
-myLutinArg.add(lutinArg.ArgDefine("j", "jobs", haveParam=True, desc="Specifies the number of jobs (commands) to run simultaneously"))
-myLutinArg.add(lutinArg.ArgDefine("s", "force-strip", desc="Force the stripping of the compile elements"))
-
-myLutinArg.add_section("properties", "keep in the sequency of the cible")
-myLutinArg.add(lutinArg.ArgDefine("t", "target", haveParam=True, desc="Select a target (by default the platform is the computer that compile this) To know list : 'lutin.py --list-target'"))
-myLutinArg.add(lutinArg.ArgDefine("c", "compilator", list=[["clang",""],["gcc",""]], desc="Compile with clang or Gcc mode (by default gcc will be used)"))
-myLutinArg.add(lutinArg.ArgDefine("m", "mode", list=[["debug",""],["release",""]], desc="Compile in release or debug mode (default release)"))
-myLutinArg.add(lutinArg.ArgDefine("a", "arch", list=[["auto","Automatic choice"],["arm","Arm processer"],["x86","Generic PC : AMD/Intel"],["ppc","Power PC"]], desc="Architecture to compile"))
-myLutinArg.add(lutinArg.ArgDefine("b", "bus", list=[["auto","Automatic choice"],["32","32 bits"],["64","64 bits"]], desc="Adressing size (Bus size)"))
-myLutinArg.add(lutinArg.ArgDefine("p", "package", desc="Disable the package generation (usefull when just compile for test on linux ...)"))
-myLutinArg.add(lutinArg.ArgDefine("g", "gcov", desc="Enable code coverage intrusion in code"))
-myLutinArg.add(lutinArg.ArgDefine("", "simulation", desc="simulater mode (availlable only for IOS)"))
-myLutinArg.add(lutinArg.ArgDefine("", "list-target", desc="list all availlables targets ==> for auto completion"))
-myLutinArg.add(lutinArg.ArgDefine("", "list-module", desc="list all availlables module ==> for auto completion"))
-
-myLutinArg.add_section("cible", "generate in order set")
-localArgument = myLutinArg.parse()
-
-"""
-	display the help of this makefile
-"""
-def usage():
-	# generic argument displayed : 
-	myLutinArg.display()
-	print "		All target can finish with '-clean' '-dump' ..."
-	print "		all"
-	print "			build all (only for the current selected board) (bynary and packages)"
-	print "		clean"
-	print "			clean all (same as previous)"
-	print "		dump"
-	print "			Dump all the module dependency and properties"
-	listOfAllModule = lutinModule.list_all_module_with_desc()
-	for mod in listOfAllModule:
-		print "		" + mod[0]
-		if mod[1] != "":
-			print "			" + mod[1]
-	print "	ex: " + sys.argv[0] + " all --target=Android all -t Windows -m debug all"
-	exit(0)
-
-# preparse the argument to get the verbose element for debug mode
-def parseGenericArg(argument,active):
-	if argument.get_option_nName() == "help":
-		#display help
-		if active==False:
-			usage()
-		return True
-	if argument.get_option_nName() == "list-module":
-		if active==False:
-			listOfModule = lutinModule.list_all_module()
-			retValue = ""
-			for moduleName in listOfModule:
-				if retValue != "":
-					retValue += " "
-				retValue += moduleName
-			print retValue
-			exit(0)
-		return True
-	if argument.get_option_nName() == "list-target":
-		if active==False:
-			listOfTarget = lutinTarget.list_all_target()
-			retValue = ""
-			for targetName in listOfTarget:
-				if retValue != "":
-					retValue += " "
-				retValue += targetName
-			print retValue
-			exit(0)
-		return True
-	elif argument.get_option_nName()=="jobs":
-		if active==True:
-			lutinMultiprocess.set_core_number(int(argument.get_arg()))
-		return True
-	elif argument.get_option_nName() == "verbose":
-		if active==True:
-			debug.set_level(int(argument.get_arg()))
-		return True
-	elif argument.get_option_nName() == "color":
-		if active==True:
-			debug.enable_color()
-		return True
-	elif argument.get_option_nName() == "force":
-		if active==True:
-			lutinEnv.set_force_mode(True)
-		return True
-	elif argument.get_option_nName() == "pretty":
-		if active==True:
-			lutinEnv.set_print_pretty_mode(True)
-		return True
-	elif argument.get_option_nName() == "force-strip":
-		if active==True:
-			lutinEnv.set_force_strip_mode(True)
-		return True
-	return False
-
-# parse default unique argument:
-if __name__ == "__main__":
-	for argument in localArgument:
-		parseGenericArg(argument, True)
-
-# now import other standard module (must be done here and not before ...
-import lutinTarget
-import lutinSystem
-import lutinHost
-import lutinTools
-
-"""
-	Run everything that is needed in the system
-"""
-def Start():
-	#available target : Linux / MacOs / Windows / Android ...
-	targetName=lutinHost.OS
-	config = {
-	             "compilator":"gcc",
-	             "mode":"release",
-	             "bus-size":"auto",
-	             "arch":"auto",
-	             "generate-package":True,
-	             "simulation":False,
-	             "gcov":False
-	          }
-	# load the default target :
-	target = None
-	actionDone=False
-	# parse all argument
-	for argument in localArgument:
-		if True==parseGenericArg(argument, False):
-			continue
-		elif argument.get_option_nName() == "package":
-			config["generate-package"]=False
-		elif argument.get_option_nName() == "simulation":
-			config["simulation"]=True
-		elif argument.get_option_nName() == "gcov":
-			config["gcov"]=True
-		elif argument.get_option_nName() == "bus":
-			config["bus-size"]=argument.get_arg()
-		elif argument.get_option_nName() == "arch":
-			config["arch"]=argument.get_arg()
-		elif argument.get_option_nName() == "compilator":
-			if config["compilator"] != argument.get_arg():
-				debug.debug("change compilator ==> " + argument.get_arg())
-				config["compilator"] = argument.get_arg()
-				#remove previous target
-				target = None
-		elif argument.get_option_nName() == "target":
-			# No check input ==> this will be verify automaticly chen the target will be loaded
-			if targetName!=argument.get_arg():
-				targetName=argument.get_arg()
-				debug.debug("change target ==> '" + targetName + "' & reset mode : gcc&release")
-				#reset properties by defauult:
-				config = {
-				             "compilator":"gcc",
-				             "mode":"release",
-				             "bus-size":"auto",
-				             "arch":"auto",
-				             "generate-package":True,
-				             "simulation":False,
-				             "gcov":False
-				          }
-				#remove previous target
-				target = None
-		elif argument.get_option_nName() == "mode":
-			if config["mode"]!=argument.get_arg():
-				config["mode"] = argument.get_arg()
-				debug.debug("change mode ==> " + config["mode"])
-				#remove previous target
-				target = None
-		else:
-			if argument.get_option_nName() != "":
-				debug.warning("Can not understand argument : '" + argument.get_option_nName() + "'")
-				usage()
-			else:
-				#load the target if needed :
-				if target == None:
-					target = lutinTarget.load_target(targetName, config)
-				target.build(argument.get_arg())
-				actionDone=True
-	# if no action done : we do "all" ...
-	if actionDone==False:
-		#load the target if needed :
-		if target == None:
-			target = lutinTarget.load_target(targetName, config)
-		target.build("all")
-	# stop all started threads 
-	lutinMultiprocess.un_init()
-
-"""
-	When the user use with make.py we initialise ourself
-"""
-if __name__ == '__main__':
-	debug.verbose("Use Make as a make stadard")
-	sys.path.append(lutinTools.get_run_folder())
-	debug.verbose(" try to impoert module 'lutinBase.py'")
-	if os.path.exists("lutinBase.py" )==True:
-		__import__("lutinBase")
-	else:
-		debug.debug("missing file lutinBase.py ==> loading subPath...");
-		# Import all sub path without out and archive
-		for folder in os.listdir("."):
-			if os.path.isdir(folder)==True:
-				if     folder.lower()!="android" \
-				   and folder.lower()!="archive" \
-				   and folder.lower()!="out" :
-					debug.debug("Automatic load path: '" + folder + "'")
-					lutinModule.import_path(folder)
-					lutinSystem.import_path(folder)
-					lutinTarget.import_path(folder)
-		#lutinSystem.display()
-	Start()
-
-
-

lutin/__init__.py

@@ -0,0 +1,47 @@
+#!/usr/bin/python
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+import os
+import sys
+# Local import
+from . import target
+from . import builder
+from . import system
+from . import host
+from . import tools
+from . import debug
+from . import module
+
+is_init = False
+
+if is_init == False:
+	debug.verbose("Use Make as a make stadard")
+	sys.path.append(tools.get_run_folder())
+	builder.import_path(tools.get_current_path(__file__))
+	module.import_path(tools.get_current_path(__file__))
+	system.import_path(tools.get_current_path(__file__))
+	target.import_path(tools.get_current_path(__file__))
+	
+	debug.debug("missing file lutinBase.py ==> loading subPath...");
+	# Import all sub path without out and archive
+	for folder in os.listdir("."):
+		if os.path.isdir(folder)==True:
+			if     folder.lower()!="android" \
+			   and folder.lower()!="archive" \
+			   and folder.lower()!="out" :
+				debug.debug("Automatic load path: '" + folder + "'")
+				builder.import_path(folder)
+				module.import_path(folder)
+				system.import_path(folder)
+				target.import_path(folder)
+	
+	builder.init()
+	
+	is_init = True
+
+

lutin/arg.py

@@ -6,9 +6,9 @@
 ##
 ## @license APACHE v2.0 (see license file)
 ##
-
 import sys
-import lutinDebug as debug
+# Local import
+from . import debug
 
 class ArgElement:
 	def __init__(self, option, value=""):
@@ -249,10 +249,10 @@ class LutinArg:
 	
 	
 	def display(self):
-		print "usage:"
+		print("usage:")
 		listOfPropertiesArg = "";
 		for element in self.m_listProperties :
 			listOfPropertiesArg += element.get_porperties()
-		print "	" + sys.argv[0] + listOfPropertiesArg + " ..."
+		print("	" + sys.argv[0] + listOfPropertiesArg + " ...")
 		for element in self.m_listProperties :
 			element.display()

lutin/builder.py

@@ -0,0 +1,74 @@
+#!/usr/bin/python
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+import sys
+import os
+import inspect
+import fnmatch
+import datetime
+# Local import
+from . import debug
+from . import heritage
+
+##
+## constitution of dictionnary:
+##     - "type": "compiler", "linker"
+##     - "in": input type file
+##     - "out": extention of the files
+##     - "builder": pointer on the element
+##
+builder_list=[]
+__start_builder_name="lutinBuilder_"
+
+
+def import_path(path):
+	global builder_list
+	matches = []
+	debug.debug('BUILDER: Start find sub File : "%s"' %path)
+	for root, dirnames, filenames in os.walk(path):
+		tmpList = fnmatch.filter(filenames, __start_builder_name + "*.py")
+		# Import the module :
+		for filename in tmpList:
+			debug.debug('BUILDER:     Find a file : "%s"' %os.path.join(root, filename))
+			#matches.append(os.path.join(root, filename))
+			sys.path.append(os.path.dirname(os.path.join(root, filename)) )
+			builder_name = filename.replace('.py', '')
+			the_builder = __import__(builder_name)
+			builder_list.append({"name":builder_name,
+			                     "element":the_builder
+			                    })
+			debug.debug('BUILDER:     type=' + the_builder.get_type() + " in=" + str(the_builder.get_input_type()) + " out=" + str(the_builder.get_output_type()))
+
+# we must have call all import before ...
+def init():
+	global builder_list
+	debug.debug('BUILDER: Initialize all ...')
+	for element in builder_list:
+		if element["element"] != None:
+			element["element"].init()
+
+def get_builder(input_type):
+	global builder_list
+	for element in builder_list:
+		if element["element"] != None:
+			if input_type in element["element"].get_input_type():
+				return element["element"]
+	# we can not find the builder ...
+	debug.error("Can not find builder for type : '" + str(input_type) + "'")
+	raise ValueError('type error :' + str(input_type))
+
+
+def get_builder_with_output(input_type):
+	global builder_list
+	for element in builder_list:
+		if element["element"] != None:
+			if input_type in element["element"].get_output_type():
+				return element["element"]
+	# we can not find the builder ...
+	debug.error("Can not find builder for type : '" + str(input_type) + "'")
+	raise ValueError('type error :' + str(input_type))

lutin/builder/lutinBuilder_binary.py

@@ -0,0 +1,108 @@
+##
+## Executable/binary builder
+##
+from lutin import multiprocess
+from lutin import tools
+from lutin import debug
+from lutin import depend
+from lutin import env
+import os
+
+##
+## Initialize the builder, if needed ... to get dependency between builder (for example)
+##
+def init():
+	pass
+
+##
+## Get the current builder type.
+## Return the type of builder
+##
+def get_type():
+	return "linker"
+
+
+##
+## @brief Get builder input file type
+## @return List of extention supported
+##
+def get_input_type():
+	return ["o"]
+
+##
+## @brief Get builder output file type
+## @return List of extention supported
+##
+def get_output_type():
+	return ["", "exe", "bin"]
+
+
+##
+## @brief Commands for running gcc to link an executable.
+##
+def link(file, binary, target, depancy, name, basic_folder):
+	file_src, file_dst, file_depend, file_cmd = target.generate_file(binary, name, basic_folder, file, "bin")
+	#create comdLine :
+	cmd = [
+		target.xx
+		]
+	try:
+		cmd.append(target.arch)
+	except:
+		pass
+	try:
+		cmd.append(target.sysroot)
+	except:
+		pass
+	try:
+		cmd.append(target.global_sysroot)
+	except:
+		pass
+	try:
+		cmd.append(["-o", file_dst])
+	except:
+		pass
+	try:
+		cmd.append(file_src)
+	except:
+		pass
+	try:
+		cmd.append(depancy.src)
+	except:
+		pass
+	try:
+		cmd.append(flags["local"]["link"])
+	except:
+		pass
+	try:
+		cmd.append(depancy.flags["link"])
+	except:
+		pass
+	try:
+		cmd.append(target.global_flags_ld)
+	except:
+		pass
+	cmdLine=tools.list_to_str(cmd)
+	# check the dependency for this file :
+	if     depend.need_re_package(file_dst, file_src, True, file_cmd, cmdLine) == False \
+	   and depend.need_re_package(file_dst, depancy.src, False, file_cmd, cmdLine) == False:
+		return file_dst
+	tools.create_directory_of_file(file_dst)
+	debug.print_element("Executable", name, "==>", file_dst)
+	
+	multiprocess.run_command(cmdLine)
+	if    target.config["mode"] == "release"\
+	   or env.get_force_strip_mode() == True:
+		# get the file size of the non strip file
+		originSize = tools.file_size(file_dst);
+		debug.print_element("Executable(strip)", name, "", "")
+		cmdLineStrip=tools.list_to_str([
+			target.strip,
+			file_dst])
+		multiprocess.run_command(cmdLineStrip)
+		# get the stip size of the binary
+		stripSize = tools.file_size(file_dst)
+		debug.debug("file reduce size : " + str(originSize/1024) + "ko ==> " + str(stripSize/1024) + "ko")
+	# write cmd line only after to prevent errors ...
+	multiprocess.store_command(cmdLine, file_cmd)
+	

lutin/builder/lutinBuilder_c.py

@@ -0,0 +1,136 @@
+##
+## C builder
+##
+from lutin import multiprocess
+from lutin import tools
+from lutin import debug
+from lutin import depend
+
+# C version:
+default_version = 1989
+default_version_gnu = False
+
+##
+## Initialize the builder, if needed ... to get dependency between builder (for example)
+##
+def init():
+	pass
+
+##
+## Get the current builder type.
+## Return the type of builder
+##
+def get_type():
+	return "compiler"
+
+##
+## @brief Get builder input file type
+## @return List of extention supported
+##
+def get_input_type():
+	return ["c", "C"]
+
+##
+## @brief Get builder output file type
+## @return List of extention supported
+##
+def get_output_type():
+	return ["o"]
+
+##
+## @brief Commands for running gcc to compile a C file in object file.
+##
+def compile(file, binary, target, depancy, flags, path, name, basic_folder):
+	file_src, file_dst, file_depend, file_cmd = target.file_generate_object(binary, name, basic_folder,file)
+	
+	# create the command line befor requesting start:
+	cmd = [
+		target.cc,
+		"-o", file_dst,
+		target.arch,
+		target.sysroot,
+		target.global_include_cc]
+	try:
+		cmd.append(tools.add_prefix("-I", path["export"]))
+	except:
+		pass
+	try:
+		cmd.append(tools.add_prefix("-I", path["local"]))
+	except:
+		pass
+	try:
+		cmd.append(tools.add_prefix("-I", depancy.path))
+	except:
+		pass
+	try:
+		cmd.append(get_version_compilation_flags(flags, depancy.flags))
+	except:
+		pass
+	try:
+		cmd.append(target.global_flags_cc)
+	except:
+		pass
+	try:
+		cmd.append(depancy.flags["c"])
+	except:
+		pass
+	try:
+		cmd.append(flags["local"]["c"])
+	except:
+		pass
+	try:
+		cmd.append(flags["export"]["c"])
+	except:
+		pass
+	cmd.append("-c")
+	cmd.append("-MMD")
+	cmd.append("-MP")
+	cmd.append(file_src)
+	# Create cmd line
+	cmdLine=tools.list_to_str(cmd)
+	# check the dependency for this file :
+	if depend.need_re_build(file_dst, file_src, file_depend, file_cmd, cmdLine) == False:
+		return file_dst
+	tools.create_directory_of_file(file_dst)
+	comment = ["c", name, "<==", file]
+	# process element
+	multiprocess.run_in_pool(cmdLine, comment, file_cmd)
+	return file_dst
+
+
+def get_version_compilation_flags(flags, dependency_flags):
+	try:
+		version_local = flags["local"]["c-version"]["version"]
+	except:
+		version_local = default_version
+	try:
+		dependency_version = dependency_flags["c-version"]
+	except:
+		dependency_version = default_version
+	try:
+		is_gnu = flags["local"]["c-version"]["gnu"]
+	except:
+		is_gnu = default_version_gnu
+	
+	version = max(version_local, dependency_version)
+	if version == 2011:
+		if is_gnu ==True:
+			out = ["-std=gnu11", "-D__C_VERSION__=2011"]
+		else:
+			out = ["-std=c11", "-D__C_VERSION__=1989"]
+	elif version == 1999:
+		if is_gnu ==True:
+			out = ["-std=gnu99", "-D__C_VERSION__=1999"]
+		else:
+			out = ["-std=c99", "-D__C_VERSION__=1989"]
+	elif version == 1990:
+		if is_gnu ==True:
+			out = ["-std=gnu90", "-D__C_VERSION__=1990"]
+		else:
+			out = ["-std=c90", "-D__C_VERSION__=1989"]
+	else:
+		if is_gnu ==True:
+			out = ["-std=gnu89", "-D__C_VERSION__=1989"]
+		else:
+			out = ["-std=c89", "-D__C_VERSION__=1989"]
+	return out

lutin/builder/lutinBuilder_cpp.py

@@ -0,0 +1,151 @@
+##
+## C++ builder
+##
+from lutin import multiprocess
+from lutin import tools
+from lutin import debug
+from lutin import depend
+# C++ default version:
+default_version = 1999
+default_version_gnu = False
+
+##
+## Initialize the builder, if needed ... to get dependency between builder (for example)
+##
+def init():
+	pass
+
+##
+## Get the current builder type.
+## Return the type of builder
+##
+def get_type():
+	return "compiler"
+
+##
+## @brief Get builder input file type
+## @return List of extention supported
+##
+def get_input_type():
+	return ["cpp", "CPP", "cxx", "CXX", "xx", "XX", "CC", "cc"]
+
+##
+## @brief Get builder output file type
+## @return List of extention supported
+##
+def get_output_type():
+	return ["o"]
+
+##
+## @brief Commands for running gcc to compile a C++ file in object file.
+##
+def compile(file, binary, target, depancy, flags, path, name, basic_folder):
+	file_src, file_dst, file_depend, file_cmd = target.file_generate_object(binary, name, basic_folder, file)
+	
+	# create the command line befor requesting start:
+	cmd = [
+		target.xx,
+		"-o", file_dst,
+		target.arch,
+		target.sysroot,
+		target.global_include_cc
+		]
+	try:
+		cmd.append(tools.add_prefix("-I",path["export"]))
+	except:
+		pass
+	try:
+		cmd.append(tools.add_prefix("-I",path["local"]))
+	except:
+		pass
+	try:
+		cmd.append(tools.add_prefix("-I",depancy.path))
+	except:
+		pass
+	try:
+		cmd.append(get_version_compilation_flags(flags, depancy.flags))
+	except:
+		pass
+	try:
+		cmd.append(target.global_flags_cc)
+	except:
+		pass
+	try:
+		cmd.append(target.global_flags_xx)
+	except:
+		pass
+	try:
+		cmd.append(depancy.flags["c"])
+	except:
+		pass
+	try:
+		cmd.append(depancy.flags["c++"])
+	except:
+		pass
+	try:
+		cmd.append(flags["local"]["c"])
+	except:
+		pass
+	try:
+		cmd.append(flags["local"]["c++"])
+	except:
+		pass
+	try:
+		cmd.append(flags["export"]["c"])
+	except:
+		pass
+	try:
+		cmd.append(flags["export"]["c++"])
+	except:
+		pass
+	cmd.append(["-c", "-MMD", "-MP"])
+	cmd.append(file_src)
+	# Create cmd line
+	cmdLine=tools.list_to_str(cmd)
+	
+	# check the dependency for this file :
+	if depend.need_re_build(file_dst, file_src, file_depend, file_cmd, cmdLine) == False:
+		return file_dst
+	tools.create_directory_of_file(file_dst)
+	comment = ["c++", name, "<==", file]
+	#process element
+	multiprocess.run_in_pool(cmdLine, comment, file_cmd)
+	return file_dst
+
+def get_version_compilation_flags(flags, dependency_flags):
+	try:
+		version_local = flags["local"]["c++-version"]["version"]
+	except:
+		version_local = default_version
+	try:
+		dependency_version = dependency_flags["c++-version"]
+	except:
+		dependency_version = default_version
+	try:
+		is_gnu = flags["local"]["c++-version"]["gnu"]
+	except:
+		is_gnu = default_version_gnu
+	
+	version = max(version_local, dependency_version)
+	if version == 2014:
+		debug.error("not supported flags for X14 ...");
+		if is_gnu == True:
+			out = ["-std=gnu++14", "-D__CPP_VERSION__=2014"]
+		else:
+			out = ["-std=c++14", "-D__CPP_VERSION__=2014"]
+	elif version == 2011:
+		if is_gnu == True:
+			out = ["-std=gnu++11", "-D__CPP_VERSION__=2011"]
+		else:
+			out = ["-std=c++11", "-D__CPP_VERSION__=2011"]
+	elif version == 2003:
+		if is_gnu == True:
+			out = ["-std=gnu++03", "-D__CPP_VERSION__=2003"]
+		else:
+			out = ["-std=c++03", "-D__CPP_VERSION__=2003"]
+	else:
+		if is_gnu == True:
+			out = ["-std=gnu++98", "-D__CPP_VERSION__=1999"]
+		else:
+			out = ["-std=c++98", "-D__CPP_VERSION__=1999"]
+	return out

lutin/builder/lutinBuilder_java.py

@@ -0,0 +1,34 @@
+##
+## Java builder
+##
+from lutin import multiprocess
+from lutin import tools
+from lutin import debug
+from lutin import depend
+
+##
+## Initialize the builder, if needed ... to get dependency between builder (for example)
+##
+def init():
+	pass
+
+##
+## Get the current builder type.
+## Return the type of builder
+##
+def get_type():
+	return "compiler"
+
+##
+## @brief Get builder input file type
+## @return List of extention supported
+##
+def get_input_type():
+	return ["java"]
+
+##
+## @brief Get builder output file type
+## @return List of extention supported
+##
+def get_output_type():
+	return ["class"]

lutin/builder/lutinBuilder_libraryDynamic.py

@@ -0,0 +1,100 @@
+##
+## Dynamic library builder
+##
+from lutin import multiprocess
+from lutin import tools
+from lutin import debug
+from lutin import depend
+from lutin import env
+import os
+
+##
+## Initialize the builder, if needed ... to get dependency between builder (for example)
+##
+def init():
+	pass
+
+##
+## Get the current builder type.
+## Return the type of builder
+##
+def get_type():
+	return "linker"
+
+##
+## @brief Get builder input file type
+## @return List of extention supported
+##
+def get_input_type():
+	return ["o"]
+
+##
+## @brief Get builder output file type
+## @return List of extention supported
+##
+def get_output_type():
+	return ["so", "dynlib", "dll"]
+
+##
+## @brief Commands for running gcc to link a shared library.
+##
+def link(file, binary, target, depancy, name, basic_folder):
+	file_src, file_dst, file_depend, file_cmd = target.generate_file(binary, name, basic_folder, file, "lib-shared")
+	#create command Line
+	cmd = [
+		target.xx,
+		"-o", file_dst
+		]
+	try:
+		cmd.append(target.global_sysroot)
+	except:
+		pass
+	try:
+		cmd.append(target.arch)
+	except:
+		pass
+	cmd.append("-shared")
+	try:
+		cmd.append(file_src)
+	except:
+		pass
+	try:
+		cmd.append(depancy.src)
+	except:
+		pass
+	try:
+		cmd.append(flags["local"]["link"])
+	except:
+		pass
+	try:
+		cmd.append(depancy.flags["link"])
+	except:
+		pass
+	try:
+		cmd.append(target.global_flags_ld)
+	except:
+		pass
+	cmdLine=tools.list_to_str(cmd)
+	# check the dependency for this file :
+	if     depend.need_re_package(file_dst, file_src, True, file_cmd, cmdLine) == False \
+	   and depend.need_re_package(file_dst, depancy.src, False, file_cmd, cmdLine) == False:
+		return tmpList[1]
+	tools.create_directory_of_file(file_dst)
+	debug.print_element("SharedLib", name, "==>", file_dst)
+	multiprocess.run_command(cmdLine)
+	# strip the output file:
+	if    target.config["mode"] == "release" \
+	   or env.get_force_strip_mode() == True:
+		# get the file size of the non strip file
+		originSize = tools.file_size(file_dst);
+		debug.print_element("SharedLib(strip)", name, "", "")
+		cmdLineStrip=tools.list_to_str([
+			target.strip,
+			file_dst])
+		multiprocess.run_command(cmdLineStrip)
+		# get the stip size of the binary
+		stripSize = tools.file_size(file_dst)
+		debug.debug("file reduce size : " + str(originSize/1024) + "ko ==> " + str(stripSize/1024) + "ko")
+	# write cmd line only after to prevent errors ...
+	multiprocess.store_command(cmdLine, file_cmd)
+	#debug.print_element("SharedLib", self.name, "==>", tmpList[1])

lutin/builder/lutinBuilder_libraryStatic.py

@@ -0,0 +1,82 @@
+##
+## Static library builder
+##
+from lutin import multiprocess
+from lutin import tools
+from lutin import debug
+from lutin import depend
+from lutin import env
+import os
+
+##
+## Initialize the builder, if needed ... to get dependency between builder (for example)
+##
+def init():
+	pass
+
+##
+## Get the current builder type.
+## Return the type of builder
+##
+def get_type():
+	return "linker"
+
+##
+## @brief Get builder input file type
+## @return List of extention supported
+##
+def get_input_type():
+	return ["o"]
+
+##
+## @brief Get builder output file type
+## @return List of extention supported
+##
+def get_output_type():
+	return ["a"]
+
+##
+## @brief Commands for running ar.
+##
+def link(file, binary, target, depancy, name, basic_folder):
+	file_src, file_dst, file_depend, file_cmd = target.generate_file(binary, name, basic_folder, file, "lib-static")
+	#$(Q)$(TARGET_AR) $(TARGET_GLOBAL_ARFLAGS) $(PRIVATE_ARFLAGS) $@ $(PRIVATE_ALL_OBJECTS)
+	cmd = [
+		target.ar
+		]
+	try:
+		cmd.append(target.global_flags_ar)
+	except:
+		pass
+	try:
+		cmd.append(flags["local"]["link"])
+	except:
+		pass
+	try:
+		cmd.append(file_dst)
+	except:
+		pass
+	try:
+		cmd.append(file_src)
+	except:
+		pass
+	cmdLine=tools.list_to_str(cmd)
+	# check the dependency for this file :
+	if     depend.need_re_package(file_dst, file_src, True, file_cmd, cmdLine) == False \
+	   and depend.need_re_package(file_dst, depancy.src, False, file_cmd, cmdLine) == False:
+		return file_dst
+	tools.create_directory_of_file(file_dst)
+	debug.print_element("StaticLib", name, "==>", file_dst)
+	# explicitly remove the destination to prevent error ...
+	if os.path.exists(file_dst) and os.path.isfile(file_dst):
+		os.remove(file_dst)
+	multiprocess.run_command(cmdLine)
+	#$(Q)$(TARGET_RANLIB) $@
+	if target.ranlib != "":
+		cmdLineRanLib=tools.list_to_str([
+			target.ranlib,
+			file_dst ])
+		multiprocess.run_command(cmdLineRanLib)
+	# write cmd line only after to prevent errors ...
+	multiprocess.store_command(cmdLine, file_cmd)
+	return file_dst

lutin/builder/lutinBuilder_m.py

@@ -0,0 +1,114 @@
+##
+## Objective-C builder
+##
+from lutin import multiprocess
+from lutin import tools
+from lutin import builder
+from lutin import debug
+from lutin import depend
+
+local_ref_on_builder_c = None
+
+##
+## Initialize the builder, if needed ... to get dependency between builder (for example)
+##
+def init():
+	global local_ref_on_builder_c
+	debug.debug("m builder get dependency on the C builder")
+	local_ref_on_builder_c = builder.get_builder("c")
+
+##
+## Get the current builder type.
+## Return the type of builder
+##
+def get_type():
+	return "compiler"
+
+##
+## @brief Get builder input file type
+## @return List of extention supported
+##
+def get_input_type():
+	return ["m", "M"]
+
+##
+## @brief Get builder output file type
+## @return List of extention supported
+##
+def get_output_type():
+	return ["o"]
+
+##
+## @brief Commands for running gcc to compile a m file in object file.
+##
+def compile(file, binary, target, depancy, flags, path, name, basic_folder):
+	file_src, file_dst, file_depend, file_cmd = target.file_generate_object(binary, name, basic_folder, file)
+	# create the command line befor requesting start:
+	cmd = [
+		target.cc,
+		"-o", file_dst ,
+		target.arch,
+		target.sysroot,
+		target.global_include_cc]
+	try:
+		cmd.append(tools.add_prefix("-I",path["export"]))
+	except:
+		pass
+	try:
+		cmd.append(tools.add_prefix("-I",path["local"]))
+	except:
+		pass
+	try:
+		cmd.append(tools.add_prefix("-I",depancy.path))
+	except:
+		pass
+	try:
+		cmd.append(local_ref_on_builder_c.get_version_compilation_flags(flags, depancy.flags))
+	except:
+		pass
+	try:
+		cmd.append(target.global_flags_cc)
+	except:
+		pass
+	try:
+		cmd.append(target.global_flags_m)
+	except:
+		pass
+	try:
+		cmd.append(depancy.flags["c"])
+	except:
+		pass
+	try:
+		cmd.append(depancy.flags["m"])
+	except:
+		pass
+	try:
+		cmd.append(flags["local"]["c"])
+	except:
+		pass
+	try:
+		cmd.append(flags["local"]["m"])
+	except:
+		pass
+	try:
+		cmd.append(flags["export"]["c"])
+	except:
+		pass
+	try:
+		cmd.append(flags["export"]["m"])
+	except:
+		pass
+	cmd.append("-c -MMD -MP")
+	cmd.append("-x objective-c")
+	cmd.append(file_src)
+	# Create cmd line
+	cmdLine=tools.list_to_str(cmd)
+	# check the dependency for this file :
+	if False==depend.need_re_build(file_dst, file_src, file_depend, file_cmd, cmdLine):
+		return file_dst
+	tools.create_directory_of_file(file_dst)
+	comment = ["m", name, "<==", file]
+	#process element
+	multiprocess.run_in_pool(cmdLine, comment, file_cmd)
+	return file_dst
+

lutin/builder/lutinBuilder_mm.py

@@ -0,0 +1,125 @@
+##
+## Objective C++ builder
+##
+from lutin import multiprocess
+from lutin import tools
+from lutin import builder
+from lutin import debug
+from lutin import depend
+
+local_ref_on_builder_cpp = None
+
+##
+## Initialize the builder, if needed ... to get dependency between builder (for example)
+##
+def init():
+	global local_ref_on_builder_cpp
+	debug.debug("mm builder get dependency on the CPP builder")
+	local_ref_on_builder_cpp = builder.get_builder("cpp")
+
+##
+## Get the current builder type.
+## Return the type of builder
+##
+def get_type():
+	return "compiler"
+
+##
+## @brief Get builder input file type
+## @return List of extention supported
+##
+def get_input_type():
+	return ["mm", "MM"]
+
+##
+## @brief Get builder output file type
+## @return List of extention supported
+##
+def get_output_type():
+	return ["o"]
+
+##
+## @brief Commands for running gcc to compile a m++ file in object file.
+##
+def compile(file, binary, target, depancy, flags, path, name, basic_folder):
+	file_src, file_dst, file_depend, file_cmd = target.file_generate_object(binary, name, basic_folder, file)
+	# create the command line befor requesting start:
+	cmd = [
+		target.xx,
+		"-o", file_dst,
+		target.arch,
+		target.sysroot,
+		target.global_include_cc]
+	try:
+		cmd.append(tools.add_prefix("-I",path["export"]))
+	except:
+		pass
+	try:
+		cmd.append(tools.add_prefix("-I",path["local"]))
+	except:
+		pass
+	try:
+		cmd.append(tools.add_prefix("-I",depancy.path))
+	except:
+		pass
+	try:
+		cmd.append(local_ref_on_builder_cpp.get_version_compilation_flags(flags, depancy.flags))
+	except:
+		pass
+	try:
+		cmd.append(target.global_flags_cc)
+	except:
+		pass
+	try:
+		cmd.append(target.global_flags_mm)
+	except:
+		pass
+	try:
+		cmd.append(depancy.flags["c"])
+	except:
+		pass
+	try:
+		cmd.append(depancy.flags["c++"])
+	except:
+		pass
+	try:
+		cmd.append(depancy.flags["mm"])
+	except:
+		pass
+	try:
+		cmd.append(flags["local"]["c"])
+	except:
+		pass
+	try:
+		cmd.append(flags["local"]["c++"])
+	except:
+		pass
+	try:
+		cmd.append(flags["local"]["mm"])
+	except:
+		pass
+	try:
+		cmd.append(flags["export"]["c"])
+	except:
+		pass
+	try:
+		cmd.append(flags["export"]["c++"])
+	except:
+		pass
+	try:
+		cmd.append(flags["export"]["mm"])
+	except:
+		pass
+	cmd.append("-c -MMD -MP")
+	cmd.append("-x objective-c++")
+	cmd.append(file_src)
+	# Create cmd line
+	cmdLine=tools.list_to_str(cmd)
+	# check the dependency for this file :
+	if False==depend.need_re_build(file_dst, file_src, file_depend, file_cmd, cmdLine):
+		return file_dst
+	tools.create_directory_of_file(file_dst)
+	comment = ["m++", name, "<==", file]
+	#process element
+	multiprocess.run_in_pool(cmdLine, comment, file_cmd)
+	return file_dst

lutin/builder/lutinBuilder_s.py

@@ -0,0 +1,33 @@
+##
+## ASM builder
+##
+from lutin import multiprocess
+from lutin import tools
+from lutin import depend
+
+##
+## Initialize the builder, if needed ... to get dependency between builder (for example)
+##
+def init():
+	pass
+
+##
+## Get the current builder type.
+## Return the type of builder
+##
+def get_type():
+	return "compiler"
+
+##
+## @brief Get builder input file type
+## @return List of extention supported
+##
+def get_input_type():
+	return ["s", "S"]
+
+##
+## @brief Get builder output file type
+## @return List of extention supported
+##
+def get_output_type():
+	return ["o"]

lutin/debug.py

@@ -8,8 +8,6 @@
 ##
 
 import os
-import thread
-import lutinMultiprocess
 import threading
 import re
 
@@ -108,9 +106,10 @@ def error(input, threadID=-1, force=False, crash=True):
 		print(color_red + "[ERROR] " + input + color_default)
 		debugLock.release()
 	if crash==True:
-		lutinMultiprocess.error_occured()
+		from . import multiprocess
+		multiprocess.error_occured()
 		if threadID != -1:
-			thread.interrupt_main()
+			threading.interrupt_main()
 		exit(-1)
 		#os_exit(-1)
 		#raise "error happend"

lutin/depend.py

@@ -6,11 +6,10 @@
 ##
 ## @license APACHE v2.0 (see license file)
 ##
-
 import os
-import lutinDebug as debug
-import lutinEnv as environement
-
+# Local import
+from . import debug
+from . import env
 
 def need_re_build(dst, src, dependFile=None, file_cmd="", cmdLine=""):
 	debug.extreme_verbose("Resuest check of dependency of :")
@@ -19,7 +18,7 @@ def need_re_build(dst, src, dependFile=None, file_cmd="", cmdLine=""):
 	debug.extreme_verbose("		dept='" + str(dependFile) + "'")
 	debug.extreme_verbose("		cmd='" + str(file_cmd) + "'")
 	# if force mode selected ==> just force rebuild ...
-	if environement.get_force_mode():
+	if env.get_force_mode():
 		debug.extreme_verbose("			==> must rebuild (force mode)")
 		return True
 	
@@ -118,7 +117,7 @@ def need_re_package(dst, srcList, mustHaveSrc, file_cmd="", cmdLine=""):
 		return False
 	
 	# if force mode selected ==> just force rebuild ...
-	if environement.get_force_mode():
+	if env.get_force_mode():
 		debug.extreme_verbose("			==> must re-package (force mode)")
 		return True
 	

lutin/env.py

@@ -7,7 +7,8 @@
 ## @license APACHE v2.0 (see license file)
 ##
 
-import lutinDebug as debug
+# Local import
+from . import debug
 
 
 

lutin/heritage.py

@@ -6,10 +6,10 @@
 ##
 ## @license APACHE v2.0 (see license file)
 ##
-
 import sys
 import copy
-import lutinDebug as debug
+# Local import
+from . import debug
 
 
 def append_to_list(listout, list):
@@ -26,13 +26,7 @@ def append_to_list(listout, list):
 
 class HeritageList:
 	def __init__(self, heritage = None):
-		self.flags_ld=[]
-		self.flags_cc=[]
-		self.flags_xx=[]
-		self.flags_m=[]
-		self.flags_mm=[]
-		self.flags_xx_version=1999
-		self.flags_cc_version=1989
+		self.flags={}
 		# sources list:
 		self.src=[]
 		self.path=[]
@@ -42,13 +36,14 @@ class HeritageList:
 			self.add_heritage(heritage)
 	
 	def add_heritage(self, heritage):
-		if type(heritage) == type(None) or heritage.name == "":
+		if    type(heritage) == type(None) \
+		   or heritage.name == "":
 			return
 		for element in self.listHeritage:
 			if element.name == heritage.name:
 				return
 		self.listHeritage.append(heritage)
-		self.regenerateTree()
+		self.regenerate_tree()
 		
 	def add_heritage_list(self, heritage_list):
 		if type(heritage_list) == type(None):
@@ -60,16 +55,10 @@ class HeritageList:
 					find = True
 			if find == False:
 				self.listHeritage.append(herit)
-		self.regenerateTree()
+		self.regenerate_tree()
 	
-	def regenerateTree(self):
-		self.flags_ld=[]
-		self.flags_cc=[]
-		self.flags_xx=[]
-		self.flags_xx_version=1999
-		self.flags_xx_version=1989
-		self.flags_m=[]
-		self.flags_mm=[]
+	def regenerate_tree(self):
+		self.flags={}
 		# sources list:
 		self.src=[]
 		self.path=[]
@@ -102,17 +91,28 @@ class HeritageList:
 		for element in self.listHeritage:
 			debug.verbose("	" + element.name + " " + str(element.depends))
 		for element in reversed(self.listHeritage):
-			append_to_list(self.flags_ld, element.flags_ld)
-			append_to_list(self.flags_cc, element.flags_cc)
-			append_to_list(self.flags_xx, element.flags_xx)
-			append_to_list(self.flags_m, element.flags_m)
-			append_to_list(self.flags_mm, element.flags_mm)
+			for flags in element.flags:
+				if flags in ["c-version", "c++-version"]:
+					continue
+				value = element.flags[flags]
+				if flags not in self.flags:
+					self.flags[flags] = value
+				else:
+					append_to_list(self.flags[flags], value)
 			append_to_list(self.path, element.path)
 			append_to_list(self.src, element.src)
-			if self.flags_xx_version < element.flags_xx_version:
-				self.flags_xx_version = element.flags_xx_version
-			if self.flags_cc_version < element.flags_cc_version:
-				self.flags_cc_version = element.flags_cc_version
+			if "c-version" in element.flags:
+				ver = element.flags["c-version"]
+				if "c-version" in self.flags:
+					if self.flags["c-version"] > ver:
+						ver = self.flags["c-version"]
+				self.flags["c-version"] = ver
+			if "c++-version" in element.flags:
+				ver = element.flags["c++-version"]
+				if "c++-version" in self.flags:
+					if self.flags["c++-version"] > ver:
+						ver = self.flags["c++-version"]
+				self.flags["c++-version"] = ver
 
 
 class heritage:
@@ -121,13 +121,7 @@ class heritage:
 		self.depends=[]
 		## Remove all variable to prevent error of multiple definition
 		# all the parameter that the upper classe need when build
-		self.flags_ld=[]
-		self.flags_cc=[]
-		self.flags_xx=[]
-		self.flags_xx_version=1999
-		self.flags_cc_version=1989
-		self.flags_m=[]
-		self.flags_mm=[]
+		self.flags={}
 		# sources list:
 		self.src=[]
 		self.path=[]
@@ -138,33 +132,13 @@ class heritage:
 			# all the parameter that the upper classe need when build
 			self.name = module.name
 			self.depends = copy.deepcopy(module.depends)
-			self.flags_ld = module.export_flags_ld
-			self.flags_cc = module.export_flags_cc
-			self.flags_xx = module.export_flags_xx
-			self.flags_m = module.export_flags_m
-			self.flags_mm = module.export_flags_mm
-			self.path = module.export_path
-			self.flags_xx_version = module.xx_version_api
-			self.flags_cc_version = module.cc_version_api
+			# keep reference because the flags can change in time
+			self.flags = module.flags["export"]
+			self.path = module.path["export"]
 	
 	def add_depends(self, depend):
 		self.depends.append(depend)
 	
-	def add_flag_LD(self, list):
-		append_to_list(self.flags_ld, list)
-	
-	def add_flag_CC(self, list):
-		append_to_list(self.flags_cc, list)
-	
-	def add_flag_XX(self, list):
-		append_to_list(self.flags_xx, list)
-	
-	def add_flag_M(self, list):
-		append_to_list(self.flags_m, list)
-	
-	def add_flag_MM(self, list):
-		append_to_list(self.flags_mm, list)
-	
 	def add_import_path(self, list):
 		append_to_list(self.path, list)
 	
@@ -180,16 +154,25 @@ class heritage:
 			return
 		if other.hasBeenUpdated == True:
 			self.hasBeenUpdated = True
-		self.add_flag_LD(other.flags_ld)
-		self.add_flag_CC(other.flags_cc)
-		self.add_flag_XX(other.flags_xx)
-		self.add_flag_M(other.flags_m)
-		self.add_flag_MM(other.flags_mm)
+		for flags in other.flags:
+			value = other.flags[flags]
+			if flags not in self.flags:
+				self.flags[flags] = value
+			else:
+				append_to_list(self.flags[flags], value)
 		self.add_import_path(other.path)
 		self.add_sources(other.src)
-		if self.flags_xx_version < module.xx_version_api:
-			self.flags_xx_version = module.xx_version_api
-		if self.flags_cc_version < module.cc_version_api:
-			self.flags_cc_version = module.cc_version_api
+		if "c-version" in module.flags["export"]:
+			ver = module.flags["export"]["c-version"]
+			if "c-version" in self.flags:
+				if self.flags["c-version"] > ver:
+					ver = self.flags["c-version"]
+			self.flags["c-version"] = ver
+		if "c++-version" in module.flags["export"]:
+			ver = module.flags["export"]["c++-version"]
+			if "c++-version" in self.flags:
+				if self.flags["c++-version"] > ver:
+					ver = self.flags["c++-version"]
+			self.flags["c++-version"] = ver
 
 

lutin/host.py

@@ -6,10 +6,10 @@
 ##
 ## @license APACHE v2.0 (see license file)
 ##
-
 import platform
 import sys
-import lutinDebug as debug
+# Local import
+from . import debug
 
 # print os.name # ==> 'posix'
 if platform.system() == "Linux":

lutin/image.py

@@ -6,13 +6,14 @@
 ##
 ## @license APACHE v2.0 (see license file)
 ##
-
-import lutinDebug as debug
-import lutinTools as tools
 import platform
 import os
-import lutinMultiprocess
-import lutinDepend as dependency
+# Local import
+from . import debug
+from . import tools
+from . import multiprocess
+from . import depend
+
 enableResizeImage = True
 try:
 	if platform.system() == "Darwin":
@@ -39,7 +40,7 @@ def resize(srcFile, destFile, x, y, cmd_file=None):
 	if os.path.exists(srcFile) == False:
 		debug.error("Request a resize an image that does not existed : '" + srcFile + "'")
 	cmd_line = "resize Image : " + srcFile + " ==> " + destFile + " newSize=(" + str(x) + "x" + str(y) + ")"
-	if False==dependency.need_re_build(destFile, srcFile, file_cmd=cmd_file , cmdLine=cmd_line):
+	if False==depend.need_re_build(destFile, srcFile, file_cmd=cmd_file , cmdLine=cmd_line):
 		return
 	# add cmdLine ...
 	x = get_pow_2_multiple(x)
@@ -89,4 +90,4 @@ def resize(srcFile, destFile, x, y, cmd_file=None):
 			tmpImage = im1.resize((x, y), Image.ANTIALIAS)
 			tools.create_directory_of_file(destFile)
 			tmpImage.save(destFile)
-	lutinMultiprocess.store_command(cmd_line, cmd_file)
+	multiprocess.store_command(cmd_line, cmd_file)

lutin/module.py

@@ -0,0 +1,630 @@
+#!/usr/bin/python
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+
+import sys
+import os
+import inspect
+import fnmatch
+# Local import
+from . import host
+from . import tools
+from . import debug
+from . import heritage
+from . import builder
+from . import multiprocess
+
+class Module:
+	
+	##
+	## @brief Module class represent all system needed for a specific
+	## 	module like 
+	## 		- type (bin/lib ...)
+	## 		- dependency
+	## 		- flags
+	## 		- files
+	## 		- ...
+	##
+	def __init__(self, file, moduleName, moduleType):
+		## Remove all variable to prevent error of multiple deffinition of the module ...
+		debug.verbose("Create a new module : '" + moduleName + "' TYPE=" + moduleType)
+		self.origin_file=''
+		self.origin_folder=''
+		# type of the module:
+		self.type='LIBRARY'
+		# Name of the module
+		self.name=moduleName
+		# Dependency list:
+		self.depends = []
+		# Dependency list (optionnal module):
+		self.depends_optionnal = []
+		self.depends_find = []
+		# Documentation list:
+		self.documentation = None
+		# export PATH
+		self.path = {"export":[],
+		             "local":[]
+		            }
+		self.flags = {"export":{},
+		              "local":{}
+		             }
+		"""
+		self.export_flags_ld = []
+		self.export_flags_cc = []
+		self.export_flags_xx = []
+		self.export_flags_m = []
+		self.export_flags_mm = []
+		# list of all flags:
+		self.flags_ld = []
+		self.flags_cc = []
+		self.flags_xx = []
+		self.flags_m = []
+		self.flags_mm = []
+		self.flags_s = []
+		self.flags_ar = []
+		"""
+		# sources list:
+		self.src = []
+		# copy files and folders:
+		self.imageToCopy = []
+		self.files = []
+		self.folders = []
+		self.isbuild = False
+		
+		## end of basic INIT ...
+		if    moduleType == 'BINARY' \
+		   or moduleType == 'LIBRARY' \
+		   or moduleType == 'PACKAGE' \
+		   or moduleType == 'PREBUILD':
+			self.type=moduleType
+		else :
+			debug.error('for module "%s"' %moduleName)
+			debug.error('    ==> error : "%s" ' %moduleType)
+			raise 'Input value error'
+		self.origin_file = file;
+		self.origin_folder = tools.get_current_path(self.origin_file)
+		self.local_heritage = heritage.heritage(self)
+		
+		self.package_prop = { "COMPAGNY_TYPE" : set(""),
+		                      "COMPAGNY_NAME" : set(""),
+		                      "COMPAGNY_NAME2" : set(""),
+		                      "MAINTAINER" : set([]),
+		                      #"ICON" : set(""),
+		                      "SECTION" : set([]),
+		                      "PRIORITY" : set(""),
+		                      "DESCRIPTION" : set(""),
+		                      "VERSION" : set("0.0.0"),
+		                      "VERSION_CODE" : "",
+		                      "NAME" : set("no-name"), # name of the application
+		                      "ANDROID_MANIFEST" : "", # By default generate the manifest
+		                      "ANDROID_JAVA_FILES" : ["DEFAULT"], # when user want to create his own services and activities
+		                      "ANDROID_RESOURCES" : [],
+		                      "ANDROID_APPL_TYPE" : "APPL", # the other mode is "WALLPAPER" ... and later "WIDGET"
+		                      "ANDROID_WALLPAPER_PROPERTIES" : [], # To create properties of the wallpaper (no use of EWOL display)
+		                      "RIGHT" : [],
+		                      "ADMOD_POSITION" : "top"
+		                     }
+		self.sub_heritage_list = None
+	
+	##
+	## @brief add Some copilation flags for this module (and only this one)
+	##
+	def add_extra_compile_flags(self):
+		self.compile_flags('c', [
+			"-Wall",
+			"-Wsign-compare",
+			"-Wreturn-type",
+			#"-Wint-to-pointer-cast",
+			"-Wno-write-strings",
+			"-Woverloaded-virtual",
+			"-Wnon-virtual-dtor",
+			"-Wno-unused-variable"]);
+		#only for gcc : "-Wunused-variable", "-Wunused-but-set-variable",
+	
+	##
+	## @brief remove all unneeded warning on compilation ==> for extern libs ...
+	##
+	def remove_compile_warning(self):
+		self.compile_flags('c', [
+			"-Wno-int-to-pointer-cast"
+			]);
+		self.compile_flags('c++', [
+			"-Wno-c++11-narrowing"
+			])
+		# only for gcc :"-Wno-unused-but-set-variable"
+	
+	##
+	## @brief Commands for copying files
+	##
+	def image_to_staging(self, binary_name, target):
+		for source, destination, sizeX, sizeY in self.imageToCopy:
+			extension = source[source.rfind('.'):]
+			if     extension != ".png" \
+			   and extension != ".jpg" \
+			   and sizeX > 0:
+				debug.error("Can not manage image other than .png and jpg to resize : " + source);
+			displaySource = source
+			source = self.origin_folder + "/" + source
+			if destination == "":
+				destination = source[source.rfind('/')+1:]
+				debug.verbose("Regenerate Destination : '" + destination + "'")
+			file_cmd = target.generate_file(binary_name, self.name, self.origin_folder, destination, "image")[0]
+			if sizeX > 0:
+				debug.verbose("Image file : " + displaySource + " ==> " + destination + " resize=(" + str(sizeX) + "," + str(sizeY) + ")")
+				fileName, fileExtension = os.path.splitext(self.origin_folder+"/" + source)
+				target.add_image_staging(source, destination, sizeX, sizeY, file_cmd)
+			else:
+				debug.verbose("Might copy file : " + displaySource + " ==> " + destination)
+				target.add_file_staging(source, destination, file_cmd)
+	
+	##
+	## @brief Commands for copying files
+	##
+	def files_to_staging(self, binary_name, target):
+		for source, destination in self.files:
+			displaySource = source
+			source = self.origin_folder + "/" + source
+			if destination == "":
+				destination = source[source.rfind('/')+1:]
+				debug.verbose("Regenerate Destination : '" + destination + "'")
+			file_cmd = target.generate_file(binary_name, self.name, self.origin_folder, destination, "image")[0]
+			# TODO : when destination is missing ...
+			debug.verbose("Might copy file : " + displaySource + " ==> " + destination)
+			target.add_file_staging(source, destination, file_cmd)
+	
+	##
+	## @brief Commands for copying files
+	##
+	def folders_to_staging(self, binary_name, target):
+		for source, destination in self.folders:
+			debug.debug("Might copy folder : " + source + "==>" + destination)
+			tools.copy_anything_target(target, self.origin_folder + "/" + source, destination)
+	
+	# call here to build the module
+	def build(self, target, package_name):
+		# ckeck if not previously build
+		if target.is_module_build(self.name)==True:
+			if self.sub_heritage_list == None:
+				self.local_heritage = heritage.heritage(self)
+			return self.sub_heritage_list
+		# create the package heritage
+		self.local_heritage = heritage.heritage(self)
+		
+		if     package_name==None \
+		   and (    self.type=="BINARY" \
+		         or self.type=="PACKAGE" ) :
+			# this is the endpoint binary ...
+			package_name = self.name
+		else :
+			# TODO : Set it better ...
+			None
+		
+		# build dependency before
+		list_sub_file_needed_to_build = []
+		self.sub_heritage_list = heritage.HeritageList()
+		# optionnal dependency :
+		for dep, option, export in self.depends_optionnal:
+			inherit_list, isBuilt = target.build_optionnal(dep, package_name)
+			if isBuilt == True:
+				self.local_heritage.add_depends(dep);
+				# TODO : Add optionnal Flags ...
+				#     ==> do it really better ...
+				if export == False:
+					self.compile_flags(option[0], option[1]);
+				else:
+					self.add_export_flag(option[0], option[1]);
+			# add at the heritage list :
+			self.sub_heritage_list.add_heritage_list(inherit_list)
+		for dep in self.depends:
+			inherit_list = target.build(dep, package_name)
+			# add at the heritage list :
+			self.sub_heritage_list.add_heritage_list(inherit_list)
+		
+		# build local sources
+		for file in self.src:
+			#debug.info(" " + self.name + " <== " + file);
+			fileExt = file.split(".")[-1]
+			try:
+				tmp_builder = builder.get_builder(fileExt);
+				resFile = tmp_builder.compile(file,
+				                             package_name,
+				                             target,
+				                             self.sub_heritage_list,
+				                             flags = self.flags,
+				                             path = self.path,
+				                             name = self.name,
+				                             basic_folder = self.origin_folder)
+				list_sub_file_needed_to_build.append(resFile)
+			except ValueError:
+				debug.warning(" UN-SUPPORTED file format:  '" + self.origin_folder + "/" + file + "'")
+		
+		# when multiprocess availlable, we need to synchronize here ...
+		multiprocess.pool_synchrosize()
+		
+		# generate end point:
+		if self.type=='PREBUILD':
+			debug.print_element("Prebuild", self.name, "==>", "find")
+		elif self.type=='LIBRARY':
+			try:
+				tmp_builder = builder.get_builder_with_output("a");
+				resFile = tmp_builder.link(list_sub_file_needed_to_build,
+				                           package_name,
+				                           target,
+				                           self.sub_heritage_list,
+				                           name = self.name,
+				                           basic_folder = self.origin_folder)
+				self.local_heritage.add_sources(resFile)
+			except ValueError:
+				debug.error(" UN-SUPPORTED link format:  '.a'")
+		elif self.type=='BINARY':
+			try:
+				tmp_builder = builder.get_builder_with_output("bin");
+				resFile = tmp_builder.link(list_sub_file_needed_to_build,
+				                           package_name,
+				                           target,
+				                           self.sub_heritage_list,
+				                           name = self.name,
+				                           basic_folder = self.origin_folder)
+			except ValueError:
+				debug.error(" UN-SUPPORTED link format:  '.bin'")
+			# generate tree for this special binary
+			target.clean_module_tree()
+			self.build_tree(target, self.name)
+			target.copy_to_staging(self.name)
+		elif self.type=="PACKAGE":
+			if target.name=="Android":
+				# special case for android wrapper :
+				try:
+					tmp_builder = builder.get_builder_with_output("so");
+					resFile = tmp_builder.link(list_sub_file_needed_to_build,
+					                           package_name,
+					                           target,
+					                           self.sub_heritage_list,
+					                           name = "libewol",
+					                           basic_folder = self.origin_folder)
+				except ValueError:
+					debug.error(" UN-SUPPORTED link format:  '.so'")
+			else:
+				try:
+					tmp_builder = builder.get_builder_with_output("bin");
+					resFile = tmp_builder.link(list_sub_file_needed_to_build,
+					                           package_name,
+					                           target,
+					                           self.sub_heritage_list,
+					                           name = self.name,
+					                           basic_folder = self.origin_folder)
+				except ValueError:
+					debug.error(" UN-SUPPORTED link format:  'binary'")
+			target.clean_module_tree()
+			# generate tree for this special binary
+			self.build_tree(target, self.name)
+			target.copy_to_staging(self.name)
+			if target.endGeneratePackage==True:
+				# generate the package with his properties ...
+				target.make_package(self.name, self.package_prop, self.origin_folder + "/..")
+		else:
+			debug.error("Dit not know the element type ... (impossible case) type=" + self.type)
+			
+		self.sub_heritage_list.add_heritage(self.local_heritage)
+		# return local dependency ...
+		return self.sub_heritage_list
+	
+	# call here to build the module
+	def build_tree(self, target, package_name):
+		# ckeck if not previously build
+		if target.is_module_buildTree(self.name)==True:
+			return
+		debug.verbose("build tree of " + self.name)
+		# add all the elements (first added only one keep ==> permit to everload sublib element)
+		self.image_to_staging(package_name, target)
+		self.files_to_staging(package_name, target)
+		self.folders_to_staging(package_name, target)
+		#build tree of all submodules
+		for dep in self.depends:
+			inherit = target.build_tree(dep, package_name)
+	
+	
+	# call here to clean the module
+	def clean(self, target):
+		if self.type=='PREBUILD':
+			# nothing to add ==> just dependence
+			None
+		elif self.type=='LIBRARY':
+			# remove folder of the lib ... for this targer
+			folderbuild = target.get_build_folder(self.name)
+			debug.info("remove folder : '" + folderbuild + "'")
+			tools.remove_folder_and_sub_folder(folderbuild)
+		elif    self.type=='BINARY' \
+		     or self.type=='PACKAGE':
+			# remove folder of the lib ... for this targer
+			folderbuild = target.get_build_folder(self.name)
+			debug.info("remove folder : '" + folderbuild + "'")
+			tools.remove_folder_and_sub_folder(folderbuild)
+			folderStaging = target.get_staging_folder(self.name)
+			debug.info("remove folder : '" + folderStaging + "'")
+			tools.remove_folder_and_sub_folder(folderStaging)
+		else:
+			debug.error("Dit not know the element type ... (impossible case) type=" + self.type)
+	
+	def append_and_check(self, listout, newElement, order):
+		for element in listout:
+			if element==newElement:
+				return
+		listout.append(newElement)
+		if True==order:
+			listout.sort()
+	
+	def append_to_internalList2(self, listout, module, list, order=False):
+		# add list in the Map
+		if module not in listout:
+			listout[module] = []
+		# add elements...
+		self.append_to_internalList(listout[module], list, order)
+	
+	def append_to_internalList(self, listout, list, order=False):
+		if type(list) == type(str()):
+			self.append_and_check(listout, list, order)
+		else:
+			# mulyiple imput in the list ...
+			for elem in list:
+				self.append_and_check(listout, elem, order)
+	
+	def add_module_depend(self, list):
+		self.append_to_internalList(self.depends, list, True)
+	
+	def add_optionnal_module_depend(self, module_name, compilation_flags=["", ""], export=False):
+		self.append_and_check(self.depends_optionnal, [module_name, compilation_flags, export], True)
+	
+	def add_export_path(self, list):
+		self.append_to_internalList(self.path["export"], list)
+	
+	def add_path(self, list):
+		self.append_to_internalList(self.path["local"], list)
+	
+	def add_export_flag(self, type, list):
+		self.append_to_internalList2(self.flags["export"], type, list)
+	
+	# add the link flag at the module
+	def compile_flags(self, type, list):
+		self.append_to_internalList2(self.flags["local"], type, list)
+	
+	def compile_version_XX(self, version, same_as_api=True, gnu=False):
+		cpp_version_list = [1999, 2003, 2011, 2014]
+		if version not in cpp_version_list:
+			debug.error("can not select CPP version : " + str(version) + " not in " + str(cpp_version_list))
+		# select API version:
+		api_version = 1999
+		if same_as_api == True:
+			api_version = version
+		self.flags["local"]["c++-version"] = { "version":version,
+		                                       "gnu":gnu
+		                                     }
+		self.flags["export"]["c++-version"] = api_version
+		if gnu == True and same_as_api == True:
+			debug.warning("Can not propagate the gnu extention of the CPP vesion for API");
+	
+	def compile_version_CC(self, version, same_as_api=True, gnu=False):
+		c_version_list = [1989, 1990, 1999, 2011]
+		if version not in c_version_list:
+			debug.error("can not select C version : " + str(version) + " not in " + str(c_version_list))
+		# select API version:
+		api_version = 1999
+		if same_as_api == True:
+			api_version = version
+		self.flags["local"]["c-version"] = { "version":version,
+		                                     "gnu":gnu
+		                                   }
+		self.flags["export"]["c-version"] = api_version
+		if gnu == True and same_as_api == True:
+			debug.warning("Can not propagate the gnu extention of the C vesion for API");
+	
+	def add_src_file(self, list):
+		self.append_to_internalList(self.src, list, True)
+	
+	def copy_image(self, source, destination='', sizeX=-1, sizeY=-1):
+		self.imageToCopy.append([source, destination, sizeX, sizeY])
+	
+	def copy_file(self, source, destination=''):
+		self.files.append([source, destination])
+	
+	def copy_folder(self, source, destination=''):
+		self.folders.append([source, destination])
+	
+	def print_list(self, description, list):
+		if len(list) > 0:
+			print('        ' + str(description))
+			for elem in list:
+				print('            ' + str(elem))
+	
+	def display(self, target):
+		print('-----------------------------------------------')
+		print(' package : "' + self.name + "'")
+		print('-----------------------------------------------')
+		print('    type:"' + str(self.type) + "'")
+		print('    file:"' + str(self.origin_file) + "'")
+		print('    folder:"' + str(self.origin_folder) + "'")
+		
+		self.print_list('depends',self.depends)
+		self.print_list('depends_optionnal', self.depends_optionnal)
+		
+		for element,value in self.flags["local"]:
+			self.print_list('flags ' + element, value)
+		
+		for element,value in self.flags["export"]:
+			self.print_list('flags export ' + element, value)
+		
+		self.print_list('src',self.src)
+		self.print_list('files',self.files)
+		self.print_list('folders',self.folders)
+		self.print_list('export path',self.path["export"])
+		self.print_list('local  path',self.path["local"])
+	
+	def pkg_set(self, variable, value):
+		if "COMPAGNY_TYPE" == variable:
+			#	com : Commercial
+			#	net : Network??
+			#	org : Organisation
+			#	gov : Governement
+			#	mil : Military
+			#	edu : Education
+			#	pri : Private
+			#	museum : ...
+			if value not in ["com", "net", "org", "gov", "mil", "edu", "pri", "museum"]:
+				debug.error("can not set the value for this Input : '" + variable + "' : '" + value + "'")
+			else:
+				self.package_prop[variable] = value
+		elif "COMPAGNY_NAME" == variable:
+			self.package_prop[variable] = value
+			val2 = value.lower()
+			val2 = val2.replace(' ', '')
+			val2 = val2.replace('-', '')
+			val2 = val2.replace('_', '')
+			self.package_prop["COMPAGNY_NAME2"] = val2
+		elif "ICON" == variable:
+			self.package_prop[variable] = value
+		elif "MAINTAINER" == variable:
+			self.package_prop[variable] = value
+		elif "SECTION" == variable:
+			# project section : (must be separate by coma
+			#    refer to : http://packages.debian.org/sid/
+			#        admin cli-mono comm database debian-installer
+			#        debug doc editors electronics devel embedded
+			#        fonts games gnome gnu-r gnustep graphics
+			#        hamradio haskell httpd interpreters java
+			#        kde kernel libdevel libs lisp localization
+			#        mail math misc net news ocaml oldlibs otherosfs
+			#        perl php python ruby science shells sound tex
+			#        text utils vcs video virtual web x11 xfce zope ...
+			self.package_prop[variable] = value
+		elif "PRIORITY" == variable:
+			#list = ["required","important","standard","optional","extra"]
+			#if isinstance(value, list):
+			if value not in ["required", "important", "standard", "optional", "extra"]:
+				debug.error("can not set the value for this Input : '" + variable + "' : '" + value + "'")
+			else:
+				self.package_prop[variable] = value
+		elif "DESCRIPTION" == variable:
+			self.package_prop[variable] = value
+		elif "VERSION" == variable:
+			self.package_prop[variable] = value
+		elif "VERSION_CODE" == variable:
+			self.package_prop[variable] = value
+		elif "NAME" == variable:
+			self.package_prop[variable] = value
+		elif "ANDROID_MANIFEST" == variable:
+			self.package_prop[variable] = value
+		elif "ANDROID_JAVA_FILES" == variable:
+			self.package_prop[variable] = value
+		elif "RIGHT" == variable:
+			self.package_prop[variable] = value
+		elif "ANDROID_RESOURCES" == variable:
+			self.package_prop[variable] = value
+		elif "ANDROID_APPL_TYPE" == variable:
+			self.package_prop[variable] = value
+		elif "ADMOD_ID" == variable:
+			self.package_prop[variable] = value
+		elif "APPLE_APPLICATION_IOS_ID" == variable:
+			self.package_prop[variable] = value
+		elif "ADMOD_POSITION" == variable:
+			if value in ["top", "bottom"]:
+				self.package_prop[variable] = value
+			else:
+				debug.error("not know pkg element : '" + variable + "' with value : '" + value + "' must be [top|bottom]")
+		else:
+			debug.error("not know pkg element : '" + variable + "'")
+	
+	def pkg_add(self, variable, value):
+		# TODO : Check values...
+		self.package_prop[variable].append(value)
+	
+	def ext_project_add_module(self, target, projectMng, added_module = []):
+		if self.name in added_module:
+			return
+		added_module.append(self.name)
+		debug.verbose("add a module to the project generator :" + self.name)
+		debug.verbose("local path :" + self.origin_folder)
+		projectMng.add_files(self.name, self.origin_folder, self.src)
+		#projectMng.add_data_file(self.origin_folder, self.files)
+		#projectMng.add_data_folder(self.origin_folder, self.folders)
+		"""
+		for depend in self.depends:
+			target.project_add_module(depend, projectMng, added_module)
+		"""
+	
+	def create_project(self, target, projectMng):
+		projectMng.set_project_name(self.name)
+		self.ext_project_add_module(target, projectMng)
+		projectMng.generate_project_file()
+
+
+
+moduleList=[]
+__startModuleName="lutin_"
+
+def import_path(path):
+	global moduleList
+	matches = []
+	debug.debug('MODULE: Start find sub File : "%s"' %path)
+	for root, dirnames, filenames in os.walk(path):
+		tmpList = fnmatch.filter(filenames, __startModuleName + "*.py")
+		# Import the module :
+		for filename in tmpList:
+			debug.debug('Module:     Find a file : "%s"' %os.path.join(root, filename))
+			#matches.append(os.path.join(root, filename))
+			sys.path.append(os.path.dirname(os.path.join(root, filename)) )
+			moduleName = filename.replace('.py', '')
+			moduleName = moduleName.replace(__startModuleName, '')
+			debug.debug("MODULE:     Integrate module: '" + moduleName + "' from '" + os.path.join(root, filename) + "'")
+			moduleList.append([moduleName,os.path.join(root, filename)])
+
+def exist(target, name):
+	global moduleList
+	for mod in moduleList:
+		if mod[0] == name:
+			return True
+	return False
+
+def load_module(target, name):
+	global moduleList
+	for mod in moduleList:
+		if mod[0] == name:
+			sys.path.append(os.path.dirname(mod[1]))
+			debug.verbose("import module : '" + __startModuleName + name + "'")
+			theModule = __import__(__startModuleName + name)
+			#try:
+			tmpElement = theModule.create(target)
+			#except:
+			#tmpElement = None
+			#debug.warning(" no function 'create' in the module : " + mod[0] + " from:'" + mod[1] + "'")
+			if (tmpElement == None) :
+				debug.debug("Request load module '" + name + "' not define for this platform")
+			else:
+				target.add_module(tmpElement)
+
+def list_all_module():
+	global moduleList
+	tmpListName = []
+	for mod in moduleList:
+		tmpListName.append(mod[0])
+	return tmpListName
+
+def list_all_module_with_desc():
+	global moduleList
+	tmpList = []
+	for mod in moduleList:
+		sys.path.append(os.path.dirname(mod[1]))
+		theModule = __import__("lutin_" + mod[0])
+		try:
+			tmpdesc = theModule.get_desc()
+			tmpList.append([mod[0], tmpdesc])
+		except:
+			debug.warning("has no naeme : " + mod[0])
+			tmpList.append([mod[0], ""])
+	return tmpList
+
+

lutin/multiprocess.py

@@ -8,18 +8,23 @@
 ##
 
 import sys
-import lutinDebug as debug
 import threading
 import time
-import Queue
+import sys
+if sys.version_info >= (3, 0):
+	import queue
+else:
+	import Queue as queue
 import os
 import subprocess
-import lutinTools
-import lutinEnv
 import shlex
+# Local import
+from . import debug
+import tools
+from . import env
 
 queueLock = threading.Lock()
-workQueue = Queue.Queue()
+workQueue = queue.Queue()
 currentThreadWorking = 0
 threads = []
 # To know the first error arrive in the pool ==> to display all the time the same error file when multiple compilation
@@ -42,7 +47,7 @@ def store_command(cmdLine, file):
 	if     file != "" \
 	   and file != None:
 		# Create directory:
-		lutinTools.create_directory_of_file(file)
+		tools.create_directory_of_file(file)
 		# Store the command Line:
 		file2 = open(file, "w")
 		file2.write(cmdLine)
@@ -63,6 +68,9 @@ def run_command_direct(cmdLine):
 		debug.error("subprocess.CalledProcessError : " + str(args))
 	# launch the subprocess:
 	output, err = p.communicate()
+	if sys.version_info >= (3, 0):
+		output = output.decode("utf-8")
+		err = err.decode("utf-8")
 	# Check error :
 	if p.returncode == 0:
 		if output == None:
@@ -86,9 +94,12 @@ def run_command(cmdLine, storeCmdLine="", buildId=-1, file=""):
 		debug.error("subprocess.CalledProcessError : TODO ...")
 	# launch the subprocess:
 	output, err = p.communicate()
+	if sys.version_info >= (3, 0):
+		output = output.decode("utf-8")
+		err = err.decode("utf-8")
 	# Check error :
 	if p.returncode == 0:
-		debug.debug(lutinEnv.print_pretty(cmdLine))
+		debug.debug(env.print_pretty(cmdLine))
 		queueLock.acquire()
 		# TODO : Print the output all the time .... ==> to show warnings ...
 		if buildId >= 0 and (output != "" or err != ""):
@@ -103,7 +114,7 @@ def run_command(cmdLine, storeCmdLine="", buildId=-1, file=""):
 		exitFlag = True
 		# if No ID : Not in a multiprocess mode ==> just stop here
 		if buildId < 0:
-			debug.debug(lutinEnv.print_pretty(cmdLine), force=True)
+			debug.debug(env.print_pretty(cmdLine), force=True)
 			debug.print_compilator(output)
 			debug.print_compilator(err)
 			if p.returncode == 2:
@@ -256,7 +267,7 @@ def pool_synchrosize():
 			debug.error("Pool error occured ... (No return information on Pool)")
 			return
 		debug.error("Error in an pool element : [" + str(errorExecution["id"]) + "]", crash=False)
-		debug.debug(lutinEnv.print_pretty(errorExecution["cmd"]), force=True)
+		debug.debug(env.print_pretty(errorExecution["cmd"]), force=True)
 		debug.print_compilator(str(errorExecution["out"][0]))
 		debug.print_compilator(str(errorExecution["err"][0]))
 		if errorExecution["return"] == 2:

lutin/system.py

@@ -11,12 +11,10 @@ import sys
 import os
 import inspect
 import fnmatch
-import lutinDebug as debug
 import datetime
-import lutinTools
-import lutinModule as module
-import lutinImage
-import lutinHost
+# Local import
+from . import debug
+from . import module
 
 class System:
 	def __init__(self):
@@ -71,11 +69,11 @@ class System:
 def createModuleFromSystem(target, dict):
 	myModule = module.Module(dict["path"], dict["name"], 'PREBUILD')
 	
-	myModule.add_export_flag_CC(dict["system"].export_flags_cc)
-	myModule.add_export_flag_LD(dict["system"].export_flags_ld)
-	myModule.add_export_flag_XX(dict["system"].export_flags_xx)
-	myModule.add_export_flag_M(dict["system"].export_flags_m)
-	myModule.add_export_flag_MM(dict["system"].export_flags_mm)
+	myModule.add_export_flag('c', dict["system"].export_flags_cc)
+	myModule.add_export_flag('link', dict["system"].export_flags_ld)
+	myModule.add_export_flag('c++', dict["system"].export_flags_xx)
+	myModule.add_export_flag('m', dict["system"].export_flags_m)
+	myModule.add_export_flag('mm', dict["system"].export_flags_mm)
 	# add the currrent module at the 
 	return myModule
 

lutin/system/lutinSystem_IOs_CoreAudio.py

@@ -7,14 +7,14 @@
 ## @license APACHE v2.0 (see license file)
 ##
 
-import lutinDebug as debug
-import lutinSystem
-import lutinTools as tools
+from lutin import debug
+from lutin import system
+from lutin import tools
 import os
 
-class System(lutinSystem.System):
+class System(system.System):
 	def __init__(self):
-		lutinSystem.System.__init__(self)
+		system.System.__init__(self)
 		# create some HELP:
 		self.help="CoreAudio : Ios interface for audio (all time present, just system interface)"
 		self.valid = True

lutin/system/lutinSystem_Linux_alsa.py

@@ -7,14 +7,14 @@
 ## @license APACHE v2.0 (see license file)
 ##
 
-import lutinDebug as debug
-import lutinSystem
-import lutinTools as tools
+from lutin import debug
+from lutin import system
+from lutin import tools
 import os
 
-class System(lutinSystem.System):
+class System(system.System):
 	def __init__(self):
-		lutinSystem.System.__init__(self)
+		system.System.__init__(self)
 		# create some HELP:
 		self.help="ALSA : Advanced Linux Sound Architecture\n Can be install with the package:\n    - libasound2-dev"
 		# check if the library exist:

lutin/system/lutinSystem_Linux_boost.py

@@ -7,14 +7,14 @@
 ## @license APACHE v2.0 (see license file)
 ##
 
-import lutinDebug as debug
-import lutinSystem
-import lutinTools as tools
+from lutin import debug
+from lutin import system
+from lutin import tools
 import os
 
-class System(lutinSystem.System):
+class System(system.System):
 	def __init__(self):
-		lutinSystem.System.__init__(self)
+		system.System.__init__(self)
 		# create some HELP:
 		self.help="BOOST : Boost interface (need when we have not all c++ feature\n Can be install with the package:\n    - libboost-all-dev"
 		# check if the library exist:

lutin/system/lutinSystem_Linux_jack.py

@@ -7,14 +7,14 @@
 ## @license APACHE v2.0 (see license file)
 ##
 
-import lutinDebug as debug
-import lutinSystem
-import lutinTools as tools
+from lutin import debug
+from lutin import system
+from lutin import tools
 import os
 
-class System(lutinSystem.System):
+class System(system.System):
 	def __init__(self):
-		lutinSystem.System.__init__(self)
+		system.System.__init__(self)
 		# create some HELP:
 		self.help="JACK : Jack Low-Latency Audio Server\n Can be install with the package:\n    - libjack-jackd2-dev (new)\n    - libjack-dev (old)"
 		# check if the library exist:

lutin/system/lutinSystem_Linux_oss.py

@@ -7,14 +7,14 @@
 ## @license APACHE v2.0 (see license file)
 ##
 
-import lutinDebug as debug
-import lutinSystem
-import lutinTools as tools
+from lutin import debug
+from lutin import system
+from lutin import tools
 import os
 
-class System(lutinSystem.System):
+class System(system.System):
 	def __init__(self):
-		lutinSystem.System.__init__(self)
+		system.System.__init__(self)
 		# create some HELP:
 		self.help="OSS : Linux Open Sound System\n Can be install with the package:\n    - ... TODO ..."
 		# check if the library exist:

lutin/system/lutinSystem_Linux_pulse.py

@@ -7,14 +7,14 @@
 ## @license APACHE v2.0 (see license file)
 ##
 
-import lutinDebug as debug
-import lutinSystem
-import lutinTools as tools
+from lutin import debug
+from lutin import system
+from lutin import tools
 import os
 
-class System(lutinSystem.System):
+class System(system.System):
 	def __init__(self):
-		lutinSystem.System.__init__(self)
+		system.System.__init__(self)
 		# create some HELP:
 		self.help="PULSE : The Linux PulseAudio\n Can be install with the package:\n    - libpulse-dev"
 		# check if the library exist:

lutin/system/lutinSystem_Linux_z.py

@@ -7,18 +7,18 @@
 ## @license APACHE v2.0 (see license file)
 ##
 
-import lutinDebug as debug
-import lutinSystem
-import lutinTools as tools
+from lutin import debug
+from lutin import system
+from lutin import tools
 import os
 
-class System(lutinSystem.System):
+class System(system.System):
 	def __init__(self):
-		lutinSystem.System.__init__(self)
+		system.System.__init__(self)
 		# create some HELP:
 		self.help="Z : z library \n Can be install with the package:\n    - zlib1g-dev"
 		# check if the library exist:
-		if     not os.path.isfile("/usr/include/zlib.h"):
+		if not os.path.isfile("/usr/include/zlib.h"):
 			# we did not find the library reqiested (just return) (automaticly set at false)
 			return;
 		self.valid = True

lutin/system/lutinSystem_MacOs_CoreAudio.py

@@ -7,14 +7,14 @@
 ## @license APACHE v2.0 (see license file)
 ##
 
-import lutinDebug as debug
-import lutinSystem
-import lutinTools as tools
+from lutin import debug
+from lutin import system
+from lutin import tools
 import os
 
-class System(lutinSystem.System):
+class System(system.System):
 	def __init__(self):
-		lutinSystem.System.__init__(self)
+		system.System.__init__(self)
 		# create some HELP:
 		self.help="CoreAudio : MacOs interface for audio (all time present, just system interface)"
 		self.valid = True

lutin/system/lutinSystem_Windows_ds.py

@@ -7,14 +7,14 @@
 ## @license APACHE v2.0 (see license file)
 ##
 
-import lutinDebug as debug
-import lutinSystem
-import lutinTools as tools
+from lutin import debug
+from lutin import system
+from lutin import tools
 import os
 
-class System(lutinSystem.System):
+class System(system.System):
 	def __init__(self):
-		lutinSystem.System.__init__(self)
+		system.System.__init__(self)
 		# create some HELP:
 		self.help="DirectSound : Direct sound API for windows audio interface"
 		# check if the library exist:

lutin/target.py

@@ -11,15 +11,15 @@ import sys
 import os
 import inspect
 import fnmatch
-import lutinDebug as debug
-import lutinHeritage as heritage
 import datetime
-import lutinTools
-import lutinModule
-import lutinSystem
-import lutinImage
-import lutinHost
-import lutinMultiprocess as multiprocess
+# Local import
+from . import debug
+from . import heritage
+from . import tools
+from . import module
+from . import system
+from . import image
+from . import multiprocess
 
 class Target:
 	def __init__(self, name, config, arch):
@@ -120,6 +120,12 @@ class Target:
 	
 	def create_number_from_version_string(self, data):
 		list = data.split(".")
+		if len(list) == 1:
+			list.append("0")
+		if len(list) == 2:
+			list.append("0")
+		if len(list) > 3:
+			list = list[:3]
 		out = 0;
 		offset = 1000**(len(list)-1)
 		for elem in list:
@@ -149,7 +155,7 @@ class Target:
 		if ret == False:
 			debug.error("Can not get the g++/clang++ version ...")
 		self.xx_version = self.create_number_from_version_string(ret)
-		debug.debug(self.config["compilator"] + "++ version=" + str(ret) + " number=" + str(self.xx_version))
+		debug.verbose(self.config["compilator"] + "++ version=" + str(ret) + " number=" + str(self.xx_version))
 		
 		self.ld = self.cross + "ld"
 		self.nm = self.cross + "nm"
@@ -184,10 +190,10 @@ class Target:
 				debug.verbose("cmd file " + cmdFile)
 			if x == -1:
 				debug.verbose("must copy file : '" + source + "' ==> '" + dst + "'");
-				lutinTools.copy_file(source, baseFolder+"/"+dst, cmdFile)
+				tools.copy_file(source, baseFolder+"/"+dst, cmdFile)
 			else:
 				debug.verbose("resize image : '" + source + "' ==> '" + dst + "' size=(" + str(x) + "," + str(y) + ")");
-				lutinImage.resize(source, baseFolder+"/"+dst, x, y, cmdFile)
+				image.resize(source, baseFolder+"/"+dst, x, y, cmdFile)
 	
 	
 	def clean_module_tree(self):
@@ -237,32 +243,32 @@ class Target:
 		return list
 	
 	def get_final_folder(self):
-		return lutinTools.get_run_folder() + self.folder_out + self.folder_final
+		return tools.get_run_folder() + self.folder_out + self.folder_final
 	
 	def get_staging_folder(self, binaryName):
-		return lutinTools.get_run_folder() + self.folder_out + self.folder_staging + "/" + binaryName
+		return tools.get_run_folder() + self.folder_out + self.folder_staging + "/" + binaryName
 	
 	def get_staging_folder_data(self, binaryName):
 		return self.get_staging_folder(binaryName) + self.folder_data + "/" + binaryName
 	
 	def get_build_folder(self, moduleName):
-		return lutinTools.get_run_folder() + self.folder_out + self.folder_build + "/" + moduleName
+		return tools.get_run_folder() + self.folder_out + self.folder_build + "/" + moduleName
 	
 	def get_doc_folder(self, moduleName):
-		return lutinTools.get_run_folder() + self.folder_out + self.folder_doc + "/" + moduleName
+		return tools.get_run_folder() + self.folder_out + self.folder_doc + "/" + moduleName
 	
-	def is_module_build(self,module):
+	def is_module_build(self, my_module):
 		for mod in self.buildDone:
-			if mod == module:
+			if mod == my_module:
 				return True
-		self.buildDone.append(module)
+		self.buildDone.append(my_module)
 		return False
 	
-	def is_module_buildTree(self,module):
+	def is_module_buildTree(self, my_module):
 		for mod in self.buildTreeDone:
-			if mod == module:
+			if mod == my_module:
 				return True
-		self.buildTreeDone.append(module)
+		self.buildTreeDone.append(my_module)
 		return False
 	
 	def add_module(self, newModule):
@@ -280,16 +286,16 @@ class Target:
 	"""
 	
 	def build_tree(self, name, packagesName):
-		for module in self.moduleList:
-			if module.name == name:
-				module.build_tree(self, packagesName)
+		for mod in self.moduleList:
+			if mod.name == name:
+				mod.build_tree(self, packagesName)
 				return
 		debug.error("request to build tree on un-existant module name : '" + name + "'")
 	
 	def clean(self, name):
-		for module in self.moduleList:
-			if module.name == name:
-				module.clean(self)
+		for mod in self.moduleList:
+			if mod.name == name:
+				mod.clean(self)
 				return
 		debug.error("request to clean an un-existant module name : '" + name + "'")
 	
@@ -298,32 +304,32 @@ class Target:
 			if elem.name == name:
 				return True
 		if optionnal == False:
-			lutinModule.load_module(self, name)
+			module.load_module(self, name)
 			return True
 		else:
 			# TODO : Check internal module and system module ...
 			# need to import the module (or the system module ...)
-			exist = lutinSystem.exist(name, self.name)
+			exist = system.exist(name, self.name)
 			if exist == True:
-				lutinSystem.load(self, name, self.name)
+				system.load(self, name, self.name)
 				return True;
 			# try to find in the local Modules:
-			exist = lutinModule.exist(self, name)
+			exist = module.exist(self, name)
 			if exist == True:
-				lutinModule.load_module(self, name)
+				module.load_module(self, name)
 				return True;
 			else:
 				return False;
 	
 	def load_all(self):
-		listOfAllTheModule = lutinModule.list_all_module()
+		listOfAllTheModule = module.list_all_module()
 		for modName in listOfAllTheModule:
 			self.load_if_needed(modName)
 	
 	def project_add_module(self, name, projectMng, addedModule):
-		for module in self.moduleList:
-			if module.name == name:
-				module.ext_project_add_module(self, projectMng, addedModule)
+		for mod in self.moduleList:
+			if mod.name == name:
+				mod.ext_project_add_module(self, projectMng, addedModule)
 				return
 	
 	def build_optionnal(self, moduleName, packagesName=None):
@@ -363,7 +369,7 @@ class Target:
 				mod.clean(self)
 		else:
 			# get the action an the module ....
-			gettedElement = name.split("-")
+			gettedElement = name.split("?")
 			moduleName = gettedElement[0]
 			if len(gettedElement)>=2:
 				actionName = gettedElement[1]
@@ -371,7 +377,7 @@ class Target:
 				actionName = "build"
 			debug.verbose("requested : " + moduleName + "-" + actionName)
 			if actionName == "install":
-				self.build(moduleName + "-build")
+				self.build(moduleName + "?build")
 				self.install_package(moduleName)
 			elif actionName == "uninstall":
 				self.un_install_package(moduleName)
@@ -401,17 +407,17 @@ __startTargetName="lutinTarget_"
 def import_path(path):
 	global targetList
 	matches = []
-	debug.debug('Start find sub File : "%s"' %path)
+	debug.debug('TARGET: Start find sub File : "%s"' %path)
 	for root, dirnames, filenames in os.walk(path):
 		tmpList = fnmatch.filter(filenames, __startTargetName + "*.py")
 		# Import the module :
 		for filename in tmpList:
-			debug.debug('    Find a file : "%s"' %os.path.join(root, filename))
+			debug.debug('TARGET:     Find a file : "%s"' %os.path.join(root, filename))
 			#matches.append(os.path.join(root, filename))
 			sys.path.append(os.path.dirname(os.path.join(root, filename)) )
 			targetName = filename.replace('.py', '')
 			targetName = targetName.replace(__startTargetName, '')
-			debug.debug("integrate module: '" + targetName + "' from '" + os.path.join(root, filename) + "'")
+			debug.debug("TARGET:     integrate module: '" + targetName + "' from '" + os.path.join(root, filename) + "'")
 			targetList.append([targetName,os.path.join(root, filename)])
 
 
@@ -430,6 +436,7 @@ def load_target(name, config):
 			#create the target
 			tmpTarget = theTarget.Target(config)
 			return tmpTarget
+	raise KeyError("No entry for : " + name)
 
 def list_all_target():
 	global targetList

lutin/target/lutinTarget_Android.py

@@ -8,17 +8,16 @@
 ##
 
 
-import lutinDebug as debug
-import lutinTarget
-import lutinTools as tools
-import lutinHost
-import lutinImage
-import lutinMultiprocess
-import lutinHost
+from lutin import debug
+from lutin import target
+from lutin import tools
+from lutin import image
+from lutin import multiprocess
+from lutin import host
 import os
 import sys
 
-class Target(lutinTarget.Target):
+class Target(target.Target):
 	def __init__(self, config):
 		#processor type selection (auto/arm/ppc/x86)
 		if config["arch"] == "auto":
@@ -28,7 +27,7 @@ class Target(lutinTarget.Target):
 			config["bus-size"] = "32"
 		
 		arch = ""#"ARMv7"
-		lutinTarget.Target.__init__(self, "Android", config, arch)
+		target.Target.__init__(self, "Android", config, arch)
 		
 		self.folder_ndk = os.getenv('PROJECT_NDK', "AUTO")
 		self.folder_sdk = os.getenv('PROJECT_SDK', "AUTO")
@@ -56,8 +55,8 @@ class Target(lutinTarget.Target):
 		
 		
 		tmpOsVal = "64"
-		gccVersion = "4.8"
-		if lutinHost.BUS_SIZE==64:
+		gccVersion = "4.9"
+		if host.BUS_SIZE==64:
 			tmpOsVal = "_64"
 		if self.config["compilator"] == "clang":
 			self.set_cross_base(self.folder_ndk + "/toolchains/llvm-3.3/prebuilt/linux-x86_64/bin/")
@@ -334,7 +333,7 @@ class Target(lutinTarget.Target):
 		tools.create_directory_of_file(self.get_staging_folder(pkgName) + "/res/drawable/icon.png");
 		if     "ICON" in pkgProperties.keys() \
 		   and pkgProperties["ICON"] != "":
-			lutinImage.resize(pkgProperties["ICON"], self.get_staging_folder(pkgName) + "/res/drawable/icon.png", 256, 256)
+			image.resize(pkgProperties["ICON"], self.get_staging_folder(pkgName) + "/res/drawable/icon.png", 256, 256)
 		else:
 			# to be sure that we have all time a resource ...
 			tmpFile = open(self.get_staging_folder(pkgName) + "/res/drawable/plop.txt", 'w')
@@ -596,7 +595,7 @@ class Target(lutinTarget.Target):
 		          + "-S " + self.get_staging_folder(pkgName) + "/res/ " \
 		          + adModResouceFolder \
 		          + "-J " + self.get_staging_folder(pkgName) + "/src/ "
-		lutinMultiprocess.run_command(cmdLine)
+		multiprocess.run_command(cmdLine)
 		#aapt  package -f -M ${manifest.file} -F ${packaged.resource.file} -I ${path.to.android-jar.library} 
 		#      -S ${android-resource-directory} [-m -J ${folder.to.output.the.R.java}]
 		
@@ -637,7 +636,7 @@ class Target(lutinTarget.Target):
 		          + filesString \
 		          + self.file_finalAbstraction + " "  \
 		          + self.get_staging_folder(pkgName) + "/src/R.java "
-		lutinMultiprocess.run_command(cmdLine)
+		multiprocess.run_command(cmdLine)
 		
 		debug.print_element("pkg", ".dex", "<==", "*.class")
 		cmdLine = androidToolPath + "dx " \
@@ -648,7 +647,7 @@ class Target(lutinTarget.Target):
 		if "ADMOD_ID" in pkgProperties:
 			cmdLine += self.folder_sdk + "/extras/google/google_play_services/libproject/google-play-services_lib/libs/google-play-services.jar "
 		
-		lutinMultiprocess.run_command(cmdLine)
+		multiprocess.run_command(cmdLine)
 		
 		debug.print_element("pkg", ".apk", "<==", ".dex, assets, .so, res")
 		#builderDebug="-agentlib:jdwp=transport=dt_socket,server=y,address=8050,suspend=y "
@@ -664,18 +663,13 @@ class Target(lutinTarget.Target):
 		          + " -z " + self.get_staging_folder(pkgName) + "/resources.res " \
 		          + " -f " + self.get_staging_folder(pkgName) + "/build/" + pkgNameApplicationName + ".dex " \
 		          + " -rf " + self.get_staging_folder(pkgName) + "/data "
-		lutinMultiprocess.run_command(cmdLine)
+		multiprocess.run_command(cmdLine)
 		
 		# doc :
 		# http://developer.android.com/tools/publishing/app-signing.html
 		# Create a key for signing your application:
 		# keytool -genkeypair -v -keystore AndroidKey.jks -storepass Pass__AndroidDebugKey -alias alias__AndroidDebugKey -keypass PassKey__AndroidDebugKey -keyalg RSA -validity 36500
 		if self.config["mode"] == "debug":
-			tmpFile = open("tmpPass.boo", 'w')
-			tmpFile.write("Pass__AndroidDebugKey\n")
-			tmpFile.write("PassKey__AndroidDebugKey\n")
-			tmpFile.flush()
-			tmpFile.close()
 			debug.print_element("pkg", ".apk(signed debug)", "<==", ".apk (not signed)")
 			# verbose mode : 
 			#debugOption = "-verbose -certs "
@@ -684,9 +678,11 @@ class Target(lutinTarget.Target):
 			    + debugOption \
 			    + "-keystore " + tools.get_current_path(__file__) + "/AndroidDebugKey.jks " \
 			    + " -sigalg SHA1withRSA -digestalg SHA1 " \
+			    + " -storepass Pass__AndroidDebugKey " \
+			    + " -keypass PassKey__AndroidDebugKey " \
 			    + self.get_staging_folder(pkgName) + "/build/" + pkgNameApplicationName + "-unalligned.apk " \
-			    + " alias__AndroidDebugKey < tmpPass.boo"
-			lutinMultiprocess.run_command(cmdLine)
+			    + " alias__AndroidDebugKey"
+			multiprocess.run_command(cmdLine)
 			tmpFile = open("tmpPass.boo", 'w')
 			tmpFile.write("\n")
 			tmpFile.flush()
@@ -699,12 +695,12 @@ class Target(lutinTarget.Target):
 			    + " -sigalg SHA1withRSA -digestalg SHA1 " \
 			    + self.get_staging_folder(pkgName) + "/build/" + pkgNameApplicationName + "-unalligned.apk " \
 			    + " " + pkgNameApplicationName
-			lutinMultiprocess.run_command(cmdLine)
+			multiprocess.run_command(cmdLine)
 			cmdLine = "jarsigner " \
 			    + " -verify -verbose -certs " \
 			    + " -sigalg SHA1withRSA -digestalg SHA1 " \
 			    + self.get_staging_folder(pkgName) + "/build/" + pkgNameApplicationName + "-unalligned.apk "
-			lutinMultiprocess.run_command(cmdLine)
+			multiprocess.run_command(cmdLine)
 		
 		debug.print_element("pkg", ".apk(aligned)", "<==", ".apk (not aligned)")
 		tools.remove_file(self.get_staging_folder(pkgName) + "/" + pkgNameApplicationName + ".apk")
@@ -712,7 +708,7 @@ class Target(lutinTarget.Target):
 		cmdLine = androidToolPath + "zipalign 4 " \
 		          + self.get_staging_folder(pkgName) + "/build/" + pkgNameApplicationName + "-unalligned.apk " \
 		          + self.get_staging_folder(pkgName) + "/" + pkgNameApplicationName + ".apk "
-		lutinMultiprocess.run_command(cmdLine)
+		multiprocess.run_command(cmdLine)
 		
 		# copy file in the final stage :
 		tools.copy_file(self.get_staging_folder(pkgName) + "/" + pkgNameApplicationName + ".apk",
@@ -728,7 +724,7 @@ class Target(lutinTarget.Target):
 			pkgNameApplicationName += "debug"
 		cmdLine = self.folder_sdk + "/platform-tools/adb install -r " \
 		          + self.get_staging_folder(pkgName) + "/" + pkgNameApplicationName + ".apk "
-		lutinMultiprocess.run_command(cmdLine)
+		multiprocess.run_command(cmdLine)
 	
 	def un_install_package(self, pkgName):
 		debug.debug("------------------------------------------------------------------------")
@@ -738,13 +734,14 @@ class Target(lutinTarget.Target):
 		if self.config["mode"] == "debug":
 			pkgNameApplicationName += "debug"
 		cmdLine = self.folder_sdk + "/platform-tools/adb uninstall " + pkgNameApplicationName
-		RlutinMultiprocess.unCommand(cmdLine)
+		Rmultiprocess.unCommand(cmdLine)
 	
 	def Log(self, pkgName):
 		debug.debug("------------------------------------------------------------------------")
 		debug.info("logcat of android board")
 		debug.debug("------------------------------------------------------------------------")
+		debug.info("cmd: " + self.folder_sdk + "/platform-tools/adb shell logcat ")
 		cmdLine = self.folder_sdk + "/platform-tools/adb shell logcat "
-		lutinMultiprocess.run_command(cmdLine)
+		multiprocess.run_command(cmdLine)
 
 

lutin/target/lutinTarget_IOs.py

@@ -7,18 +7,18 @@
 ## @license APACHE v2.0 (see license file)
 ##
 
-import lutinDebug as debug
-import lutinTarget
-import lutinTools
-import lutinImage
+from lutin import debug
+from lutin import target
+from lutin import tools
+from lutin import image
 import os
 import stat
-import lutinMultiprocess
-import lutinHost
+from lutin import multiprocess
+from lutin import host
 import random
 import re
 
-class Target(lutinTarget.Target):
+class Target(target.Target):
 	def __init__(self, config):
 		if config["compilator"] == "gcc":
 			debug.info("compile only with clang for IOs");
@@ -37,7 +37,7 @@ class Target(lutinTarget.Target):
 		else:
 			arch="arm64" # for ipad air
 			#arch="armv7" # for Iphone 4
-		lutinTarget.Target.__init__(self, "IOs", config, arch)
+		target.Target.__init__(self, "IOs", config, arch)
 		if self.config["simulation"] == True:
 			self.set_cross_base("/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/")
 		else:
@@ -76,7 +76,7 @@ class Target(lutinTarget.Target):
 		#self.global_flags_m.append("-fmodules")
 
 	def get_staging_folder(self, binaryName):
-		return lutinTools.get_run_folder() + self.folder_out + self.folder_staging + "/" + binaryName + ".app/"
+		return tools.get_run_folder() + self.folder_out + self.folder_staging + "/" + binaryName + ".app/"
 	
 	def get_staging_folder_data(self, binaryName):
 		return self.get_staging_folder(binaryName) + self.folder_data + "/"
@@ -92,23 +92,23 @@ class Target(lutinTarget.Target):
 			# TODO : Do not regenerate if source resource is not availlable
 			# TODO : Add a colored background ...
 			debug.print_element("pkg", "iTunesArtwork.png", "<==", pkgProperties["ICON"])
-			lutinImage.resize(pkgProperties["ICON"], self.get_staging_folder(pkgName) + "/iTunesArtwork.png", 512, 512)
+			image.resize(pkgProperties["ICON"], self.get_staging_folder(pkgName) + "/iTunesArtwork.png", 512, 512)
 			debug.print_element("pkg", "iTunesArtwork@2x.png", "<==", pkgProperties["ICON"])
-			lutinImage.resize(pkgProperties["ICON"], self.get_staging_folder(pkgName) + "/iTunesArtwork@2x.png", 1024, 1024)
+			image.resize(pkgProperties["ICON"], self.get_staging_folder(pkgName) + "/iTunesArtwork@2x.png", 1024, 1024)
 			debug.print_element("pkg", "Icon-60@2x.png", "<==", pkgProperties["ICON"])
-			lutinImage.resize(pkgProperties["ICON"], self.get_staging_folder(pkgName) + "/Icon-60@2x.png", 120, 120)
+			image.resize(pkgProperties["ICON"], self.get_staging_folder(pkgName) + "/Icon-60@2x.png", 120, 120)
 			debug.print_element("pkg", "Icon-76.png", "<==", pkgProperties["ICON"])
-			lutinImage.resize(pkgProperties["ICON"], self.get_staging_folder(pkgName) + "/Icon-76.png", 76, 76)
+			image.resize(pkgProperties["ICON"], self.get_staging_folder(pkgName) + "/Icon-76.png", 76, 76)
 			debug.print_element("pkg", "Icon-76@2x.png", "<==", pkgProperties["ICON"])
-			lutinImage.resize(pkgProperties["ICON"], self.get_staging_folder(pkgName) + "/Icon-76@2x.png", 152, 152)
+			image.resize(pkgProperties["ICON"], self.get_staging_folder(pkgName) + "/Icon-76@2x.png", 152, 152)
 			debug.print_element("pkg", "Icon-Small-40.png", "<==", pkgProperties["ICON"])
-			lutinImage.resize(pkgProperties["ICON"], self.get_staging_folder(pkgName) + "/Icon-Small-40.png", 40, 40)
+			image.resize(pkgProperties["ICON"], self.get_staging_folder(pkgName) + "/Icon-Small-40.png", 40, 40)
 			debug.print_element("pkg", "Icon-Small-40@2x.png", "<==", pkgProperties["ICON"])
-			lutinImage.resize(pkgProperties["ICON"], self.get_staging_folder(pkgName) + "/Icon-Small-40@2x.png", 80, 80)
+			image.resize(pkgProperties["ICON"], self.get_staging_folder(pkgName) + "/Icon-Small-40@2x.png", 80, 80)
 			debug.print_element("pkg", "Icon-Small.png", "<==", pkgProperties["ICON"])
-			lutinImage.resize(pkgProperties["ICON"], self.get_staging_folder(pkgName) + "/Icon-Small.png", 29, 29)
+			image.resize(pkgProperties["ICON"], self.get_staging_folder(pkgName) + "/Icon-Small.png", 29, 29)
 			debug.print_element("pkg", "Icon-Small@2x.png", "<==", pkgProperties["ICON"])
-			lutinImage.resize(pkgProperties["ICON"], self.get_staging_folder(pkgName) + "/Icon-Small@2x.png", 58, 58)
+			image.resize(pkgProperties["ICON"], self.get_staging_folder(pkgName) + "/Icon-Small@2x.png", 58, 58)
 		
 		debug.print_element("pkg", "PkgInfo", "<==", "APPL????")
 		infoFile = self.get_staging_folder(pkgName) + "/PkgInfo"
@@ -227,7 +227,7 @@ class Target(lutinTarget.Target):
 		else:
 			cmdLine += " -platform iphoneos "
 		cmdLine += " -o " + self.get_staging_folder(pkgName) + "/" + "Info.plist"
-		lutinMultiprocess.run_command(cmdLine)
+		multiprocess.run_command(cmdLine)
 		"""
 		"""
 		
@@ -329,16 +329,16 @@ class Target(lutinTarget.Target):
 			# application signing :
 			debug.print_element("pkg(signed)", "pkg", "<==", "Signing application")
 			iosDevelopperKeyFile = ".iosKey.txt"
-			if lutinTools.file_size(iosDevelopperKeyFile) < 10:
+			if tools.file_size(iosDevelopperKeyFile) < 10:
 				debug.error("To sign an application we need to have a signing key in the file '" + iosDevelopperKeyFile + "' \n it is represented like: 'iPhone Developer: Francis DUGENOUX (YRRQE5KGTH)'\n you can obtain it with : 'certtool y | grep \"Developer\"'")
-			signatureKey = lutinTools.file_read_data(iosDevelopperKeyFile)
+			signatureKey = tools.file_read_data(iosDevelopperKeyFile)
 			signatureKey = re.sub('\n', '', signatureKey)
 			cmdLine  = 'codesign  --force --sign '
 			# to get this key ;    certtool y | grep "Developer"
 			cmdLine += ' "' + signatureKey + '" '
 			cmdLine += ' --entitlements ' + self.get_build_folder(pkgName) + '/worddown.xcent'
 			cmdLine += ' ' + self.get_staging_folder(pkgName)
-			lutinMultiprocess.run_command(cmdLine)
+			multiprocess.run_command(cmdLine)
 			
 			# --force --sign "iPhone Developer: Edouard DUPIN (SDFGSDFGSDFG)"
 			#		  --resource-rules=/Users/edouarddupin/Library/Developer/Xcode/DerivedData/worddown-cmuvjchgtiteexdiacyqoexsyadg/Build/Products/Debug-iphoneos/worddown.app/ResourceRules.plist
@@ -357,18 +357,18 @@ class Target(lutinTarget.Target):
 		debug.info("Install package '" + pkgName + "'")
 		debug.debug("------------------------------------------------------------------------")
 		if self.sumulator == False:
-			if lutinTools.file_size("ewol/ios-deploy/ios-deploy") == 0:
+			if tools.file_size("ewol/ios-deploy/ios-deploy") == 0:
 				debug.print_element("tool", "ios-deploy", "<==", "external sources")
 				cmdLine = 'cd ewol/ios-deploy ; make ; cd ../.. '
-				lutinMultiprocess.run_command(cmdLine)
-			if lutinTools.file_size("ewol/ios-deploy/ios-deploy") == 0:
+				multiprocess.run_command(cmdLine)
+			if tools.file_size("ewol/ios-deploy/ios-deploy") == 0:
 				debug.error("Can not create ios-deploy external software ...")
 			debug.print_element("deploy", "iphone/ipad", "<==", "aplication")
 			cmdLine = './ewol/ios-deploy/ios-deploy --bundle ' + self.get_staging_folder(pkgName)
-			lutinMultiprocess.run_command(cmdLine)
+			multiprocess.run_command(cmdLine)
 		else:
 			simulatorIdFile = ".iosSimutatorId_" + pkgName + ".txt"
-			if lutinTools.file_size(simulatorIdFile) < 10:
+			if tools.file_size(simulatorIdFile) < 10:
 				#create the file:
 				tmpFile = open(simulatorIdFile, 'w')
 				tmpFile.write(self.createRandomNumber(8))
@@ -382,17 +382,17 @@ class Target(lutinTarget.Target):
 				tmpFile.write(self.createRandomNumber(12))
 				tmpFile.flush()
 				tmpFile.close()
-			simulatorId = lutinTools.file_read_data(simulatorIdFile)
+			simulatorId = tools.file_read_data(simulatorIdFile)
 			home = os.path.expanduser("~")
 			destinationFolderBase = home + "/Library/Application\\ Support/iPhone\\ Simulator/7.1/Applications/" + simulatorId
 			destinationFolder = home + "/Library/Application Support/iPhone Simulator/7.1/Applications/" + simulatorId + "/" + pkgName + ".app"
 			destinationFolder2 = home + "/Library/Application\\ Support/iPhone\\ Simulator/7.1/Applications/" + simulatorId + "/" + pkgName + ".app"
 			debug.info("install in simulator : " + destinationFolder)
-			lutinTools.create_directory_of_file(destinationFolder + "/plop.txt")
+			tools.create_directory_of_file(destinationFolder + "/plop.txt")
 			cmdLine = "cp -rf " + self.get_staging_folder(pkgName) + " " + destinationFolder2
-			lutinMultiprocess.run_command(cmdLine)
+			multiprocess.run_command(cmdLine)
 			cmdLine = "touch " + destinationFolderBase
-			lutinMultiprocess.run_command(cmdLine)
+			multiprocess.run_command(cmdLine)
 			
 		#sudo dpkg -i $(TARGET_OUT_FINAL)/$(PROJECT_NAME) + self.suffix_package
 	
@@ -404,7 +404,7 @@ class Target(lutinTarget.Target):
 			debug.warning("not implemented")
 		else:
 			simulatorIdFile = ".iosSimutatorId_" + pkgName + ".txt"
-			if lutinTools.file_size(simulatorIdFile) < 10:
+			if tools.file_size(simulatorIdFile) < 10:
 				debug.warning("Can not get simulation O_ID : " + simulatorIdFile)
 		
 		#sudo dpkg -r $(TARGET_OUT_FINAL)/$(PROJECT_NAME) + self.suffix_package
@@ -414,18 +414,18 @@ class Target(lutinTarget.Target):
 		debug.info("log of iOs board")
 		debug.debug("------------------------------------------------------------------------")
 		if self.sumulator == False:
-			if lutinTools.file_size("ewol/ios-deploy/ios-deploy") == 0:
+			if tools.file_size("ewol/ios-deploy/ios-deploy") == 0:
 				debug.print_element("tool", "ios-deploy", "<==", "external sources")
 				cmdLine = 'cd ewol/ios-deploy ; make ; cd ../.. '
-				lutinMultiprocess.run_command(cmdLine)
-			if lutinTools.file_size("ewol/ios-deploy/ios-deploy") == 0:
+				multiprocess.run_command(cmdLine)
+			if tools.file_size("ewol/ios-deploy/ios-deploy") == 0:
 				debug.error("Can not create ios-deploy external software ...")
 			debug.print_element("deploy", "iphone/ipad", "<==", "aplication")
 			cmdLine = './ewol/ios-deploy/ios-deploy --debug --bundle ' + self.get_staging_folder(pkgName)
-			lutinMultiprocess.run_command(cmdLine)
+			multiprocess.run_command(cmdLine)
 		else:
 			cmdLine = "tail -f ~/Library/Logs/iOS\ Simulator/7.1/system.log"
-			lutinMultiprocess.run_command(cmdLine)
+			multiprocess.run_command(cmdLine)
 
 
 

lutin/target/lutinTarget_Linux.py

@@ -7,31 +7,30 @@
 ## @license APACHE v2.0 (see license file)
 ##
 
-import lutinDebug as debug
-import lutinTarget
-import lutinTools as tools
+from lutin import debug
+from lutin import target
+from lutin import tools
 import os
 import stat
 import re
-import lutinMultiprocess
-import lutinHost
+from lutin import host
 
-class Target(lutinTarget.Target):
+class Target(target.Target):
 	def __init__(self, config):
 		#processor type selection (auto/arm/ppc/x86)
 		if config["arch"] == "auto":
 			config["arch"] = "x86"
 		#bus size selection (auto/32/64)
 		if config["bus-size"] == "auto":
-			config["bus-size"] = str(lutinHost.BUS_SIZE)
-		lutinTarget.Target.__init__(self, "Linux", config, "")
+			config["bus-size"] = str(host.BUS_SIZE)
+		target.Target.__init__(self, "Linux", config, "")
 		if self.config["bus-size"] == "64":
 			# 64 bits
-			if lutinHost.BUS_SIZE != 64:
+			if host.BUS_SIZE != 64:
 				self.global_flags_cc.append("-m64")
 		else:
 			# 32 bits
-			if lutinHost.BUS_SIZE != 32:
+			if host.BUS_SIZE != 32:
 				self.global_flags_cc.append("-m32")
 	
 	def generate_list_separate_coma(self, list):

lutin/target/lutinTarget_MacOs.py

@@ -7,24 +7,24 @@
 ## @license APACHE v2.0 (see license file)
 ##
 
-import lutinDebug as debug
-import lutinTarget
-import lutinTools
-import lutinHost
+from lutin import debug
+from lutin import target
+from lutin import tools
+from lutin import host
 import os
 import stat
 
-class Target(lutinTarget.Target):
+class Target(target.Target):
 	def __init__(self, config):
 		#processor type selection (auto/arm/ppc/x86)
 		if config["arch"] == "auto":
 			config["arch"] = "x86"
 		#bus size selection (auto/32/64)
 		if config["bus-size"] == "auto":
-			config["bus-size"] = str(lutinHost.BUS_SIZE)
+			config["bus-size"] = str(host.BUS_SIZE)
 		# http://biolpc22.york.ac.uk/pub/linux-mac-cross/
 		# http://devs.openttd.org/~truebrain/compile-farm/apple-darwin9.txt
-		lutinTarget.Target.__init__(self, "MacOs", config, "")
+		target.Target.__init__(self, "MacOs", config, "")
 		
 		self.folder_bin="/MacOS"
 		self.folder_lib="/lib"
@@ -38,7 +38,7 @@ class Target(lutinTarget.Target):
 		
 	
 	def get_staging_folder(self, binaryName):
-		return lutinTools.get_run_folder() + self.folder_out + self.folder_staging + "/" + binaryName + ".app/Contents/"
+		return tools.get_run_folder() + self.folder_out + self.folder_staging + "/" + binaryName + ".app/Contents/"
 	
 	def get_staging_folder_data(self, binaryName):
 		return self.get_staging_folder(binaryName) + self.folder_data + "/"
@@ -50,7 +50,7 @@ class Target(lutinTarget.Target):
 		
 		if    "ICON" in pkgProperties.keys() \
 		   and pkgProperties["ICON"] != "":
-			lutinTools.copy_file(pkgProperties["ICON"], self.get_staging_folder_data(pkgName) + "/icon.icns", force=True)
+			tools.copy_file(pkgProperties["ICON"], self.get_staging_folder_data(pkgName) + "/icon.icns", force=True)
 		
 		# http://www.sandroid.org/imcross/#Deployment
 		infoFile=self.get_staging_folder(pkgName) + "/Info.plist"

lutin/target/lutinTarget_Windows.py

@@ -7,15 +7,16 @@
 ## @license APACHE v2.0 (see license file)
 ##
 
-import lutinDebug as debug
-import lutinTarget
-import lutinTools
-import lutinHost
+from lutin import debug
+from lutin import target
+from lutin import tools
+from lutin import host
 import os
 import stat
 import sys
+from lutin import zip
 
-class Target(lutinTarget.Target):
+class Target(target.Target):
 	def __init__(self, config):
 		if config["compilator"] != "gcc":
 			debug.error("Windows does not support '" + config["compilator"] + "' compilator ... availlable : [gcc]")
@@ -26,14 +27,14 @@ class Target(lutinTarget.Target):
 			config["arch"] = "x86"
 		#bus size selection (auto/32/64)
 		if config["bus-size"] == "auto":
-			config["bus-size"] = str(lutinHost.BUS_SIZE)
+			config["bus-size"] = str(host.BUS_SIZE)
 		
-		lutinTarget.Target.__init__(self, "Windows", config, "")
+		target.Target.__init__(self, "Windows", config, "")
 		
 		# on windows board the basic path is not correct 
 		# TODO : get external PATH for the minGW path
 		# TODO : Set the cyngwin path ...
-		if lutinHost.OS == "Windows":
+		if host.OS == "Windows":
 			self.set_cross_base("c:\\MinGW\\bin\\")
 			sys.path.append("c:\\MinGW\\bin" )
 			os.environ['PATH'] += ";c:\\MinGW\\bin\\"
@@ -67,7 +68,54 @@ class Target(lutinTarget.Target):
 		debug.debug("------------------------------------------------------------------------")
 		debug.info("Generate package '" + pkgName + "'")
 		debug.debug("------------------------------------------------------------------------")
-		debug.warning("    ==> TODO")
+		debug.print_element("zip", "data.zip", "<==", "data/*")
+		zipPath = self.get_staging_folder(pkgName) + "/data.zip"
+		zip.create_zip(self.get_staging_folder_data(pkgName), zipPath)
+		
+		binPath = self.get_staging_folder(pkgName) + "/" + self.folder_bin + "/" + pkgName + self.suffix_binary
+		binSize = tools.file_size(binPath)
+		debug.info("binarysize : " + str(binSize/1024) + " ko ==> " + str(binSize) + " octets")
+		
+		#now we create a simple bundle binary ==> all file is stored in one file ...
+		self.get_staging_folder(pkgName)
+		finalBin = self.get_final_folder() + "/" + pkgName + self.suffix_binary
+		tools.create_directory_of_file(finalBin);
+		debug.print_element("pkg", finalBin, "<==", pkgName + self.suffix_binary)
+		#open output file
+		tmpFile = open(finalBin, 'wb')
+		# read all executable binary
+		dataExecutable = tools.file_read_data(binPath, binary=True)
+		# wrte binary to the output
+		tmpFile.write(dataExecutable)
+		#align data in the 32 Bytes position (prevent zip align error)
+		residualToAllign = 32 + 32 - (len(dataExecutable) - int(len(dataExecutable)/32)*32)
+		for iii in range(0,residualToAllign):
+			tmpFile.write(b'\0');
+		positionOfZip = len(dataExecutable) + residualToAllign;
+		# write a control TAG
+		tmpFile.write(b'***START DATA***');
+		# write all the zip file
+		debug.print_element("pkg", finalBin, "<==", "data.zip")
+		dataData = tools.file_read_data(zipPath, binary=True)
+		tmpFile.write(dataData)
+		#align data in the 32 Bytes position (to be fun"
+		tmpLen = len(dataData) + positionOfZip
+		residualToAllign = 32 + 32 - (tmpLen - int(tmpLen/32)*32)
+		for iii in range(0,residualToAllign):
+			tmpFile.write(b'\0');
+		# write a control TAG
+		tmpFile.write(b'*** END DATA ***');
+		# reserved AREA (can be use later for extra value ...)
+		for iii in range(0,8):
+			tmpFile.write(b'\0');
+		# write the position of the zip file (TAG position)
+		h = '{0:016x}'.format(positionOfZip)
+		s = ('0'*(len(h) % 2) + h).decode('hex')
+		tmpFile.write(s)
+		# package is done
+		tmpFile.flush()
+		tmpFile.close()
+		debug.verbose("zip position=" + str(positionOfZip) + " = 0x" + h)
 	
 	def install_package(self, pkgName):
 		debug.debug("------------------------------------------------------------------------")

lutin/tools.py

@@ -10,11 +10,11 @@
 import os
 import shutil
 import errno
-import lutinDebug as debug
 import fnmatch
-import lutinMultiprocess
-import lutinDepend as dependency
-
+# Local import
+from . import debug
+from . import depend
+import multiprocess
 
 """
 	
@@ -56,10 +56,13 @@ def file_size(path):
 	statinfo = os.stat(path)
 	return statinfo.st_size
 
-def file_read_data(path):
+def file_read_data(path, binary=False):
 	if not os.path.isfile(path):
 		return ""
-	file = open(path, "r")
+	if binary == True:
+		file = open(path, "rb")
+	else:
+		file = open(path, "r")
 	data_file = file.read()
 	file.close()
 	return data_file
@@ -98,12 +101,12 @@ def copy_file(src, dst, cmd_file=None, force=False):
 		debug.error("Request a copy a file that does not existed : '" + src + "'")
 	cmd_line = "copy \"" + src + "\" \"" + dst + "\""
 	if     force == False \
-	   and dependency.need_re_build(dst, src, file_cmd=cmd_file , cmdLine=cmd_line) == False:
+	   and depend.need_re_build(dst, src, file_cmd=cmd_file , cmdLine=cmd_line) == False:
 		return
 	debug.print_element("copy file", src, "==>", dst)
 	create_directory_of_file(dst)
 	shutil.copyfile(src, dst)
-	lutinMultiprocess.store_command(cmd_line, cmd_file)
+	multiprocess.store_command(cmd_line, cmd_file)
 
 
 def copy_anything(src, dst):

lutin/zip.py

@@ -0,0 +1,30 @@
+#!/usr/bin/python
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+import platform
+import os
+import zipfile
+# Local import
+from . import debug
+from . import tools
+
+
+def create_zip(path, outputFile):
+	debug.debug("Create Zip : '" + outputFile + "'")
+	debug.debug("    from '" + path + "'")
+	basePathlen = len(path)
+	zf = zipfile.ZipFile(outputFile, mode='w')
+	for root, dirnames, filenames in os.walk(path):
+		# List all files :
+		for filename in filenames:
+			file = os.path.join(root, filename)
+			debug.verbose("    ADD zip = " + str(file))
+			zf.write(file, file[basePathlen:])
+	zf.close()
+	
+

lutinModule.py

@@ -1,904 +0,0 @@
-#!/usr/bin/python
-##
-## @author Edouard DUPIN
-##
-## @copyright 2012, Edouard DUPIN, all right reserved
-##
-## @license APACHE v2.0 (see license file)
-##
-
-import sys
-import os
-import inspect
-import fnmatch
-import lutinModule as module
-import lutinHost as host
-import lutinTools
-import lutinDebug as debug
-import lutinHeritage as heritage
-import lutinDepend as dependency
-import lutinMultiprocess
-import lutinEnv
-
-class Module:
-	
-	##
-	## @brief Module class represent all system needed for a specific
-	## 	module like 
-	## 		- type (bin/lib ...)
-	## 		- dependency
-	## 		- flags
-	## 		- files
-	## 		- ...
-	##
-	def __init__(self, file, moduleName, moduleType):
-		## Remove all variable to prevent error of multiple deffinition of the module ...
-		debug.verbose("Create a new module : '" + moduleName + "' TYPE=" + moduleType)
-		self.originFile=''
-		self.originFolder=''
-		# type of the module:
-		self.type='LIBRARY'
-		# Name of the module
-		self.name=moduleName
-		# Dependency list:
-		self.depends = []
-		# Dependency list (optionnal module):
-		self.depends_optionnal = []
-		self.depends_find = []
-		# Documentation list:
-		self.documentation = None
-		# export PATH
-		self.export_path = []
-		self.local_path = []
-		self.export_flags_ld = []
-		self.export_flags_cc = []
-		self.export_flags_xx = []
-		self.export_flags_m = []
-		self.export_flags_mm = []
-		# list of all flags:
-		self.flags_ld = []
-		self.flags_cc = []
-		self.flags_xx = []
-		self.flags_m = []
-		self.flags_mm = []
-		self.flags_s = []
-		self.flags_ar = []
-		# sources list:
-		self.src = []
-		# copy files and folders:
-		self.imageToCopy = []
-		self.files = []
-		self.folders = []
-		self.isbuild = False
-		# CPP version:
-		self.xx_version = 1999
-		self.xx_version_api = 1999
-		self.cc_version = 1989
-		self.cc_version_api = 1989
-		## end of basic INIT ...
-		if    moduleType == 'BINARY' \
-		   or moduleType == 'LIBRARY' \
-		   or moduleType == 'PACKAGE' \
-		   or moduleType == 'PREBUILD':
-			self.type=moduleType
-		else :
-			debug.error('for module "%s"' %moduleName)
-			debug.error('    ==> error : "%s" ' %moduleType)
-			raise 'Input value error'
-		self.originFile = file;
-		self.originFolder = lutinTools.get_current_path(self.originFile)
-		self.localHeritage = heritage.heritage(self)
-		
-		self.packageProp = { "COMPAGNY_TYPE" : set(""),
-		                     "COMPAGNY_NAME" : set(""),
-		                     "COMPAGNY_NAME2" : set(""),
-		                     "MAINTAINER" : set([]),
-		                     #"ICON" : set(""),
-		                     "SECTION" : set([]),
-		                     "PRIORITY" : set(""),
-		                     "DESCRIPTION" : set(""),
-		                     "VERSION" : set("0.0.0"),
-		                     "VERSION_CODE" : "",
-		                     "NAME" : set("no-name"), # name of the application
-		                     "ANDROID_MANIFEST" : "", # By default generate the manifest
-		                     "ANDROID_JAVA_FILES" : ["DEFAULT"], # when user want to create his own services and activities
-		                     "ANDROID_RESOURCES" : [],
-		                     "ANDROID_APPL_TYPE" : "APPL", # the other mode is "WALLPAPER" ... and later "WIDGET"
-		                     "ANDROID_WALLPAPER_PROPERTIES" : [], # To create properties of the wallpaper (no use of EWOL display)
-		                     "RIGHT" : [],
-		                     "ADMOD_POSITION" : "top"
-		                    }
-		self.subHeritageList = None
-	
-	##
-	## @brief add Some copilation flags for this module (and only this one)
-	##
-	def add_extra_compile_flags(self):
-		self.compile_flags_CC([
-			"-Wall",
-			"-Wsign-compare",
-			"-Wreturn-type",
-			#"-Wint-to-pointer-cast",
-			"-Wno-write-strings",
-			"-Woverloaded-virtual",
-			"-Wnon-virtual-dtor",
-			"-Wno-unused-variable"]);
-		#only for gcc : "-Wunused-variable", "-Wunused-but-set-variable",
-	
-	##
-	## @brief remove all unneeded warning on compilation ==> for extern libs ...
-	##
-	def remove_compile_warning(self):
-		self.compile_flags_CC([
-			"-Wno-int-to-pointer-cast"
-			]);
-		self.compile_flags_XX([
-			"-Wno-c++11-narrowing"
-			])
-		# only for gcc :"-Wno-unused-but-set-variable"
-	
-	##
-	## @brief Commands for running gcc to compile a m++ file.
-	##
-	def compile_mm_to_o(self, file, binary, target, depancy):
-		file_src, file_dst, file_depend, file_cmd = target.file_generate_object(binary,self.name,self.originFolder,file)
-		xx_version = max(self.xx_version, depancy.flags_xx_version)
-		if xx_version == 2014:
-			debug.error("not supported flags for X14 ...");
-			local_xx_version_flags=["-std=c++14", "-D__CPP_VERSION__=2014"]
-		elif xx_version == 2011:
-			local_xx_version_flags=["-std=c++11", "-D__CPP_VERSION__=2011"]
-		elif xx_version == 2003:
-			local_xx_version_flags=["-std=c++03", "-D__CPP_VERSION__=2003"]
-		else:
-			local_xx_version_flags=["-D__CPP_VERSION__=1999"]
-		
-		# create the command line befor requesting start:
-		cmdLine=lutinTools.list_to_str([
-			target.xx,
-			"-o", file_dst,
-			target.arch,
-			target.sysroot,
-			target.global_include_cc,
-			lutinTools.add_prefix("-I",self.export_path),
-			lutinTools.add_prefix("-I",self.local_path),
-			lutinTools.add_prefix("-I",depancy.path),
-			local_xx_version_flags,
-			target.global_flags_cc,
-			target.global_flags_mm,
-			depancy.flags_cc,
-			depancy.flags_mm,
-			self.flags_mm,
-			self.flags_cc,
-			self.export_flags_mm,
-			self.export_flags_cc,
-			"-c -MMD -MP",
-			"-x objective-c++",
-			file_src])
-		# check the dependency for this file :
-		if False==dependency.need_re_build(file_dst, file_src, file_depend, file_cmd, cmdLine):
-			return file_dst
-		lutinTools.create_directory_of_file(file_dst)
-		comment = ["m++", self.name, "<==", file]
-		#process element
-		lutinMultiprocess.run_in_pool(cmdLine, comment, file_cmd)
-		return file_dst
-	
-	##
-	## @brief Commands for running gcc to compile a m file.
-	##
-	def compile_m_to_o(self, file, binary, target, depancy):
-		file_src, file_dst, file_depend, file_cmd = target.file_generate_object(binary,self.name,self.originFolder,file)
-		cc_version = max(self.cc_version, depancy.flags_cc_version)
-		if cc_version == 2011:
-			local_cc_version_flags=["-std=c11", "-D__C_VERSION__=2011"]
-		elif cc_version == 1999:
-			local_cc_version_flags=["-std=c99", "-D__C_VERSION__=1999"]
-		elif cc_version == 1990:
-			local_cc_version_flags=["-std=c90", "-D__C_VERSION__=1990"]
-		else:
-			local_cc_version_flags=["-std=c89", "-D__C_VERSION__=1989"]
-		
-		# create the command line befor requesting start:
-		cmdLine=lutinTools.list_to_str([
-			target.cc,
-			"-o", file_dst ,
-			target.arch,
-			target.sysroot,
-			target.global_include_cc,
-			lutinTools.add_prefix("-I",self.export_path),
-			lutinTools.add_prefix("-I",self.local_path),
-			lutinTools.add_prefix("-I",depancy.path),
-			local_cc_version_flags,
-			target.global_flags_cc,
-			target.global_flags_m,
-			depancy.flags_cc,
-			depancy.flags_m,
-			self.flags_m,
-			self.flags_cc,
-			self.export_flags_m,
-			self.export_flags_cc,
-			"-c -MMD -MP",
-			"-x objective-c",
-			file_src])
-		# check the dependency for this file :
-		if False==dependency.need_re_build(file_dst, file_src, file_depend, file_cmd, cmdLine):
-			return file_dst
-		lutinTools.create_directory_of_file(file_dst)
-		comment = ["m", self.name, "<==", file]
-		#process element
-		lutinMultiprocess.run_in_pool(cmdLine, comment, file_cmd)
-		return file_dst
-	
-	##
-	## @brief Commands for running gcc to compile a C++ file.
-	##
-	def compile_xx_to_o(self, file, binary, target, depancy):
-		file_src, file_dst, file_depend, file_cmd = target.file_generate_object(binary,self.name,self.originFolder,file)
-		xx_version = max(self.xx_version, depancy.flags_xx_version)
-		if xx_version == 2014:
-			debug.error("not supported flags for X14 ...");
-			local_xx_version_flags=["-std=c++14", "-D__CPP_VERSION__=2014"]
-		elif xx_version == 2011:
-			local_xx_version_flags=["-std=c++11", "-D__CPP_VERSION__=2011"]
-		elif xx_version == 2003:
-			local_xx_version_flags=["-std=c++03", "-D__CPP_VERSION__=2003"]
-		else:
-			local_xx_version_flags=["-D__CPP_VERSION__=1999"]
-		
-		# create the command line befor requesting start:
-		cmdLine=lutinTools.list_to_str([
-			target.xx,
-			"-o", file_dst,
-			target.arch,
-			target.sysroot,
-			target.global_include_cc,
-			lutinTools.add_prefix("-I",self.export_path),
-			lutinTools.add_prefix("-I",self.local_path),
-			lutinTools.add_prefix("-I",depancy.path),
-			local_xx_version_flags,
-			target.global_flags_cc,
-			target.global_flags_xx,
-			depancy.flags_cc,
-			depancy.flags_xx,
-			self.flags_xx,
-			self.flags_cc,
-			self.export_flags_xx,
-			self.export_flags_cc,
-			" -c -MMD -MP",
-			file_src])
-		# check the dependency for this file :
-		if False==dependency.need_re_build(file_dst, file_src, file_depend, file_cmd, cmdLine):
-			return file_dst
-		lutinTools.create_directory_of_file(file_dst)
-		comment = ["c++", self.name, "<==", file]
-		#process element
-		lutinMultiprocess.run_in_pool(cmdLine, comment, file_cmd)
-		return file_dst
-	
-	##
-	## @brief Commands for running gcc to compile a C file.
-	##
-	def compile_cc_to_o(self, file, binary, target, depancy):
-		file_src, file_dst, file_depend, file_cmd = target.file_generate_object(binary,self.name,self.originFolder,file)
-		cc_version = max(self.cc_version, depancy.flags_cc_version)
-		if cc_version == 2011:
-			local_cc_version_flags=["-std=c11", "-D__C_VERSION__=2011"]
-		elif cc_version == 1999:
-			local_cc_version_flags=["-std=c99", "-D__C_VERSION__=1999"]
-		elif cc_version == 1990:
-			local_cc_version_flags=["-std=c90", "-D__C_VERSION__=1990"]
-		else:
-			local_cc_version_flags=["-std=c89", "-D__C_VERSION__=1989"]
-		
-		# create the command line befor requesting start:
-		cmdLine=lutinTools.list_to_str([
-			target.cc,
-			"-o", file_dst,
-			target.arch,
-			target.sysroot,
-			target.global_include_cc,
-			lutinTools.add_prefix("-I",self.export_path),
-			lutinTools.add_prefix("-I",self.local_path),
-			lutinTools.add_prefix("-I",depancy.path),
-			local_cc_version_flags,
-			target.global_flags_cc,
-			depancy.flags_cc,
-			self.flags_cc,
-			self.export_flags_cc,
-			" -c -MMD -MP",
-			file_src])
-		
-		# check the dependency for this file :
-		if False==dependency.need_re_build(file_dst, file_src, file_depend, file_cmd, cmdLine):
-			return file_dst
-		lutinTools.create_directory_of_file(file_dst)
-		comment = ["c", self.name, "<==", file]
-		# process element
-		lutinMultiprocess.run_in_pool(cmdLine, comment, file_cmd)
-		return file_dst
-	
-	
-	##
-	## @brief Commands for running ar.
-	##
-	def link_to_a(self, file, binary, target, depancy):
-		file_src, file_dst, file_depend, file_cmd = target.generate_file(binary, self.name,self.originFolder,file,"lib-static")
-		#$(Q)$(TARGET_AR) $(TARGET_GLOBAL_ARFLAGS) $(PRIVATE_ARFLAGS) $@ $(PRIVATE_ALL_OBJECTS)
-		cmdLine=lutinTools.list_to_str([
-			target.ar,
-			target.global_flags_ar,
-			self.flags_ar,
-			file_dst,
-			file_src])#,
-			#depancy.src])
-		
-		# check the dependency for this file :
-		if     False==dependency.need_re_package(file_dst, file_src, True, file_cmd, cmdLine) \
-		   and False==dependency.need_re_package(file_dst, depancy.src, False, file_cmd, cmdLine):
-			return file_dst
-		lutinTools.create_directory_of_file(file_dst)
-		debug.print_element("StaticLib", self.name, "==>", file_dst)
-		# explicitly remove the destination to prevent error ...
-		if os.path.exists(file_dst) and os.path.isfile(file_dst):
-			os.remove(file_dst)
-		lutinMultiprocess.run_command(cmdLine)
-		#$(Q)$(TARGET_RANLIB) $@
-		if target.ranlib != "":
-			cmdLineRanLib=lutinTools.list_to_str([
-				target.ranlib,
-				file_dst ])
-			lutinMultiprocess.run_command(cmdLineRanLib)
-		# write cmd line only after to prevent errors ...
-		lutinMultiprocess.store_command(cmdLine, file_cmd)
-		return file_dst
-	
-	
-	##
-	## @brief Commands for running gcc to link a shared library.
-	##
-	def link_to_so(self, file, binary, target, depancy, libName=""):
-		if libName=="":
-			libName = self.name
-		file_src, file_dst, file_depend, file_cmd = target.generate_file(binary, libName,self.originFolder,file,"lib-shared")
-		#create command Line
-		cmdLine=lutinTools.list_to_str([
-			target.xx,
-			"-o", file_dst,
-			target.global_sysroot,
-			target.arch,
-			"-shared",
-			file_src,
-			depancy.src,
-			self.flags_ld,
-			depancy.flags_ld,
-			target.global_flags_ld])
-		
-		# check the dependency for this file :
-		if     dependency.need_re_package(file_dst, file_src, True, file_cmd, cmdLine) == False \
-		   and dependency.need_re_package(file_dst, depancy.src, False, file_cmd, cmdLine) == False:
-			return tmpList[1]
-		lutinTools.create_directory_of_file(file_dst)
-		debug.print_element("SharedLib", libName, "==>", file_dst)
-		lutinMultiprocess.run_command(cmdLine)
-		if    target.config["mode"] == "release" \
-		   or lutinEnv.get_force_strip_mode()==True:
-			# get the file size of the non strip file
-			originSize = lutinTools.file_size(file_dst);
-			debug.print_element("SharedLib(strip)", libName, "", "")
-			cmdLineStrip=lutinTools.list_to_str([
-				target.strip,
-				file_dst])
-			lutinMultiprocess.run_command(cmdLineStrip)
-			# get the stip size of the binary
-			stripSize = lutinTools.file_size(file_dst)
-			debug.debug("file reduce size : " + str(originSize/1024) + "ko ==> " + str(stripSize/1024) + "ko")
-		# write cmd line only after to prevent errors ...
-		lutinMultiprocess.store_command(cmdLine, file_cmd)
-		#debug.print_element("SharedLib", self.name, "==>", tmpList[1])
-	
-	
-	##
-	## @brief Commands for running gcc to link an executable.
-	##
-	def link_to_bin(self, file, binary, target, depancy):
-		file_src, file_dst, file_depend, file_cmd = target.generate_file(binary, self.name,self.originFolder,file,"bin")
-		#create comdLine : 
-		cmdLine=lutinTools.list_to_str([
-			target.xx,
-			target.arch,
-			target.sysroot,
-			target.global_sysroot,
-			"-o", file_dst,
-			file_src,
-			depancy.src,
-			self.flags_ld,
-			depancy.flags_ld,
-			target.global_flags_ld])
-		# check the dependency for this file :
-		if False==dependency.need_re_package(file_dst, file_src, True, file_cmd, cmdLine) \
-				and False==dependency.need_re_package(file_dst, depancy.src, False, file_cmd, cmdLine):
-			return file_dst
-		lutinTools.create_directory_of_file(file_dst)
-		debug.print_element("Executable", self.name, "==>", file_dst)
-		
-		lutinMultiprocess.run_command(cmdLine)
-		if    "release"==target.config["mode"] \
-		   or lutinEnv.get_force_strip_mode()==True:
-			# get the file size of the non strip file
-			originSize = lutinTools.file_size(file_dst);
-			debug.print_element("Executable(strip)", self.name, "", "")
-			cmdLineStrip=lutinTools.list_to_str([
-				target.strip,
-				file_dst])
-			lutinMultiprocess.run_command(cmdLineStrip)
-			# get the stip size of the binary
-			stripSize = lutinTools.file_size(file_dst)
-			debug.debug("file reduce size : " + str(originSize/1024) + "ko ==> " + str(stripSize/1024) + "ko")
-		# write cmd line only after to prevent errors ...
-		lutinMultiprocess.store_command(cmdLine, file_cmd)
-		
-	
-	##
-	## @brief Commands for copying files
-	##
-	def image_to_staging(self, binaryName, target):
-		for source, destination, sizeX, sizeY in self.imageToCopy:
-			extension = source[source.rfind('.'):]
-			if     extension != ".png" \
-			   and extension != ".jpg" \
-			   and sizeX > 0:
-				debug.error("Can not manage image other than .png and jpg to resize : " + source);
-			displaySource = source
-			source = self.originFolder + "/" + source
-			if destination == "":
-				destination = source[source.rfind('/')+1:]
-				debug.verbose("Regenerate Destination : '" + destination + "'")
-			file_cmd = target.generate_file(binaryName, self.name, self.originFolder, destination, "image")[0]
-			if sizeX > 0:
-				debug.verbose("Image file : " + displaySource + " ==> " + destination + " resize=(" + str(sizeX) + "," + str(sizeY) + ")")
-				fileName, fileExtension = os.path.splitext(self.originFolder+"/" + source)
-				target.add_image_staging(source, destination, sizeX, sizeY, file_cmd)
-			else:
-				debug.verbose("Might copy file : " + displaySource + " ==> " + destination)
-				target.add_file_staging(source, destination, file_cmd)
-	
-	##
-	## @brief Commands for copying files
-	##
-	def files_to_staging(self, binaryName, target):
-		for source, destination in self.files:
-			displaySource = source
-			source = self.originFolder + "/" + source
-			if destination == "":
-				destination = source[source.rfind('/')+1:]
-				debug.verbose("Regenerate Destination : '" + destination + "'")
-			file_cmd = target.generate_file(binaryName, self.name, self.originFolder, destination, "image")[0]
-			# TODO : when destination is missing ...
-			debug.verbose("Might copy file : " + displaySource + " ==> " + destination)
-			target.add_file_staging(source, destination, file_cmd)
-	
-	##
-	## @brief Commands for copying files
-	##
-	def folders_to_staging(self, binaryName, target):
-		for source, destination in self.folders:
-			debug.debug("Might copy folder : " + source + "==>" + destination)
-			lutinTools.copy_anything_target(target, self.originFolder + "/" + source, destination)
-	
-	# call here to build the module
-	def build(self, target, packageName):
-		# ckeck if not previously build
-		if target.is_module_build(self.name)==True:
-			if self.subHeritageList == None:
-				self.localHeritage = heritage.heritage(self)
-			return self.subHeritageList
-		# create the packege heritage
-		self.localHeritage = heritage.heritage(self)
-		
-		if     packageName==None \
-		   and (    self.type=="BINARY" \
-		         or self.type=="PACKAGE" ) :
-			# this is the endpoint binary ...
-			packageName = self.name
-		else :
-			# TODO : Set it better ...
-			None
-		
-		# build dependency before
-		listSubFileNeededTobuild = []
-		self.subHeritageList = heritage.HeritageList()
-		# optionnal dependency :
-		for dep, option, export in self.depends_optionnal:
-			inheritList, isBuilt = target.build_optionnal(dep, packageName)
-			if isBuilt == True:
-				self.localHeritage.add_depends(dep);
-				# TODO : Add optionnal Flags ...
-				#     ==> do it really better ...
-				if export == False:
-					self.compile_flags_CC("-D"+option);
-				else:
-					self.add_export_flag_CC("-D"+option);
-			# add at the heritage list :
-			self.subHeritageList.add_heritage_list(inheritList)
-		for dep in self.depends:
-			inheritList = target.build(dep, packageName)
-			# add at the heritage list :
-			self.subHeritageList.add_heritage_list(inheritList)
-		
-		# build local sources
-		for file in self.src:
-			#debug.info(" " + self.name + " <== " + file);
-			fileExt = file.split(".")[-1]
-			if    fileExt in ["c", "C"]:
-				resFile = self.compile_cc_to_o(file, packageName, target, self.subHeritageList)
-				listSubFileNeededTobuild.append(resFile)
-			elif    fileExt in ["cpp", "CPP", "cxx", "CXX", "xx", "XX", "CC", "cc"]:
-				resFile = self.compile_xx_to_o(file, packageName, target, self.subHeritageList)
-				listSubFileNeededTobuild.append(resFile)
-			elif    fileExt in ["mm", "MM"]:
-				resFile = self.compile_mm_to_o(file, packageName, target, self.subHeritageList)
-				listSubFileNeededTobuild.append(resFile)
-			elif    fileExt in ["m", "M"]:
-				resFile = self.compile_m_to_o(file, packageName, target, self.subHeritageList)
-				listSubFileNeededTobuild.append(resFile)
-			else:
-				debug.warning(" UN-SUPPORTED file format:  '" + self.originFolder + "/" + file + "'")
-		# when multiprocess availlable, we need to synchronize here ...
-		lutinMultiprocess.pool_synchrosize()
-		
-		# generate end point:
-		if self.type=='PREBUILD':
-			debug.print_element("Prebuild", self.name, "==>", "find")
-		elif self.type=='LIBRARY':
-			resFile = self.link_to_a(listSubFileNeededTobuild, packageName, target, self.subHeritageList)
-			self.localHeritage.add_sources(resFile)
-		elif self.type=='BINARY':
-			resFile = self.link_to_bin(listSubFileNeededTobuild, packageName, target, self.subHeritageList)
-			# generate tree for this special binary
-			target.clean_module_tree()
-			self.build_tree(target, self.name)
-			target.copy_to_staging(self.name)
-		elif self.type=="PACKAGE":
-			if target.name=="Android":
-				# special case for android wrapper :
-				resFile = self.link_to_so(listSubFileNeededTobuild, packageName, target, self.subHeritageList, "libewol")
-			else:
-				resFile = self.link_to_bin(listSubFileNeededTobuild, packageName, target, self.subHeritageList)
-			target.clean_module_tree()
-			# generate tree for this special binary
-			self.build_tree(target, self.name)
-			target.copy_to_staging(self.name)
-			if target.endGeneratePackage==True:
-				# generate the package with his properties ...
-				target.make_package(self.name, self.packageProp, self.originFolder + "/..")
-		else:
-			debug.error("Dit not know the element type ... (impossible case) type=" + self.type)
-			
-		self.subHeritageList.add_heritage(self.localHeritage)
-		# return local dependency ...
-		return self.subHeritageList
-	
-	# call here to build the module
-	def build_tree(self, target, packageName):
-		# ckeck if not previously build
-		if target.is_module_buildTree(self.name)==True:
-			return
-		debug.verbose("build tree of " + self.name)
-		# add all the elements (first added only one keep ==> permit to everload sublib element)
-		self.image_to_staging(packageName, target)
-		self.files_to_staging(packageName, target)
-		self.folders_to_staging(packageName, target)
-		#build tree of all submodules
-		for dep in self.depends:
-			inherit = target.build_tree(dep, packageName)
-	
-	
-	# call here to clean the module
-	def clean(self, target):
-		if self.type=='PREBUILD':
-			# nothing to add ==> just dependence
-			None
-		elif self.type=='LIBRARY':
-			# remove folder of the lib ... for this targer
-			folderbuild = target.get_build_folder(self.name)
-			debug.info("remove folder : '" + folderbuild + "'")
-			lutinTools.remove_folder_and_sub_folder(folderbuild)
-		elif    self.type=='BINARY' \
-		     or self.type=='PACKAGE':
-			# remove folder of the lib ... for this targer
-			folderbuild = target.get_build_folder(self.name)
-			debug.info("remove folder : '" + folderbuild + "'")
-			lutinTools.remove_folder_and_sub_folder(folderbuild)
-			folderStaging = target.get_staging_folder(self.name)
-			debug.info("remove folder : '" + folderStaging + "'")
-			lutinTools.remove_folder_and_sub_folder(folderStaging)
-		else:
-			debug.error("Dit not know the element type ... (impossible case) type=" + self.type)
-	
-	def append_and_check(self, listout, newElement, order):
-		for element in listout:
-			if element==newElement:
-				return
-		listout.append(newElement)
-		if True==order:
-			listout.sort()
-	
-	def append_to_internalList(self, listout, list, order=False):
-		if type(list) == type(str()):
-			self.append_and_check(listout, list, order)
-		else:
-			# mulyiple imput in the list ...
-			for elem in list:
-				self.append_and_check(listout, elem, order)
-	
-	def add_module_depend(self, list):
-		self.append_to_internalList(self.depends, list, True)
-	
-	def add_optionnal_module_depend(self, module_name, compilation_flags="", export=False):
-		self.append_and_check(self.depends_optionnal, [module_name, compilation_flags, export], True)
-	
-	def add_export_path(self, list):
-		self.append_to_internalList(self.export_path, list)
-	
-	def add_path(self, list):
-		self.append_to_internalList(self.local_path, list)
-	
-	def add_export_flag_LD(self, list):
-		self.append_to_internalList(self.export_flags_ld, list)
-	
-	def add_export_flag_CC(self, list):
-		self.append_to_internalList(self.export_flags_cc, list)
-	
-	def add_export_flag_XX(self, list):
-		self.append_to_internalList(self.export_flags_xx, list)
-	
-	def add_export_flag_M(self, list):
-		self.append_to_internalList(self.export_flags_m, list)
-	
-	def add_export_flag_MM(self, list):
-		self.append_to_internalList(self.export_flags_mm, list)
-	
-	# add the link flag at the module
-	def compile_flags_LD(self, list):
-		self.append_to_internalList(self.flags_ld, list)
-	
-	def compile_flags_CC(self, list):
-		self.append_to_internalList(self.flags_cc, list)
-	
-	def compile_flags_XX(self, list):
-		self.append_to_internalList(self.flags_xx, list)
-	
-	def compile_flags_M(self, list):
-		self.append_to_internalList(self.flags_m, list)
-	
-	def compile_flags_MM(self, list):
-		self.append_to_internalList(self.flags_mm, list)
-	
-	def compile_flags_S(self, list):
-		self.append_to_internalList(self.flags_s, list)
-	
-	def compile_version_XX(self, version, same_as_api=True):
-		cpp_version_list = [1999, 2003, 2011, 2014]
-		if version not in cpp_version_list:
-			debug.error("can not select CPP version : " + str(version) + " not in " + str(cpp_version_list))
-		self.xx_version = version
-		if same_as_api == True:
-			self.xx_version_api = self.xx_version
-	
-	def compile_version_CC(self, version, same_as_api=True):
-		c_version_list = [1989, 1990, 1999, 2011]
-		if version not in c_version_list:
-			debug.error("can not select C version : " + str(version) + " not in " + str(c_version_list))
-		self.cc_version = version
-		if same_as_api == True:
-			self.cc_version_api = self.cc_version
-	
-	def add_src_file(self, list):
-		self.append_to_internalList(self.src, list, True)
-	
-	def copy_image(self, source, destination='', sizeX=-1, sizeY=-1):
-		self.imageToCopy.append([source, destination, sizeX, sizeY])
-	
-	def copy_file(self, source, destination=''):
-		self.files.append([source, destination])
-	
-	def copy_folder(self, source, destination=''):
-		self.folders.append([source, destination])
-	
-	def print_list(self, description, list):
-		if len(list) > 0:
-			print '        %s' %description
-			for elem in list:
-				print '            %s' %elem
-	
-	def display(self, target):
-		print '-----------------------------------------------'
-		print ' package : "%s"' %self.name
-		print '-----------------------------------------------'
-		print '    type:"%s"' %self.type
-		print '    file:"%s"' %self.originFile
-		print '    folder:"%s"' %self.originFolder
-		self.print_list('depends',self.depends)
-		self.print_list('depends_optionnal', self.depends_optionnal)
-		self.print_list('flags_ld',self.flags_ld)
-		self.print_list('flags_cc',self.flags_cc)
-		self.print_list('flags_xx',self.flags_xx)
-		self.print_list('flags_m',self.flags_m)
-		self.print_list('flags_mm',self.flags_mm)
-		self.print_list('flags_s',self.flags_s)
-		self.print_list('src',self.src)
-		self.print_list('files',self.files)
-		self.print_list('folders',self.folders)
-		self.print_list('export_path',self.export_path)
-		self.print_list('export_flags_ld',self.export_flags_ld)
-		self.print_list('export_flags_cc',self.export_flags_cc)
-		self.print_list('export_flags_xx',self.export_flags_xx)
-		self.print_list('export_flags_m',self.export_flags_m)
-		self.print_list('export_flags_mm',self.export_flags_mm)
-		self.print_list('local_path',self.local_path)
-	
-	def pkg_set(self, variable, value):
-		if "COMPAGNY_TYPE" == variable:
-			#	com : Commercial
-			#	net : Network??
-			#	org : Organisation
-			#	gov : Governement
-			#	mil : Military
-			#	edu : Education
-			#	pri : Private
-			#	museum : ...
-			if value not in ["com", "net", "org", "gov", "mil", "edu", "pri", "museum"]:
-				debug.error("can not set the value for this Input : '" + variable + "' : '" + value + "'")
-			else:
-				self.packageProp[variable] = value
-		elif "COMPAGNY_NAME" == variable:
-			self.packageProp[variable] = value
-			val2 = value.lower()
-			val2 = val2.replace(' ', '')
-			val2 = val2.replace('-', '')
-			val2 = val2.replace('_', '')
-			self.packageProp["COMPAGNY_NAME2"] = val2
-		elif "ICON" == variable:
-			self.packageProp[variable] = value
-		elif "MAINTAINER" == variable:
-			self.packageProp[variable] = value
-		elif "SECTION" == variable:
-			# project section : (must be separate by coma
-			#    refer to : http://packages.debian.org/sid/
-			#        admin cli-mono comm database debian-installer
-			#        debug doc editors electronics devel embedded
-			#        fonts games gnome gnu-r gnustep graphics
-			#        hamradio haskell httpd interpreters java
-			#        kde kernel libdevel libs lisp localization
-			#        mail math misc net news ocaml oldlibs otherosfs
-			#        perl php python ruby science shells sound tex
-			#        text utils vcs video virtual web x11 xfce zope ...
-			self.packageProp[variable] = value
-		elif "PRIORITY" == variable:
-			#list = ["required","important","standard","optional","extra"]
-			#if isinstance(value, list):
-			if value not in ["required", "important", "standard", "optional", "extra"]:
-				debug.error("can not set the value for this Input : '" + variable + "' : '" + value + "'")
-			else:
-				self.packageProp[variable] = value
-		elif "DESCRIPTION" == variable:
-			self.packageProp[variable] = value
-		elif "VERSION" == variable:
-			self.packageProp[variable] = value
-		elif "VERSION_CODE" == variable:
-			self.packageProp[variable] = value
-		elif "NAME" == variable:
-			self.packageProp[variable] = value
-		elif "ANDROID_MANIFEST" == variable:
-			self.packageProp[variable] = value
-		elif "ANDROID_JAVA_FILES" == variable:
-			self.packageProp[variable] = value
-		elif "RIGHT" == variable:
-			self.packageProp[variable] = value
-		elif "ANDROID_RESOURCES" == variable:
-			self.packageProp[variable] = value
-		elif "ANDROID_APPL_TYPE" == variable:
-			self.packageProp[variable] = value
-		elif "ADMOD_ID" == variable:
-			self.packageProp[variable] = value
-		elif "APPLE_APPLICATION_IOS_ID" == variable:
-			self.packageProp[variable] = value
-		elif "ADMOD_POSITION" == variable:
-			if value in ["top", "bottom"]:
-				self.packageProp[variable] = value
-			else:
-				debug.error("not know pkg element : '" + variable + "' with value : '" + value + "' must be [top|bottom]")
-		else:
-			debug.error("not know pkg element : '" + variable + "'")
-	
-	def pkg_add(self, variable, value):
-		# TODO : Check values...
-		self.packageProp[variable].append(value)
-	
-	def ext_project_add_module(self, target, projectMng, addedModule = []):
-		if self.name in addedModule:
-			return
-		addedModule.append(self.name)
-		debug.verbose("add a module to the project generator :" + self.name)
-		debug.verbose("local path :" + self.originFolder)
-		projectMng.add_files(self.name, self.originFolder, self.src)
-		#projectMng.add_data_file(self.originFolder, self.files)
-		#projectMng.add_data_folder(self.originFolder, self.folders)
-		"""
-		for depend in self.depends:
-			target.project_add_module(depend, projectMng, addedModule)
-		"""
-	
-	def create_project(self, target, projectMng):
-		projectMng.set_project_name(self.name)
-		self.ext_project_add_module(target, projectMng)
-		projectMng.generate_project_file()
-
-
-
-moduleList=[]
-__startModuleName="lutin_"
-
-def import_path(path):
-	global moduleList
-	matches = []
-	debug.debug('Start find sub File : "%s"' %path)
-	for root, dirnames, filenames in os.walk(path):
-		tmpList = fnmatch.filter(filenames, __startModuleName + "*.py")
-		# Import the module :
-		for filename in tmpList:
-			debug.debug('    Find a file : "%s"' %os.path.join(root, filename))
-			#matches.append(os.path.join(root, filename))
-			sys.path.append(os.path.dirname(os.path.join(root, filename)) )
-			moduleName = filename.replace('.py', '')
-			moduleName = moduleName.replace(__startModuleName, '')
-			debug.debug("integrate module: '" + moduleName + "' from '" + os.path.join(root, filename) + "'")
-			moduleList.append([moduleName,os.path.join(root, filename)])
-
-def exist(target, name):
-	global moduleList
-	for mod in moduleList:
-		if mod[0] == name:
-			return True
-	return False
-
-def load_module(target, name):
-	global moduleList
-	for mod in moduleList:
-		if mod[0] == name:
-			sys.path.append(os.path.dirname(mod[1]))
-			debug.verbose("import module : '" + __startModuleName + name + "'")
-			theModule = __import__(__startModuleName + name)
-			#try:
-			tmpElement = theModule.create(target)
-			#except:
-			#tmpElement = None
-			#debug.warning(" no function 'create' in the module : " + mod[0] + " from:'" + mod[1] + "'")
-			if (tmpElement == None) :
-				debug.debug("Request load module '" + name + "' not define for this platform")
-			else:
-				target.add_module(tmpElement)
-
-def list_all_module():
-	global moduleList
-	tmpListName = []
-	for mod in moduleList:
-		tmpListName.append(mod[0])
-	return tmpListName
-
-def list_all_module_with_desc():
-	global moduleList
-	tmpList = []
-	for mod in moduleList:
-		sys.path.append(os.path.dirname(mod[1]))
-		theModule = __import__("lutin_" + mod[0])
-		try:
-			tmpdesc = theModule.get_desc()
-			tmpList.append([mod[0], tmpdesc])
-		except:
-			debug.warning("has no naeme : " + mod[0])
-			tmpList.append([mod[0], ""])
-	return tmpList
-
-

setup.py

@@ -0,0 +1,35 @@
+#!/usr/bin/python
+from setuptools import setup
+
+def readme():
+	with open('README.rst') as f:
+		return f.read()
+
+# https://pypi.python.org/pypi?%3Aaction=list_classifiers
+setup(name='lutin',
+      version='0.5.4',
+      description='Lutin generic builder',
+      long_description=readme(),
+      url='http://github.com/HeeroYui/lutin',
+      author='Edouard DUPIN',
+      author_email='yui.heero@gmail.com',
+      license='APACHE-2',
+      packages=['lutin',
+                'lutin/builder',
+                'lutin/system',
+                'lutin/target'
+               ],
+      classifiers=[
+        'Development Status :: 3 - Alpha',
+        'License :: OSI Approved :: Apache Software License',
+        'Programming Language :: Python',
+        'Topic :: Software Development :: Compilers',
+      ],
+      keywords='builder c++ c android ios macos makefile cmake',
+      scripts=['bin/lutin'],
+      include_package_data = True,
+      zip_safe=False)
+
+#To developp: ./setup.py install/develop
+#TO register all in pip: ./setup.py register sdist upload
+