[DEV] start create a pip installable lutin

lutin/__init__.py

@@ -0,0 +1,41 @@
+#!/usr/bin/python
+
+import os
+import sys
+
+# now import other standard module (must be done here and not before ...
+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:
+	"""
+		When the user use with make.py we initialise ourself
+	"""
+	debug.verbose("Use Make as a make stadard")
+	sys.path.append(tools.get_run_folder())
+	
+	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

@@ -0,0 +1,258 @@
+#!/usr/bin/python
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+
+import sys
+from . import debug
+
+class ArgElement:
+	def __init__(self, option, value=""):
+		self.m_option = option;
+		self.m_arg = value;
+	
+	def get_option_nName(self):
+		return self.m_option
+	
+	def get_arg(self):
+		return self.m_arg
+	
+	def display(self):
+		if len(self.m_arg)==0:
+			debug.info("option : " + self.m_option)
+		elif len(self.m_option)==0:
+			debug.info("element :       " + self.m_arg)
+		else:
+			debug.info("option : " + self.m_option + ":" + self.m_arg)
+
+
+class ArgDefine:
+	def __init__(self,
+	             smallOption="", # like v for -v
+	             bigOption="", # like verbose for --verbose
+	             list=[], # ["val", "description"]
+	             desc="",
+	             haveParam=False):
+		self.m_optionSmall = smallOption;
+		self.m_optionBig = bigOption;
+		self.m_list = list;
+		if len(self.m_list)!=0:
+			self.m_haveParam = True
+		else:
+			if True==haveParam:
+				self.m_haveParam = True
+			else:
+				self.m_haveParam = False
+		self.m_description = desc;
+	
+	def get_option_small(self):
+		return self.m_optionSmall
+		
+	def get_option_big(self):
+		return self.m_optionBig
+	
+	def need_parameters(self):
+		return self.m_haveParam
+	
+	def get_porperties(self):
+		return ""
+	
+	def check_availlable(self, argument):
+		if len(self.m_list)==0:
+			return True
+		for element,desc in self.m_list:
+			if element == argument:
+				return True
+		return False
+	
+	def display(self):
+		if self.m_optionSmall != "" and self.m_optionBig != "":
+			print("		-" + self.m_optionSmall + " / --" + self.m_optionBig)
+		elif self.m_optionSmall != "":
+			print("		-" + self.m_optionSmall)
+		elif self.m_optionBig != "":
+			print("		--" + self.m_optionBig)
+		else:
+			print("		???? ==> internal error ...")
+		if self.m_description != "":
+			print("			" + self.m_description)
+		if len(self.m_list)!=0:
+			hasDescriptiveElement=False
+			for val,desc in self.m_list:
+				if desc!="":
+					hasDescriptiveElement=True
+					break;
+			if hasDescriptiveElement==True:
+				for val,desc in self.m_list:
+					print("				" + val + " : " + desc)
+			else:
+				tmpElementPrint = ""
+				for val,desc in self.m_list:
+					if len(tmpElementPrint)!=0:
+						tmpElementPrint += " / "
+					tmpElementPrint += val
+				print("				{ " + tmpElementPrint + " }")
+	
+	def parse(self, argList, currentID):
+		return currentID;
+
+
+class ArgSection:
+	def __init__(self,
+	             sectionName="",
+	             desc=""):
+		self.m_section = sectionName;
+		self.m_description = desc;
+	
+	def get_option_small(self):
+		return ""
+		
+	def get_option_big(self):
+		return ""
+		
+	def get_porperties(self):
+		return " [" + self.m_section + "]"
+	
+	def display(self):
+		print("	[" + self.m_section + "] : " + self.m_description)
+	
+	def parse(self, argList, currentID):
+		return currentID;
+
+
+class LutinArg:
+	def __init__(self):
+		self.m_listProperties = []
+	
+	def add(self, argument):
+		self.m_listProperties.append(argument) #ArgDefine(smallOption, bigOption, haveParameter, parameterList, description));
+	
+	def add_section(self, sectionName, sectionDesc):
+		self.m_listProperties.append(ArgSection(sectionName, sectionDesc))
+	
+	def parse(self):
+		listArgument = [] # composed of list element
+		NotparseNextElement=False
+		for iii in range(1, len(sys.argv)):
+			# special case of parameter in some elements
+			if NotparseNextElement==True:
+				NotparseNextElement = False
+				continue
+			debug.verbose("parse [" + str(iii) + "]=" + sys.argv[iii])
+			argument = sys.argv[iii]
+			optionList = argument.split("=")
+			debug.verbose(str(optionList))
+			if type(optionList) == type(str()):
+				option = optionList
+			else:
+				option = optionList[0]
+			optionParam = argument[len(option)+1:]
+			debug.verbose(option)
+			argumentFound=False;
+			if option[:2]=="--":
+				# big argument
+				for prop in self.m_listProperties:
+					if prop.get_option_big()=="":
+						continue
+					if prop.get_option_big() == option[2:]:
+						# find it
+						debug.verbose("find argument 2 : " + option[2:])
+						if prop.need_parameters()==True:
+							internalSub = option[2+len(prop.get_option_big()):]
+							if len(internalSub)!=0:
+								if len(optionParam)!=0:
+									# wrong argument ...
+									debug.warning("maybe wrong argument for : '" + prop.get_option_big() + "' cmdLine='" + argument + "'")
+									prop.display()
+									continue
+								optionParam = internalSub
+							if len(optionParam)==0:
+								#Get the next parameters 
+								if len(sys.argv) > iii+1:
+									optionParam = sys.argv[iii+1]
+									NotparseNextElement=True
+								else :
+									# missing arguments
+									debug.warning("parsing argument error : '" + prop.get_option_big() + "' Missing : subParameters ... cmdLine='" + argument + "'")
+									prop.display()
+									exit(-1)
+							if prop.check_availlable(optionParam)==False:
+								debug.warning("argument error : '" + prop.get_option_big() + "' SubParameters not availlable ... cmdLine='" + argument + "' option='" + optionParam + "'")
+								prop.display()
+								exit(-1)
+							listArgument.append(ArgElement(prop.get_option_big(),optionParam))
+							argumentFound = True
+						else:
+							if len(optionParam)!=0:
+								debug.warning("parsing argument error : '" + prop.get_option_big() + "' need no subParameters : '" + optionParam + "'   cmdLine='" + argument + "'")
+								prop.display()
+							listArgument.append(ArgElement(prop.get_option_big()))
+							argumentFound = True
+						break;
+				if False==argumentFound:
+					debug.error("UNKNOW argument : '" + argument + "'")
+			elif option[:1]=="-":
+				# small argument
+				for prop in self.m_listProperties:
+					if prop.get_option_small()=="":
+						continue
+					if prop.get_option_small() == option[1:1+len(prop.get_option_small())]:
+						# find it
+						debug.verbose("find argument 1 : " + option[1:1+len(prop.get_option_small())])
+						if prop.need_parameters()==True:
+							internalSub = option[1+len(prop.get_option_small()):]
+							if len(internalSub)!=0:
+								if len(optionParam)!=0:
+									# wrong argument ...
+									debug.warning("maybe wrong argument for : '" + prop.get_option_big() + "' cmdLine='" + argument + "'")
+									prop.display()
+									continue
+								optionParam = internalSub
+							if len(optionParam)==0:
+								#Get the next parameters 
+								if len(sys.argv) > iii+1:
+									optionParam = sys.argv[iii+1]
+									NotparseNextElement=True
+								else :
+									# missing arguments
+									debug.warning("parsing argument error : '" + prop.get_option_big() + "' Missing : subParameters  cmdLine='" + argument + "'")
+									prop.display()
+									exit(-1)
+							if prop.check_availlable(optionParam)==False:
+								debug.warning("argument error : '" + prop.get_option_big() + "' SubParameters not availlable ... cmdLine='" + argument + "' option='" + optionParam + "'")
+								prop.display()
+								exit(-1)
+							listArgument.append(ArgElement(prop.get_option_big(),optionParam))
+							argumentFound = True
+						else:
+							if len(optionParam)!=0:
+								debug.warning("parsing argument error : '" + prop.get_option_big() + "' need no subParameters : '" + optionParam + "'  cmdLine='" + argument + "'")
+								prop.display()
+							listArgument.append(ArgElement(prop.get_option_big()))
+							argumentFound = True
+						break;
+			
+			if argumentFound==False:
+				#unknow element ... ==> just add in the list ...
+				debug.verbose("unknow argument : " + argument)
+				listArgument.append(ArgElement("", argument))
+			
+		#for argument in listArgument:
+		#	argument.display()
+		#exit(0)
+		return listArgument;
+	
+	
+	
+	def display(self):
+		print("usage:")
+		listOfPropertiesArg = "";
+		for element in self.m_listProperties :
+			listOfPropertiesArg += element.get_porperties()
+		print("	" + sys.argv[0] + listOfPropertiesArg + " ...")
+		for element in self.m_listProperties :
+			element.display()

lutin/builder.py

@@ -0,0 +1,79 @@
+#!/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
+from . import debug
+from . import heritage
+import datetime
+from . import tools as lutinTools
+from . import module as lutinModule
+from . import system as lutinSystem
+from . import image as lutinImage
+from . import host as lutinHost
+
+##
+## 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
+##
+import lutinMultiprocess
+import lutinTools
+import lutinDebug as debug
+import lutinDepend as dependency
+import lutinEnv
+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=lutinTools.list_to_str(cmd)
+	# 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 file_dst
+	lutinTools.create_directory_of_file(file_dst)
+	debug.print_element("Executable", name, "==>", 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("Executable(strip)", 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)
+	

lutin/builder/lutinBuilder_c.py

@@ -0,0 +1,136 @@
+##
+## C builder
+##
+import lutinMultiprocess
+import lutinTools
+import lutinDebug as debug
+import lutinDepend as dependency
+
+# 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(lutinTools.add_prefix("-I", path["export"]))
+	except:
+		pass
+	try:
+		cmd.append(lutinTools.add_prefix("-I", path["local"]))
+	except:
+		pass
+	try:
+		cmd.append(lutinTools.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=lutinTools.list_to_str(cmd)
+	# check the dependency for this file :
+	if dependency.need_re_build(file_dst, file_src, file_depend, file_cmd, cmdLine) == False:
+		return file_dst
+	lutinTools.create_directory_of_file(file_dst)
+	comment = ["c", name, "<==", file]
+	# process element
+	lutinMultiprocess.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
+##
+import lutinMultiprocess
+import lutinTools
+import lutinDebug as debug
+import lutinDepend as dependency
+# 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(lutinTools.add_prefix("-I",path["export"]))
+	except:
+		pass
+	try:
+		cmd.append(lutinTools.add_prefix("-I",path["local"]))
+	except:
+		pass
+	try:
+		cmd.append(lutinTools.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=lutinTools.list_to_str(cmd)
+	
+	# check the dependency for this file :
+	if dependency.need_re_build(file_dst, file_src, file_depend, file_cmd, cmdLine) == False:
+		return file_dst
+	lutinTools.create_directory_of_file(file_dst)
+	comment = ["c++", name, "<==", file]
+	#process element
+	lutinMultiprocess.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
+##
+import lutinMultiprocess
+import lutinTools
+import lutinDebug as debug
+import lutinDepend as dependency
+
+##
+## 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,99 @@
+##
+## Dynamic library builder
+##
+import lutinMultiprocess
+import lutinTools
+import lutinDebug as debug
+import lutinDepend as dependency
+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=lutinTools.list_to_str(cmd)
+	# 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", name, "==>", file_dst)
+	lutinMultiprocess.run_command(cmdLine)
+	# strip the output file:
+	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)", 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)
+	#debug.print_element("SharedLib", self.name, "==>", tmpList[1])

lutin/builder/lutinBuilder_libraryStatic.py

@@ -0,0 +1,81 @@
+##
+## Static library builder
+##
+import lutinMultiprocess
+import lutinTools
+import lutinDebug as debug
+import lutinDepend as dependency
+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=lutinTools.list_to_str(cmd)
+	# 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 file_dst
+	lutinTools.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)
+	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

lutin/builder/lutinBuilder_m.py

@@ -0,0 +1,114 @@
+##
+## Objective-C builder
+##
+import lutinMultiprocess
+import lutinTools
+import lutinBuilder
+import lutinDebug as debug
+import lutinDepend as dependency
+
+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 = lutinBuilder.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(lutinTools.add_prefix("-I",path["export"]))
+	except:
+		pass
+	try:
+		cmd.append(lutinTools.add_prefix("-I",path["local"]))
+	except:
+		pass
+	try:
+		cmd.append(lutinTools.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=lutinTools.list_to_str(cmd)
+	# 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", name, "<==", file]
+	#process element
+	lutinMultiprocess.run_in_pool(cmdLine, comment, file_cmd)
+	return file_dst
+

lutin/builder/lutinBuilder_mm.py

@@ -0,0 +1,125 @@
+##
+## Objective C++ builder
+##
+import lutinMultiprocess
+import lutinTools
+import lutinBuilder
+import lutinDebug as debug
+import lutinDepend as dependency
+
+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 = lutinBuilder.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(lutinTools.add_prefix("-I",path["export"]))
+	except:
+		pass
+	try:
+		cmd.append(lutinTools.add_prefix("-I",path["local"]))
+	except:
+		pass
+	try:
+		cmd.append(lutinTools.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=lutinTools.list_to_str(cmd)
+	# 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++", name, "<==", file]
+	#process element
+	lutinMultiprocess.run_in_pool(cmdLine, comment, file_cmd)
+	return file_dst

lutin/builder/lutinBuilder_s.py

@@ -0,0 +1,33 @@
+##
+## ASM builder
+##
+import lutinMultiprocess
+import lutinTools
+import lutinDepend as dependency
+
+##
+## 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

@@ -0,0 +1,141 @@
+#!/usr/bin/python
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+
+import os
+from . import multiprocess as lutinMultiprocess
+import threading
+import re
+
+debugLevel=3
+debugColor=False
+
+color_default= ""
+color_red    = ""
+color_green  = ""
+color_yellow = ""
+color_blue   = ""
+color_purple = ""
+color_cyan   = ""
+
+
+debugLock = threading.Lock()
+
+def set_level(id):
+	global debugLevel
+	debugLevel = id
+	#print "SetDebug level at " + str(debugLevel)
+
+def get_level():
+	global debugLevel
+	return debugLevel
+
+def enable_color():
+	global debugColor
+	debugColor = True
+	global color_default
+	color_default= "\033[00m"
+	global color_red
+	color_red    = "\033[31m"
+	global color_green
+	color_green  = "\033[32m"
+	global color_yellow
+	color_yellow = "\033[33m"
+	global color_blue
+	color_blue   = "\033[34m"
+	global color_purple
+	color_purple = "\033[35m"
+	global color_cyan
+	color_cyan   = "\033[36m"
+
+def extreme_verbose(input, force=False):
+	global debugLock
+	global debugLevel
+	if    debugLevel >= 6 \
+	   or force == True:
+		debugLock.acquire()
+		print(color_blue + input + color_default)
+		debugLock.release()
+
+def verbose(input, force=False):
+	global debugLock
+	global debugLevel
+	if    debugLevel >= 5 \
+	   or force == True:
+		debugLock.acquire()
+		print(color_blue + input + color_default)
+		debugLock.release()
+
+def debug(input, force=False):
+	global debugLock
+	global debugLevel
+	if    debugLevel >= 4 \
+	   or force == True:
+		debugLock.acquire()
+		print(color_green + input + color_default)
+		debugLock.release()
+
+def info(input, force=False):
+	global debugLock
+	global debugLevel
+	if    debugLevel >= 3 \
+	   or force == True:
+		debugLock.acquire()
+		print(input + color_default)
+		debugLock.release()
+
+def warning(input, force=False):
+	global debugLock
+	global debugLevel
+	if    debugLevel >= 2 \
+	   or force == True:
+		debugLock.acquire()
+		print(color_purple + "[WARNING] " + input + color_default)
+		debugLock.release()
+
+def error(input, threadID=-1, force=False, crash=True):
+	global debugLock
+	global debugLevel
+	if    debugLevel >= 1 \
+	   or force == True:
+		debugLock.acquire()
+		print(color_red + "[ERROR] " + input + color_default)
+		debugLock.release()
+	if crash==True:
+		lutinMultiprocess.error_occured()
+		if threadID != -1:
+			threading.interrupt_main()
+		exit(-1)
+		#os_exit(-1)
+		#raise "error happend"
+
+def print_element(type, lib, dir, name, force=False):
+	global debugLock
+	global debugLevel
+	if    debugLevel >= 3 \
+	   or force == True:
+		debugLock.acquire()
+		print(color_cyan + type + color_default + " : " + color_yellow + lib + color_default + " " + dir + " " + color_blue + name + color_default)
+		debugLock.release()
+
+def print_compilator(myString):
+	global debugColor
+	global debugLock
+	if debugColor == True:
+		myString = myString.replace('\\n', '\n')
+		myString = myString.replace('\\t', '\t')
+		myString = myString.replace('error:', color_red+'error:'+color_default)
+		myString = myString.replace('warning:', color_purple+'warning:'+color_default)
+		myString = myString.replace('note:', color_green+'note:'+color_default)
+		myString = re.sub(r'([/\w_-]+\.\w+):', r'-COLORIN-\1-COLOROUT-:', myString)
+		myString = myString.replace('-COLORIN-', color_yellow)
+		myString = myString.replace('-COLOROUT-', color_default)
+	
+	debugLock.acquire()
+	print(myString)
+	debugLock.release()

lutin/depend.py

@@ -0,0 +1,158 @@
+#!/usr/bin/python
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+
+import os
+from . import debug
+from . import env as environement
+
+
+def need_re_build(dst, src, dependFile=None, file_cmd="", cmdLine=""):
+	debug.extreme_verbose("Resuest check of dependency of :")
+	debug.extreme_verbose("		dst='" + str(dst) + "'")
+	debug.extreme_verbose("		str='" + str(src) + "'")
+	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():
+		debug.extreme_verbose("			==> must rebuild (force mode)")
+		return True
+	
+	# check if the destination existed:
+	if     dst != "" \
+	   and dst != None \
+	   and os.path.exists(dst) == False:
+		debug.extreme_verbose("			==> must rebuild (dst does not exist)")
+		return True
+	if     dst != "" \
+	   and dst != None \
+	   and os.path.exists(src) == False:
+		debug.warning("			==> unexistant file :'" + src + "'")
+		return True
+	# chek the basic date if the 2 files
+	if     dst != "" \
+	   and dst != None \
+	   and os.path.getmtime(src) > os.path.getmtime(dst):
+		debug.extreme_verbose("			==> must rebuild (source time greater)")
+		return True
+	
+	if     dependFile != "" \
+	   and dependFile != None \
+	   and os.path.exists(dependFile) == False:
+		debug.extreme_verbose("			==> must rebuild (no depending file)")
+		return True
+	
+	if     file_cmd != "" \
+	   and file_cmd != None:
+		if os.path.exists(file_cmd) == False:
+			debug.extreme_verbose("			==> must rebuild (no commandLine file)")
+			return True
+		# check if the 2 cmdline are similar :
+		file2 = open(file_cmd, "r")
+		firstAndUniqueLine = file2.read()
+		if firstAndUniqueLine != cmdLine:
+			debug.extreme_verbose("			==> must rebuild (cmdLines are not identical)")
+			debug.extreme_verbose("				==> '" + cmdLine + "'")
+			debug.extreme_verbose("				==> '" + firstAndUniqueLine + "'")
+			file2.close()
+			return True
+		# the cmdfile is correct ...
+		file2.close()
+	
+	if     dependFile != "" \
+	   and dependFile != None:
+		debug.extreme_verbose("			start parsing dependency file : '" + dependFile + "'")
+		file = open(dependFile, "r")
+		for curLine in file.readlines():
+			# normal file : end with : ": \\n"
+			curLine = curLine[:len(curLine)-1]
+			# removing last \ ...
+			if curLine[len(curLine)-1:] == '\\' :
+				curLine = curLine[:len(curLine)-1]
+			# remove white space : 
+			#debug.verbose("				Line (read) : '" + curLine + "'");
+			curLine = curLine.strip()
+			#debug.verbose("				Line (strip) : '" + curLine + "'");
+			
+			testFile=""
+			if curLine[len(curLine)-1:] == ':':
+				debug.extreme_verbose("				Line (no check (already done) : '" + curLine + "'");
+			elif    len(curLine) == 0 \
+			     or curLine == '\\':
+				debug.extreme_verbose("				Line (Not parsed) : '" + curLine + "'");
+			else:
+				testFile = curLine
+				debug.extreme_verbose("				Line (might check) : '" + testFile + "'");
+			# really check files:
+			if testFile!="":
+				debug.extreme_verbose("					==> test");
+				if False==os.path.exists(testFile):
+					debug.extreme_verbose("			==> must rebuild (a dependency file does not exist)")
+					file.close()
+					return True
+				if os.path.getmtime(testFile) > os.path.getmtime(dst):
+					debug.extreme_verbose("			==> must rebuild (a dependency file time is newer)")
+					file.close()
+					return True
+		# close the current file :
+		file.close()
+	
+	debug.extreme_verbose("			==> Not rebuild (all dependency is OK)")
+	return False
+
+
+
+def need_re_package(dst, srcList, mustHaveSrc, file_cmd="", cmdLine=""):
+	debug.extreme_verbose("Resuest check of dependency of :")
+	debug.extreme_verbose("		dst='" + dst + "'")
+	debug.extreme_verbose("		src()=")
+	for src in srcList:
+		debug.verbose("			'" + src + "'")
+	
+	if mustHaveSrc==False and len(srcList)==0:
+		return False
+	
+	# if force mode selected ==> just force rebuild ...
+	if environement.get_force_mode():
+		debug.extreme_verbose("			==> must re-package (force mode)")
+		return True
+	
+	# check if the destination existed:
+	if False==os.path.exists(dst):
+		debug.extreme_verbose("			==> must re-package (dst does not exist)")
+		return True
+	# chek the basic date if the 2 files
+	if len(srcList)==0:
+		debug.extreme_verbose("			==> must re-package (no source ???)")
+		return True
+	for src in srcList:
+		if os.path.getmtime(src) > os.path.getmtime(dst):
+			debug.extreme_verbose("			==> must re-package (source time greater) : '" + src + "'")
+			return True
+	
+	if ""!=file_cmd:
+		if False==os.path.exists(file_cmd):
+			debug.extreme_verbose("			==> must rebuild (no commandLine file)")
+			return True
+		# check if the 2 cmdline are similar :
+		file2 = open(file_cmd, "r")
+		firstAndUniqueLine = file2.read()
+		if firstAndUniqueLine != cmdLine:
+			debug.extreme_verbose("			==> must rebuild (cmdLines are not identical)")
+			debug.extreme_verbose("				==> '" + cmdLine + "'")
+			debug.extreme_verbose("				==> '" + firstAndUniqueLine + "'")
+			file2.close()
+			return True
+		# the cmdfile is correct ...
+		file2.close()
+	
+	debug.extreme_verbose("			==> Not re-package (all dependency is OK)")
+	return False
+
+
+

lutin/env.py

@@ -0,0 +1,97 @@
+#!/usr/bin/python
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+
+from . import debug
+
+
+
+forceMode=False
+
+def set_force_mode(val):
+	global forceMode
+	if val==1:
+		forceMode = 1
+	else:
+		forceMode = 0
+
+def get_force_mode():
+	global forceMode
+	return forceMode
+
+
+printPrettyMode=False
+
+def set_print_pretty_mode(val):
+	global printPrettyMode
+	if val == True:
+		printPrettyMode = True
+	else:
+		printPrettyMode = False
+
+def get_print_pretty_mode():
+	global printPrettyMode
+	return printPrettyMode
+
+def print_pretty(myString, force=False):
+	global printPrettyMode
+	if    printPrettyMode == True \
+	   or force == True:
+		if myString[len(myString)-1]==' ' : 
+			tmpcmdLine = myString[:len(myString)-1]
+		else :
+			tmpcmdLine = myString
+		tmpcmdLine = tmpcmdLine.replace(' ', '\n\t')
+		tmpcmdLine = tmpcmdLine.replace('\n\t\n\t', '\n\t')
+		tmpcmdLine = tmpcmdLine.replace('\n\t\n\t', '\n\t')
+		tmpcmdLine = tmpcmdLine.replace('\n\t\n\t', '\n\t')
+		baseElementList = ["-o",
+		                   "-D",
+		                   "-I",
+		                   "-L",
+		                   "g++",
+		                   "gcc",
+		                   "clang",
+		                   "clang++",
+		                   "ar",
+		                   "ld",
+		                   "ranlib",
+		                   "-framework",
+		                   "-isysroot",
+		                   "-arch",
+		                   "-keystore",
+		                   "-sigalg",
+		                   "-digestalg",
+		                   "<",
+		                   "<<",
+		                   ">",
+		                   ">>"]
+		for element in baseElementList:
+			tmpcmdLine = tmpcmdLine.replace(element+'\n\t', element+' ')
+		baseElementList = ["g++", "gcc", "clang", "clang++", "ar", "ld", "ranlib"]
+		for element in baseElementList:
+			tmpcmdLine = tmpcmdLine.replace('/'+element+' ', '/'+element+'\n\t')
+		tmpcmdLine = tmpcmdLine.replace('\n\t', ' \\\n\t')
+		
+		return tmpcmdLine
+	else:
+		return myString
+
+forceStripMode=False
+
+def set_force_strip_mode(val):
+	global forceStripMode
+	if val==True:
+		forceStripMode = True
+	else:
+		forceStripMode = False
+
+def get_force_strip_mode():
+	global forceStripMode
+	return forceStripMode
+

lutin/heritage.py

@@ -0,0 +1,178 @@
+#!/usr/bin/python
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+
+import sys
+import copy
+from . import debug
+
+
+def append_to_list(listout, list):
+	if type(list) == type(str()):
+		if list not in listout:
+			listout.append(list)
+	else:
+		# mulyiple imput in the list ...
+		for elem in list:
+			if elem not in listout:
+				listout.append(elem)
+
+
+
+class HeritageList:
+	def __init__(self, heritage = None):
+		self.flags={}
+		# sources list:
+		self.src=[]
+		self.path=[]
+		
+		self.listHeritage=[]
+		if heritage != None:
+			self.add_heritage(heritage)
+	
+	def add_heritage(self, heritage):
+		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.regenerate_tree()
+		
+	def add_heritage_list(self, heritage_list):
+		if type(heritage_list) == type(None):
+			return
+		for herit in heritage_list.listHeritage:
+			find = False
+			for element in self.listHeritage:
+				if element.name == herit.name:
+					find = True
+			if find == False:
+				self.listHeritage.append(herit)
+		self.regenerate_tree()
+	
+	def regenerate_tree(self):
+		self.flags={}
+		# sources list:
+		self.src=[]
+		self.path=[]
+		# reorder heritage list :
+		listHeritage = self.listHeritage
+		self.listHeritage = []
+		# first step : add all lib with no dependency:
+		for herit in listHeritage:
+			if len(herit.depends) == 0:
+				self.listHeritage.append(herit)
+				listHeritage.remove(herit)
+		while len(listHeritage) > 0:
+			currentHeritageSize = len(listHeritage)
+			debug.verbose("list heritage = " + str([[x.name, x.depends] for x in listHeritage]))
+			# Add element only when all dependence are resolved
+			for herit in listHeritage:
+				listDependsName = [y.name for y in self.listHeritage]
+				if all(x in listDependsName for x in herit.depends) == True:
+					listHeritage.remove(herit)
+					self.listHeritage.append(herit)
+			if currentHeritageSize == len(listHeritage):
+				debug.warning("Not resolve dependency between the library ==> can be a cyclic dependency !!!")
+				for herit in listHeritage:
+					self.listHeritage.append(herit)
+				listHeritage = []
+				debug.warning("new heritage list:")
+				for element in self.listHeritage:
+					debug.warning("	" + element.name + " " + str(element.depends))
+		debug.verbose("new heritage list:")
+		for element in self.listHeritage:
+			debug.verbose("	" + element.name + " " + str(element.depends))
+		for element in reversed(self.listHeritage):
+			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 "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:
+	def __init__(self, module):
+		self.name=""
+		self.depends=[]
+		## Remove all variable to prevent error of multiple definition
+		# all the parameter that the upper classe need when build
+		self.flags={}
+		# sources list:
+		self.src=[]
+		self.path=[]
+		# update is set at true when data are newly created ==> force upper element to update
+		self.hasBeenUpdated=False
+		
+		if type(module) != type(None):
+			# all the parameter that the upper classe need when build
+			self.name = module.name
+			self.depends = copy.deepcopy(module.depends)
+			# 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_import_path(self, list):
+		append_to_list(self.path, list)
+	
+	def add_sources(self, list):
+		append_to_list(self.src, list)
+	
+	def need_update(self, list):
+		self.hasBeenUpdated=True
+	
+	def add_sub(self, other):
+		if type(other) == type(None):
+			debug.verbose("input of the heriatege class is None !!!")
+			return
+		if other.hasBeenUpdated == True:
+			self.hasBeenUpdated = True
+		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 "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

@@ -0,0 +1,33 @@
+#!/usr/bin/python
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+
+import platform
+import sys
+from . import debug
+
+# print os.name # ==> 'posix'
+if platform.system() == "Linux":
+	OS = "Linux"
+elif platform.system() == "Windows":
+	OS = "Windows"
+elif platform.system() == "Darwin":
+	OS = "MacOs"
+else:
+	debug.error("Unknow the Host OS ... '" + platform.system() + "'")
+
+debug.debug("host.OS = " + OS)
+
+
+if sys.maxsize > 2**32:
+	BUS_SIZE = 64
+else:
+	BUS_SIZE = 32
+
+debug.debug("host.BUS_SIZE = " + str(BUS_SIZE))
+

lutin/image.py

@@ -0,0 +1,93 @@
+#!/usr/bin/python
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+
+from . import debug
+from . import tools
+import platform
+import os
+from . import multiprocess as lutinMultiprocess
+from . import depend as dependency
+
+enableResizeImage = True
+try:
+	if platform.system() == "Darwin":
+		import CoreGraphics
+	else:
+		from PIL import Image
+except:
+	enableResizeImage = False
+	debug.warning("Missing python tools : CoreGraphics (MacOs) or PIL") 
+
+def get_pow_2_multiple(size):
+	base = 2
+	while size>base:
+		base = base * 2
+	return base
+
+# TODO : 3 things to do :
+#        check if force requested
+#        check if time change
+#        check if command line change
+def resize(srcFile, destFile, x, y, cmd_file=None):
+	if enableResizeImage == False:
+		return
+	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):
+		return
+	# add cmdLine ...
+	x = get_pow_2_multiple(x)
+	extension = destFile[destFile.rfind('.'):]
+	if platform.system() == "Darwin":
+		source_image = CoreGraphics.CGImageImport(CoreGraphics.CGDataProviderCreateWithFilename(srcFile))
+		source_width = source_image.getWidth()
+		source_height = source_image.getHeight()
+		if source_width <= x:
+			# for small image just copy:
+			tools.copy_file(srcFile, destFile)
+		else:
+			if y <= 0:
+				# keep ratio :
+				y = int(float(x) * float(source_height) / float(source_width))
+			y = get_pow_2_multiple(y)
+			debug.print_element("resize Image (" + str(x) + "x" + str(y) + ")", srcFile, "==>", destFile)
+			debug.debug("Resize image: " + srcFile + " size=(" + str(source_width) + "x" + str(source_height) + ") -> (" + str(x) + "x" + str(y) + ")")
+			source_image_rect = CoreGraphics.CGRectMake(0, 0, source_width, source_height)
+			new_image = source_image.createWithImageInRect(source_image_rect)
+			colors_space = CoreGraphics.CGColorSpaceCreateDeviceRGB()
+			colors = CoreGraphics.CGFloatArray(5)
+			context = CoreGraphics.CGBitmapContextCreateWithColor(x, y, colors_space, colors)
+			context.setInterpolationQuality(CoreGraphics.kCGInterpolationHigh)
+			new_image_rect = CoreGraphics.CGRectMake(0, 0, x, y)
+			context.drawImage(new_image_rect, new_image)
+			tools.create_directory_of_file(destFile)
+			if extension == ".jpeg":
+				context.writeToFile(destFile, CoreGraphics.kCGImageFormatJPEG)
+			elif extension == ".png":
+				context.writeToFile(destFile, CoreGraphics.kCGImageFormatPNG)
+			else:
+				debug.error(" can not manage extention ... : " + destFile)
+	else:
+		# open an image file (.bmp,.jpg,.png,.gif) you have in the working folder
+		im1 = Image.open(srcFile)
+		if im1.size[0] <= x:
+			# for small image just copy:
+			tools.copy_file(srcFile, destFile)
+		else:
+			if y <= 0:
+				# keep ratio :
+				y = int(float(x) * float(im1.size[1]) / float(im1.size[0]))
+			y = get_pow_2_multiple(y)
+			debug.print_element("resize Image (" + str(x) + "x" + str(y) + ")", srcFile, "==>", destFile)
+			# use one of these filter options to resize the image
+			tmpImage = im1.resize((x, y), Image.ANTIALIAS)
+			tools.create_directory_of_file(destFile)
+			tmpImage.save(destFile)
+	lutinMultiprocess.store_command(cmd_line, cmd_file)

lutin/module.py

@@ -0,0 +1,659 @@
+#!/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
+from . import module
+from . import host
+from . import tools as lutinTools
+from . import debug
+from . import heritage
+from . import depend as dependency
+from . import builder
+from . import multiprocess as lutinMultiprocess
+from . import env as 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.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 = lutinTools.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_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 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)
+			lutinTools.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_CC("-D"+option);
+				else:
+					self.add_export_flag_CC("-D"+option);
+			# 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 ...
+		lutinMultiprocess.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 + "'")
+			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_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_LD(self, list):
+		self.append_to_internalList2(self.flags["export"], "link", list)
+	
+	def add_export_flag_CC(self, list):
+		self.append_to_internalList2(self.flags["export"], "c", list)
+	
+	def add_export_flag_XX(self, list):
+		self.append_to_internalList2(self.flags["export"], "c++", list)
+	
+	def add_export_flag_M(self, list):
+		self.append_to_internalList2(self.flags["export"], "m", list)
+	
+	def add_export_flag_MM(self, list):
+		self.append_to_internalList2(self.flags["export"], "mm", list)
+	
+	# add the link flag at the module
+	def compile_flags_LD(self, list):
+		self.append_to_internalList2(self.flags["local"], "link", list)
+	
+	def compile_flags_CC(self, list):
+		self.append_to_internalList2(self.flags["local"], "c", list)
+	
+	def compile_flags_XX(self, list):
+		self.append_to_internalList2(self.flags["local"], "c++", list)
+	
+	def compile_flags_M(self, list):
+		self.append_to_internalList2(self.flags["local"], "m", list)
+	
+	def compile_flags_MM(self, list):
+		self.append_to_internalList2(self.flags["local"], "mm", list)
+	
+	def compile_flags_S(self, list):
+		self.append_to_internalList2(self.flags["local"], "s", 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

@@ -0,0 +1,276 @@
+#!/usr/bin/python
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+
+import sys
+import threading
+import time
+import sys
+if sys.version_info >= (3, 0):
+	import queue
+else:
+	import Queue as queue
+import os
+import subprocess
+import shlex
+from . import debug
+from . import tools as lutinTools
+from . import env as lutinEnv
+
+queueLock = threading.Lock()
+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
+currentIdExecution = 0
+errorExecution = {
+	"id":-1,
+	"cmd":"",
+	"return":0,
+	"err":"",
+	"out":"",
+}
+
+exitFlag = False # resuest stop of the thread
+isinit = False # the thread are initialized
+errorOccured = False # a thread have an error
+processorAvaillable = 1 # number of CPU core availlable
+
+def store_command(cmdLine, file):
+	# write cmd line only after to prevent errors ...
+	if     file != "" \
+	   and file != None:
+		# Create directory:
+		lutinTools.create_directory_of_file(file)
+		# Store the command Line:
+		file2 = open(file, "w")
+		file2.write(cmdLine)
+		file2.flush()
+		file2.close()
+
+##
+## @brief Execute the command and ruturn generate data
+##
+def run_command_direct(cmdLine):
+	# prepare command line:
+	args = shlex.split(cmdLine)
+	debug.verbose("cmd = " + str(args))
+	try:
+		# create the subprocess
+		p = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+	except subprocess.CalledProcessError as e:
+		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:
+			return err[:-1];
+		return output[:-1];
+	else:
+		return False
+
+
+def run_command(cmdLine, storeCmdLine="", buildId=-1, file=""):
+	global errorOccured
+	global exitFlag
+	global currentIdExecution
+	# prepare command line:
+	args = shlex.split(cmdLine)
+	debug.verbose("cmd = " + str(args))
+	try:
+		# create the subprocess
+		p = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+	except subprocess.CalledProcessError as e:
+		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))
+		queueLock.acquire()
+		# TODO : Print the output all the time .... ==> to show warnings ...
+		if buildId >= 0 and (output != "" or err != ""):
+			debug.warning("output in subprocess compiling: '" + file + "'")
+		if output != "":
+			debug.print_compilator(output)
+		if err != "":
+			debug.print_compilator(err)
+		queueLock.release()
+	else:
+		errorOccured = True
+		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.print_compilator(output)
+			debug.print_compilator(err)
+			if p.returncode == 2:
+				debug.error("can not compile file ... [keyboard interrrupt]")
+			else:
+				debug.error("can not compile file ... ret : " + str(p.returncode))
+		else:
+			# in multiprocess interface
+			queueLock.acquire()
+			# if an other write an error before, check if the current process is started before ==> then is the first error
+			if errorExecution["id"] >= buildId:
+				# nothing to do ...
+				queueLock.release()
+				return;
+			errorExecution["id"] = buildId
+			errorExecution["cmd"] = cmdLine
+			errorExecution["return"] = p.returncode
+			errorExecution["err"] = err,
+			errorExecution["out"] = output,
+			queueLock.release()
+		# not write the command file...
+		return
+	debug.verbose("done 3")
+	# write cmd line only after to prevent errors ...
+	store_command(cmdLine, storeCmdLine)
+
+
+
+class myThread(threading.Thread):
+	def __init__(self, threadID, lock, queue):
+		threading.Thread.__init__(self)
+		self.threadID = threadID
+		self.name = "Thread " + str(threadID)
+		self.queue = queue
+		self.lock = lock
+	def run(self):
+		debug.verbose("Starting " + self.name)
+		global exitFlag
+		global currentThreadWorking
+		workingSet = False
+		while exitFlag == False:
+			self.lock.acquire()
+			if not self.queue.empty():
+				if workingSet==False:
+					currentThreadWorking += 1
+					workingSet = True
+				data = self.queue.get()
+				self.lock.release()
+				debug.verbose(self.name + " processing '" + data[0] + "'")
+				if data[0]=="cmdLine":
+					comment = data[2]
+					cmdLine = data[1]
+					cmdStoreFile = data[3]
+					debug.print_element( "[" + str(data[4]) + "][" + str(self.threadID) + "] " + comment[0], comment[1], comment[2], comment[3])
+					run_command(cmdLine, cmdStoreFile, buildId=data[4], file=comment[3])
+				else:
+					debug.warning("unknow request command : " + data[0])
+			else:
+				if workingSet==True:
+					currentThreadWorking -= 1
+					workingSet=False
+				# no element to parse, just wait ...
+				self.lock.release()
+				time.sleep(0.2)
+		# kill requested ...
+		debug.verbose("Exiting " + self.name)
+
+
+def error_occured():
+	global exitFlag
+	exitFlag = True
+
+def set_core_number(numberOfcore):
+	global processorAvaillable
+	processorAvaillable = numberOfcore
+	debug.debug(" set number of core for multi process compilation : " + str(processorAvaillable))
+	# nothing else to do
+
+def init():
+	global exitFlag
+	global isinit
+	if isinit==False:
+		isinit=True
+		global threads
+		global queueLock
+		global workQueue
+		# Create all the new threads
+		threadID = 0
+		while threadID < processorAvaillable:
+			thread = myThread(threadID, queueLock, workQueue)
+			thread.start()
+			threads.append(thread)
+			threadID += 1
+		
+
+
+def un_init():
+	global exitFlag
+	# Notify threads it's time to exit
+	exitFlag = True
+	if processorAvaillable > 1:
+		# Wait for all threads to complete
+		for tmp in threads:
+			debug.verbose("join thread ...")
+			tmp.join()
+		debug.verbose("Exiting ALL Threads")
+
+
+
+def run_in_pool(cmdLine, comment, storeCmdLine=""):
+	global currentIdExecution
+	if processorAvaillable <= 1:
+		debug.print_element(comment[0], comment[1], comment[2], comment[3])
+		run_command(cmdLine, storeCmdLine, file=comment[3])
+		return
+	# multithreaded mode
+	init()
+	# Fill the queue
+	queueLock.acquire()
+	debug.verbose("add : in pool cmdLine")
+	workQueue.put(["cmdLine", cmdLine, comment, storeCmdLine, currentIdExecution])
+	currentIdExecution +=1;
+	queueLock.release()
+	
+
+def pool_synchrosize():
+	global errorOccured
+	global errorExecution
+	if processorAvaillable <= 1:
+		#in this case : nothing to synchronise
+		return
+	
+	debug.verbose("wait queue process ended\n")
+	# Wait for queue to empty
+	while not workQueue.empty() \
+	      and False==errorOccured:
+		time.sleep(0.2)
+		pass
+	# Wait all thread have ended their current process
+	while currentThreadWorking != 0 \
+	      and False==errorOccured:
+		time.sleep(0.2)
+		pass
+	if False==errorOccured:
+		debug.verbose("queue is empty")
+	else:
+		un_init()
+		debug.debug("Thread return with error ... ==> stop all the pool")
+		if errorExecution["id"] == -1:
+			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.print_compilator(str(errorExecution["out"][0]))
+		debug.print_compilator(str(errorExecution["err"][0]))
+		if errorExecution["return"] == 2:
+			debug.error("can not compile file ... [keyboard interrrupt]")
+		else:
+			debug.error("can not compile file ... return value : " + str(errorExecution["return"]))
+	

lutin/system.py

@@ -0,0 +1,163 @@
+#!/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
+from . import debug
+import datetime
+from . import tools as lutinTools
+from . import module
+from . import image as lutinImage
+from . import host as lutinHost
+
+class System:
+	def __init__(self):
+		self.valid=False;
+		self.help="";
+		self.include_cc=[]
+		self.export_flags_cc=[]
+		self.export_flags_xx=[]
+		self.export_flags_mm=[]
+		self.export_flags_m=[]
+		self.export_flags_ar=[]
+		self.export_flags_ld=[]
+		self.export_flags_ld_shared=[]
+		self.export_libs_ld=[]
+		self.export_libs_ld_shared=[]
+		
+	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_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)
+	
+	
+
+
+
+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)
+	# add the currrent module at the 
+	return myModule
+
+
+
+
+# Dictionnaire of Target name
+#   inside table of ["Name of the lib", "path of the lib", boolean loaded, module loaded]
+systemList={}
+__startSystemName="lutinSystem_"
+
+
+def import_path(path):
+	global targetList
+	matches = []
+	debug.debug('Start find sub File : "%s"' %path)
+	for root, dirnames, filenames in os.walk(path):
+		tmpList = fnmatch.filter(filenames, __startSystemName + "*.py")
+		# Import the module :
+		for filename in tmpList:
+			debug.verbose('    Find a file : "%s"' %os.path.join(root, filename))
+			sys.path.append(os.path.dirname(os.path.join(root, filename)) )
+			systemName = filename.replace('.py', '')
+			systemName = systemName.replace(__startSystemName, '')
+			targetType, systemName = systemName.split('_')
+			debug.debug("integrate system: '" + targetType + "':'" + systemName + "' from '" + os.path.join(root, filename) + "'")
+			if targetType in systemList:
+				systemList[targetType].append({"name":systemName,
+				                               "path":os.path.join(root, filename),
+				                               "system":None,
+				                               "loaded":False,
+				                               "exist":False,
+				                               "module":None})
+			else:
+				systemList[targetType] = [{"name":systemName,
+				                           "path":os.path.join(root, filename),
+				                           "system":None,
+				                           "loaded":False,
+				                           "exist":False,
+				                           "module":None}]
+
+def display():
+	global systemList
+	for elementName in systemList:
+		debug.info("integrate system: '" + elementName +"'")
+		for data in systemList[elementName]:
+			debug.info("    '" + data["name"] +"' in " + data["path"])
+
+
+def exist(lib_name, target_name) :
+	global systemList
+	if target_name not in systemList:
+		return False
+	for data in systemList[target_name]:
+		if data["name"] == lib_name:
+			# we find it in the List ==> need to check if it is present in the system :
+			if data["loaded"] == False:
+				debug.verbose("add to path: '" + os.path.dirname(data["path"]) + "'")
+				sys.path.append(os.path.dirname(data["path"]))
+				debug.verbose("import system : '" + data["name"] + "'")
+				theSystem = __import__(__startSystemName + target_name + "_" + data["name"])
+				#create the system module
+				try:
+					data["system"] = theSystem.System()
+					data["exist"] = data["system"].valid
+				except:
+					debug.debug("Not find: '" + data["name"] + "'")
+			return data["exist"]
+	return False
+
+def load(target, lib_name, target_name):
+	global systemList
+	if target_name not in systemList:
+		debug.error("you must call this function after checking of the system exist() !1!")
+	for data in systemList[target_name]:
+		if data["name"] == lib_name:
+			if data["exist"] == False:
+				debug.error("you must call this function after checking of the system exist() !2!")
+			if data["module"] == None:
+				# create a module from the system interface...
+				data["module"] = createModuleFromSystem(target, data)
+				data["loaded"] = True
+			target.add_module(data["module"])
+			return
+

lutin/system/lutinSystem_IOs_CoreAudio.py

@@ -0,0 +1,25 @@
+#!/usr/bin/python
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+
+import lutinDebug as debug
+import lutinSystem
+import lutinTools as tools
+import os
+
+class System(lutinSystem.System):
+	def __init__(self):
+		lutinSystem.System.__init__(self)
+		# create some HELP:
+		self.help="CoreAudio : Ios interface for audio (all time present, just system interface)"
+		self.valid = True
+		# todo : create a searcher of the presence of the library:
+		self.add_export_flag_LD("-framework CoreAudio")
+		self.add_export_flag_LD("-framework AudioToolbox")
+
+

lutin/system/lutinSystem_Linux_alsa.py

@@ -0,0 +1,29 @@
+#!/usr/bin/python
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+
+import lutinDebug as debug
+import lutinSystem
+import lutinTools as tools
+import os
+
+class System(lutinSystem.System):
+	def __init__(self):
+		lutinSystem.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:
+		if     not os.path.isfile("/usr/include/alsa/asoundlib.h") \
+		   and not os.path.isfile("/usr/include/dssi/alsa/asoundlib.h"):
+			# we did not find the library reqiested (just return) (automaticly set at false)
+			return;
+		self.valid = True
+		# todo : create a searcher of the presence of the library:
+		self.add_export_flag_LD("-lasound")
+
+

lutin/system/lutinSystem_Linux_boost.py

@@ -0,0 +1,33 @@
+#!/usr/bin/python
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+
+import lutinDebug as debug
+import lutinSystem
+import lutinTools as tools
+import os
+
+class System(lutinSystem.System):
+	def __init__(self):
+		lutinSystem.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:
+		if not os.path.isfile("/usr/include/boost/chrono.hpp"):
+			# we did not find the library reqiested (just return) (automaticly set at false)
+			return;
+		self.valid = True
+		# todo : create a searcher of the presence of the library:
+		self.add_export_flag_LD([
+		    "-lboost_system",
+		    "-lboost_thread",
+		    "-lboost_chrono"
+		    ])
+		
+
+

lutin/system/lutinSystem_Linux_jack.py

@@ -0,0 +1,28 @@
+#!/usr/bin/python
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+
+import lutinDebug as debug
+import lutinSystem
+import lutinTools as tools
+import os
+
+class System(lutinSystem.System):
+	def __init__(self):
+		lutinSystem.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:
+		if     not os.path.isfile("/usr/include/jack/jack.h"):
+			# we did not find the library reqiested (just return) (automaticly set at false)
+			return;
+		self.valid = True
+		# todo : create a searcher of the presence of the library:
+		self.add_export_flag_LD("-ljack")
+
+

lutin/system/lutinSystem_Linux_oss.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 lutinDebug as debug
+import lutinSystem
+import lutinTools as tools
+import os
+
+class System(lutinSystem.System):
+	def __init__(self):
+		lutinSystem.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:
+		"""
+		if     not os.path.isfile("/usr/include/jack/jack.h"):
+			# we did not find the library reqiested (just return) (automaticly set at false)
+			return;
+		self.valid = True
+		# todo : create a searcher of the presence of the library:
+		self.add_export_flag_CC("-ljack")
+		"""
+
+

lutin/system/lutinSystem_Linux_pulse.py

@@ -0,0 +1,28 @@
+#!/usr/bin/python
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+
+import lutinDebug as debug
+import lutinSystem
+import lutinTools as tools
+import os
+
+class System(lutinSystem.System):
+	def __init__(self):
+		lutinSystem.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:
+		if     not os.path.isfile("/usr/include/pulse/pulseaudio.h"):
+			# we did not find the library reqiested (just return) (automaticly set at false)
+			return;
+		self.valid = True
+		# todo : create a searcher of the presence of the library:
+		self.add_export_flag_LD(["-lpulse-simple", "-lpulse"])
+
+

lutin/system/lutinSystem_Linux_z.py

@@ -0,0 +1,28 @@
+#!/usr/bin/python
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+
+import lutinDebug as debug
+import lutinSystem
+import lutinTools as tools
+import os
+
+class System(lutinSystem.System):
+	def __init__(self):
+		lutinSystem.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"):
+			# we did not find the library reqiested (just return) (automaticly set at false)
+			return;
+		self.valid = True
+		# todo : create a searcher of the presence of the library:
+		self.add_export_flag_LD(["-lz"])
+
+

lutin/system/lutinSystem_MacOs_CoreAudio.py

@@ -0,0 +1,24 @@
+#!/usr/bin/python
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+
+import lutinDebug as debug
+import lutinSystem
+import lutinTools as tools
+import os
+
+class System(lutinSystem.System):
+	def __init__(self):
+		lutinSystem.System.__init__(self)
+		# create some HELP:
+		self.help="CoreAudio : MacOs interface for audio (all time present, just system interface)"
+		self.valid = True
+		# todo : create a searcher of the presence of the library:
+		self.add_export_flag_LD("-framework CoreAudio")
+		self.add_export_flag_LD("-framework CoreFoundation")
+

lutin/system/lutinSystem_Windows_ds.py

@@ -0,0 +1,31 @@
+#!/usr/bin/python
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+
+import lutinDebug as debug
+import lutinSystem
+import lutinTools as tools
+import os
+
+class System(lutinSystem.System):
+	def __init__(self):
+		lutinSystem.System.__init__(self)
+		# create some HELP:
+		self.help="DirectSound : Direct sound API for windows audio interface"
+		# check if the library exist:
+		if     not os.path.isfile("/usr/i686-w64-mingw32/include/dsound.h"):
+			# we did not find the library reqiested (just return) (automaticly set at false)
+			return;
+		self.valid = True
+		# todo : create a searcher of the presence of the library:
+		self.add_export_flag_LD(["-ldsound",
+		                         "-lwinmm",
+		                         "-lole32"
+		                         ])
+
+

lutin/target.py

@@ -0,0 +1,460 @@
+#!/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
+from . import debug
+from . import heritage
+import datetime
+from . import tools as lutinTools
+from . import module as lutinModule
+from . import system as lutinSystem
+from . import image as lutinImage
+from . import host as lutinHost
+from . import multiprocess
+
+class Target:
+	def __init__(self, name, config, arch):
+		self.config = config
+		
+		#processor type selection (auto/arm/ppc/x86)
+		self.selectArch = config["arch"]; # TODO : Remove THIS ...
+		#bus size selection (auto/32/64)
+		self.selectBus = config["bus-size"]; # TODO : Remove THIS ...
+		
+		if config["bus-size"] == "auto":
+			debug.error("system error ==> must generate the default 'bus-size' config")
+		if config["arch"] == "auto":
+			debug.error("system error ==> must generate the default 'bus-size' config")
+		
+		debug.debug("config=" + str(config))
+		if arch != "":
+			self.arch = "-arch " + arch
+		else:
+			self.arch = ""
+		
+		# todo : remove this :
+		self.sumulator = config["simulation"]
+		self.name=name
+		self.endGeneratePackage = config["generate-package"]
+		debug.info("=================================");
+		debug.info("== Target='" + self.name + "' " + config["bus-size"] + " bits for arch '" + config["arch"] + "'");
+		debug.info("=================================");
+		
+		self.set_cross_base()
+		
+		###############################################################################
+		# Target global variables.
+		###############################################################################
+		self.global_include_cc=[]
+		self.global_flags_cc=['-D__TARGET_OS__'+self.name,
+		                      '-D__TARGET_ARCH__'+self.selectArch,
+		                      '-D__TARGET_ADDR__'+self.selectBus + 'BITS',
+		                      '-D_REENTRANT']
+		
+		self.global_flags_xx=[]
+		self.global_flags_mm=[]
+		if self.name == "Windows":
+			self.global_flags_xx=['-static-libgcc', '-static-libstdc++']
+			self.global_flags_mm=[]
+		self.global_flags_m=[]
+		self.global_flags_ar=['rcs']
+		self.global_flags_ld=[]
+		self.global_flags_ld_shared=[]
+		self.global_libs_ld=[]
+		self.global_libs_ld_shared=[]
+		
+		self.global_sysroot=""
+		
+		self.suffix_cmdLine='.cmd'
+		self.suffix_dependence='.d'
+		self.suffix_obj='.o'
+		self.suffix_lib_static='.a'
+		self.suffix_lib_dynamic='.so'
+		self.suffix_binary=''
+		self.suffix_package='.deb'
+		
+		self.folder_arch="/" + self.name
+		
+		if "debug" == self.config["mode"]:
+			self.global_flags_cc.append("-g")
+			self.global_flags_cc.append("-DDEBUG")
+			self.global_flags_cc.append("-O0")
+		else:
+			self.global_flags_cc.append("-DNDEBUG")
+			self.global_flags_cc.append("-O3")
+		
+		## To add code coverate on build result system
+		if self.config["gcov"] == True:
+			self.global_flags_cc.append("-fprofile-arcs")
+			self.global_flags_cc.append("-ftest-coverage")
+			self.global_flags_ld.append("-fprofile-arcs")
+			self.global_flags_ld.append("-ftest-coverage")
+		
+		self.update_folder_tree()
+		self.folder_bin="/usr/bin"
+		self.folder_lib="/usr/lib"
+		self.folder_data="/usr/share"
+		self.folder_doc="/usr/share/doc"
+		self.buildDone=[]
+		self.buildTreeDone=[]
+		self.moduleList=[]
+		# output staging files list :
+		self.listFinalFile=[]
+		
+		self.sysroot=""
+	
+	def update_folder_tree(self):
+		self.folder_out="/out/" + self.name + "_" + self.config["arch"] + "_" + self.config["bus-size"] + "/" + self.config["mode"]
+		self.folder_final="/final/" + self.config["compilator"]
+		self.folder_staging="/staging/" + self.config["compilator"]
+		self.folder_build="/build/" + self.config["compilator"]
+	
+	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:
+			out += offset*int(elem)
+			debug.verbose("get : " + str(int(elem)) + " tmp" + str(out))
+			offset /= 1000
+		return out
+	
+	def set_cross_base(self, cross=""):
+		self.cross = cross
+		debug.debug("== Target='" + self.cross + "'");
+		self.ar = self.cross + "ar"
+		self.ranlib = self.cross + "ranlib"
+		if self.config["compilator"] == "clang":
+			self.cc = self.cross + "clang"
+			self.xx = self.cross + "clang++"
+			#self.ar=self.cross + "llvm-ar"
+			#self.ranlib="ls"
+		else:
+			self.cc = self.cross + "gcc"
+			self.xx = self.cross + "g++"
+			#self.ar=self.cross + "ar"
+			#self.ranlib=self.cross + "ranlib"
+		
+		#get g++ compilation version :
+		ret = multiprocess.run_command_direct(self.xx + " -dumpversion");
+		if ret == False:
+			debug.error("Can not get the g++/clang++ version ...")
+		self.xx_version = self.create_number_from_version_string(ret)
+		debug.verbose(self.config["compilator"] + "++ version=" + str(ret) + " number=" + str(self.xx_version))
+		
+		self.ld = self.cross + "ld"
+		self.nm = self.cross + "nm"
+		self.strip = self.cross + "strip"
+		self.dlltool = self.cross + "dlltool"
+		self.update_folder_tree()
+	
+	def get_build_mode(self):
+		return self.config["mode"]
+	
+	def add_image_staging(self, inputFile, outputFile, sizeX, sizeY, cmdFile=None):
+		for source, dst, x, y, cmdFile2 in self.listFinalFile:
+			if dst == outputFile :
+				debug.verbose("already added : " + outputFile)
+				return
+		debug.verbose("add file : '" + inputFile + "' ==> '" + outputFile + "'")
+		self.listFinalFile.append([inputFile,outputFile, sizeX, sizeY, cmdFile])
+	
+	def add_file_staging(self, inputFile, outputFile, cmdFile=None):
+		for source, dst, x, y, cmdFile2 in self.listFinalFile:
+			if dst == outputFile :
+				debug.verbose("already added : " + outputFile)
+				return
+		debug.verbose("add file : '" + inputFile + "' ==> '" + outputFile + "'");
+		self.listFinalFile.append([inputFile, outputFile, -1, -1, cmdFile])
+	
+	def copy_to_staging(self, binaryName):
+		baseFolder = self.get_staging_folder_data(binaryName)
+		for source, dst, x, y, cmdFile in self.listFinalFile:
+			if     cmdFile != None \
+			   and cmdFile != "":
+				debug.verbose("cmd file " + cmdFile)
+			if x == -1:
+				debug.verbose("must copy file : '" + source + "' ==> '" + dst + "'");
+				lutinTools.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)
+	
+	
+	def clean_module_tree(self):
+		self.buildTreeDone = []
+		self.listFinalFile = []
+	
+	
+	# TODO : Remove this hack ... ==> really bad ... but usefull
+	def set_ewol_folder(self, folder):
+		self.folder_ewol = folder
+	
+	
+	def file_generate_object(self,binaryName,moduleName,basePath,file):
+		list=[]
+		list.append(basePath + "/" + file)
+		list.append(self.get_build_folder(moduleName) + "/" + file + self.suffix_obj)
+		list.append(self.get_build_folder(moduleName) + "/" + file + self.suffix_dependence)
+		list.append(self.get_build_folder(moduleName) + "/" + file + self.suffix_cmdLine)
+		return list
+	"""
+		return a list of 3 elements :
+			0 : sources files (can be a list)
+			1 : destination file
+			2 : dependence files module (*.d)
+	"""
+	def generate_file(self,binaryName,moduleName,basePath,file,type):
+		list=[]
+		if (type=="bin"):
+			list.append(file)
+			list.append(self.get_staging_folder(binaryName) + "/" + self.folder_bin + "/" + moduleName + self.suffix_binary)
+			list.append(self.get_build_folder(moduleName) + "/" + moduleName + self.suffix_dependence)
+			list.append(self.get_build_folder(binaryName) + "/" + self.folder_bin + "/" + moduleName + self.suffix_cmdLine)
+		elif (type=="lib-shared"):
+			list.append(file)
+			list.append(self.get_staging_folder(binaryName) + "/" + self.folder_lib + "/" + moduleName + self.suffix_lib_dynamic)
+			list.append(self.get_build_folder(moduleName) + "/" + moduleName + self.suffix_dependence)
+			list.append(self.get_build_folder(binaryName) + "/" + self.folder_lib + "/" + moduleName + self.suffix_cmdLine)
+		elif (type=="lib-static"):
+			list.append(file)
+			list.append(self.get_build_folder(moduleName) + "/" + moduleName + self.suffix_lib_static)
+			list.append(self.get_build_folder(moduleName) + "/" + moduleName + self.suffix_dependence)
+			list.append(self.get_build_folder(moduleName) + "/" + moduleName + self.suffix_cmdLine)
+		elif (type=="image"):
+			list.append(self.get_build_folder(binaryName) + "/data/" + file + self.suffix_cmdLine)
+		else:
+			debug.error("unknow type : " + type)
+		return list
+	
+	def get_final_folder(self):
+		return lutinTools.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
+	
+	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
+	
+	def get_doc_folder(self, moduleName):
+		return lutinTools.get_run_folder() + self.folder_out + self.folder_doc + "/" + moduleName
+	
+	def is_module_build(self, module):
+		for mod in self.buildDone:
+			if mod == module:
+				return True
+		self.buildDone.append(module)
+		return False
+	
+	def is_module_buildTree(self, module):
+		for mod in self.buildTreeDone:
+			if mod == module:
+				return True
+		self.buildTreeDone.append(module)
+		return False
+	
+	def add_module(self, newModule):
+		debug.debug("Add nodule for Taget : " + newModule.name)
+		self.moduleList.append(newModule)
+	
+	
+	# return inherit packages ...
+	"""
+	def build(self, name, packagesName):
+		for module in self.moduleList:
+			if module.name == name:
+				return module.build(self, packagesName)
+		debug.error("request to build an un-existant module name : '" + name + "'")
+	"""
+	
+	def build_tree(self, name, packagesName):
+		for module in self.moduleList:
+			if module.name == name:
+				module.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)
+				return
+		debug.error("request to clean an un-existant module name : '" + name + "'")
+	
+	def load_if_needed(self, name, optionnal=False):
+		for elem in self.moduleList:
+			if elem.name == name:
+				return True
+		if optionnal == False:
+			lutinModule.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)
+			if exist == True:
+				lutinSystem.load(self, name, self.name)
+				return True;
+			# try to find in the local Modules:
+			exist = lutinModule.exist(self, name)
+			if exist == True:
+				lutinModule.load_module(self, name)
+				return True;
+			else:
+				return False;
+	
+	def load_all(self):
+		listOfAllTheModule = lutinModule.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)
+				return
+	
+	def build_optionnal(self, moduleName, packagesName=None):
+		present = self.load_if_needed(moduleName, optionnal=True)
+		if present == False:
+			return [heritage.HeritageList(), False]
+		# clean requested
+		for mod in self.moduleList:
+			if mod.name == moduleName:
+				debug.debug("build module '" + moduleName + "'")
+				return [mod.build(self, None), True]
+		debug.warning("not know module name : '" + moduleName + "' to '" + "build" + "' it")
+		return [heritage.HeritageList(), False]
+	
+	def build(self, name, packagesName=None):
+		if name == "dump":
+			debug.info("dump all")
+			self.load_all()
+			for mod in self.moduleList:
+				mod.display(self)
+			return
+		if name == "all":
+			debug.info("build all")
+			self.load_all()
+			for mod in self.moduleList:
+				if self.name=="Android":
+					if mod.type == "PACKAGE":
+						mod.build(self, None)
+				else:
+					if    mod.type == "BINARY" \
+					   or mod.type == "PACKAGE":
+						mod.build(self, None)
+		elif name == "clean":
+			debug.info("clean all")
+			self.load_all()
+			for mod in self.moduleList:
+				mod.clean(self)
+		else:
+			# get the action an the module ....
+			gettedElement = name.split("?")
+			moduleName = gettedElement[0]
+			if len(gettedElement)>=2:
+				actionName = gettedElement[1]
+			else :
+				actionName = "build"
+			debug.verbose("requested : " + moduleName + "-" + actionName)
+			if actionName == "install":
+				self.build(moduleName + "?build")
+				self.install_package(moduleName)
+			elif actionName == "uninstall":
+				self.un_install_package(moduleName)
+			elif actionName == "log":
+				self.Log(moduleName)
+			else:
+				self.load_if_needed(moduleName)
+				# clean requested
+				for mod in self.moduleList:
+					if mod.name == moduleName:
+						if actionName == "dump":
+							debug.info("dump module '" + moduleName + "'")
+							return mod.display(self)
+						elif actionName == "clean":
+							debug.info("clean module '" + moduleName + "'")
+							return mod.clean(self)
+						elif actionName == "build":
+							debug.debug("build module '" + moduleName + "'")
+							return mod.build(self, None)
+				debug.error("not know module name : '" + moduleName + "' to '" + actionName + "' it")
+
+
+targetList=[]
+__startTargetName="lutinTarget_"
+
+
+def import_path(path):
+	global targetList
+	matches = []
+	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('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("TARGET:     integrate module: '" + targetName + "' from '" + os.path.join(root, filename) + "'")
+			targetList.append([targetName,os.path.join(root, filename)])
+
+
+def load_target(name, config):
+	global targetList
+	debug.debug("load target: " + name)
+	if len(targetList) == 0:
+		debug.error("No target to compile !!!")
+	debug.debug("list target: " + str(targetList))
+	for mod in targetList:
+		if mod[0] == name:
+			debug.verbose("add to path: '" + os.path.dirname(mod[1]) + "'")
+			sys.path.append(os.path.dirname(mod[1]))
+			debug.verbose("import target : '" + __startTargetName + name + "'")
+			theTarget = __import__(__startTargetName + name)
+			#create the target
+			tmpTarget = theTarget.Target(config)
+			return tmpTarget
+	raise KeyError("No entry for : " + name)
+
+def list_all_target():
+	global targetList
+	tmpListName = []
+	for mod in targetList:
+		tmpListName.append(mod[0])
+	return tmpListName
+
+def list_all_target_with_desc():
+	global targetList
+	tmpList = []
+	for mod in targetList:
+		sys.path.append(os.path.dirname(mod[1]))
+		theTarget = __import__(__startTargetName + mod[0])
+		try:
+			tmpdesc = theTarget.get_desc()
+			tmpList.append([mod[0], tmpdesc])
+		except:
+			debug.warning("has no name : " + mod[0])
+			tmpList.append([mod[0], ""])
+	return tmpList

lutin/target/lutinTarget_Android.py

@@ -0,0 +1,748 @@
+#!/usr/bin/python
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+
+
+import lutinDebug as debug
+import lutinTarget
+import lutinTools as tools
+import lutinHost
+import lutinImage
+import lutinMultiprocess
+import lutinHost
+import os
+import sys
+
+class Target(lutinTarget.Target):
+	def __init__(self, config):
+		#processor type selection (auto/arm/ppc/x86)
+		if config["arch"] == "auto":
+			config["arch"] = "arm"
+		#bus size selection (auto/32/64)
+		if config["bus-size"] == "auto":
+			config["bus-size"] = "32"
+		
+		arch = ""#"ARMv7"
+		lutinTarget.Target.__init__(self, "Android", config, arch)
+		
+		self.folder_ndk = os.getenv('PROJECT_NDK', "AUTO")
+		self.folder_sdk = os.getenv('PROJECT_SDK', "AUTO")
+		# auto search NDK
+		if self.folder_ndk == "AUTO":
+			for folder in os.listdir("."):
+				if os.path.isdir(folder)==True:
+					if folder=="android":
+						self.folder_ndk = folder + "/ndk"
+			if self.folder_ndk == "AUTO":
+				self.folder_ndk = tools.get_run_folder() + "/../android/ndk"
+		# auto search SDK
+		if self.folder_sdk == "AUTO":
+			for folder in os.listdir("."):
+				if os.path.isdir(folder)==True:
+					if folder=="android":
+						self.folder_sdk = folder + "/sdk"
+			if self.folder_sdk == "AUTO":
+				self.folder_sdk = tools.get_run_folder() + "/../android/sdk"
+		
+		if not os.path.isdir(self.folder_ndk):
+			debug.error("NDK path not set !!! set env : PROJECT_NDK on the NDK path")
+		if not os.path.isdir(self.folder_sdk):
+			debug.error("SDK path not set !!! set env : PROJECT_SDK on the SDK path")
+		
+		
+		tmpOsVal = "64"
+		gccVersion = "4.9"
+		if lutinHost.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/")
+		else:
+			baseFolderArm = self.folder_ndk + "/toolchains/arm-linux-androideabi-" + gccVersion + "/prebuilt/linux-x86" + tmpOsVal + "/bin/"
+			baseFolderMips = self.folder_ndk + "/toolchains/mipsel-linux-android-" + gccVersion + "/prebuilt/linux-x86" + tmpOsVal + "/bin/"
+			baseFolderX86 = self.folder_ndk + "/toolchains/x86-" + gccVersion + "/prebuilt/linux-x86" + tmpOsVal + "/bin/"
+			self.set_cross_base(baseFolderArm + "arm-linux-androideabi-")
+			if not os.path.isdir(baseFolderArm):
+				debug.error("Gcc Arm path does not exist !!!")
+			if not os.path.isdir(baseFolderMips):
+				debug.info("Gcc Mips path does not exist !!!")
+			if not os.path.isdir(baseFolderX86):
+				debug.info("Gcc x86 path does not exist !!!")
+		
+		arch = "ARMv7"
+		# for gcc :
+		
+		# for clang :
+		
+		
+		self.folder_bin="/mustNotCreateBinary"
+		self.folder_lib="/data/lib/armeabi"
+		self.folder_data="/data/assets"
+		self.folder_doc="/doc"
+		self.suffix_package='.pkg'
+		
+		# board id at 14 is for android 4.0 and more ...
+		self.boardId = 14
+		if arch == "ARMv5" or arch == "ARMv7":
+			self.global_include_cc.append("-I" + self.folder_ndk +"/platforms/android-" + str(self.boardId) + "/arch-arm/usr/include/")
+		elif arch == "mips":
+			self.global_include_cc.append("-I" + self.folder_ndk +"/platforms/android-" + str(self.boardId) + "/arch-mips/usr/include/")
+		elif arch == "x86":
+			self.global_include_cc.append("-I" + self.folder_ndk +"/platforms/android-" + str(self.boardId) + "/arch-x86/usr/include/")
+		
+		if True:
+			if self.config["compilator"] == "clang":
+				self.global_include_cc.append("-I" + self.folder_ndk +"/sources/cxx-stl/llvm-libc++/libcxx/include/")
+				if arch == "ARMv5":
+					stdCppBasePath = self.folder_ndk +"/sources/cxx-stl/llvm-libc++/libcxx/libs/armeabi/"
+					self.global_include_cc.append("-I" + stdCppBasePath + "include/")
+					self.global_flags_ld.append(         stdCppBasePath + "libc++_static.a")
+				elif arch == "ARMv7":
+					stdCppBasePath = self.folder_ndk +"/sources/cxx-stl/llvm-libc++/libcxx/libs/armeabi-v7a/"
+					self.global_include_cc.append("-I" + stdCppBasePath + "include/")
+					self.global_flags_ld.append(         stdCppBasePath + "libc++_static.a")
+				elif arch == "mips":
+					stdCppBasePath = self.folder_ndk +"/sources/cxx-stl/llvm-libc++/libcxx/libs/mips/"
+					self.global_include_cc.append("-I" + stdCppBasePath + "include/")
+					self.global_flags_ld.append(         stdCppBasePath + "libc++_static.a")
+				elif arch == "x86":
+					stdCppBasePath = self.folder_ndk +"/sources/cxx-stl/llvm-libc++/libcxx/libs/x86/"
+					self.global_include_cc.append("-I" + stdCppBasePath + "include/")
+					self.global_flags_ld.append(         stdCppBasePath + "libc++_static.a")
+			else:
+				self.global_include_cc.append("-I" + self.folder_ndk +"/sources/cxx-stl/gnu-libstdc++/" + gccVersion + "/include/")
+				if arch == "ARMv5":
+					stdCppBasePath = self.folder_ndk +"/sources/cxx-stl/gnu-libstdc++/" + gccVersion + "/libs/armeabi/"
+					self.global_include_cc.append("-I" + stdCppBasePath + "include/")
+					self.global_flags_ld.append(         stdCppBasePath + "thumb/libgnustl_static.a")
+					self.global_flags_ld.append(         stdCppBasePath + "thumb/libsupc++.a")
+				elif arch == "ARMv7":
+					stdCppBasePath = self.folder_ndk +"/sources/cxx-stl/gnu-libstdc++/" + gccVersion + "/libs/armeabi-v7a/"
+					self.global_include_cc.append("-I" + stdCppBasePath + "include/")
+					self.global_flags_ld.append(         stdCppBasePath + "thumb/libgnustl_static.a")
+					self.global_flags_ld.append(         stdCppBasePath + "thumb/libsupc++.a")
+				elif arch == "mips":
+					stdCppBasePath = self.folder_ndk +"/sources/cxx-stl/gnu-libstdc++/" + gccVersion + "/libs/mips/"
+					self.global_include_cc.append("-I" + stdCppBasePath + "include/")
+					self.global_flags_ld.append(         stdCppBasePath + "libgnustl_static.a")
+					self.global_flags_ld.append(         stdCppBasePath + "libsupc++.a")
+				elif arch == "x86":
+					stdCppBasePath = self.folder_ndk +"/sources/cxx-stl/gnu-libstdc++/" + gccVersion + "/libs/x86/"
+					self.global_include_cc.append("-I" + stdCppBasePath + "include/")
+					self.global_flags_ld.append(         stdCppBasePath + "libgnustl_static.a")
+					self.global_flags_ld.append(         stdCppBasePath + "libsupc++.a")
+		else :
+			self.global_include_cc.append("-I" + self.folder_ndk +"/sources/cxx-stl/system/include/")
+			self.global_include_cc.append("-I" + self.folder_ndk +"/sources/cxx-stl/stlport/stlport/")
+			self.global_flags_ld.append(self.folder_ndk +"/platforms/android-" + str(self.boardId) + "/arch-arm/usr/lib/libstdc++.a")
+		
+		self.global_sysroot = "--sysroot=" + self.folder_ndk +"/platforms/android-" + str(self.boardId) + "/arch-arm"
+		
+		self.global_flags_cc.append("-D__ARM_ARCH_5__")
+		self.global_flags_cc.append("-D__ARM_ARCH_5T__")
+		self.global_flags_cc.append("-D__ARM_ARCH_5E__")
+		self.global_flags_cc.append("-D__ARM_ARCH_5TE__")
+		if self.arch == "ARM":
+			# -----------------------
+			# -- arm V5 :
+			# -----------------------
+			self.global_flags_cc.append("-march=armv5te")
+			self.global_flags_cc.append("-msoft-float")
+		else:
+			# -----------------------
+			# -- arm V7 (Neon) :
+			# -----------------------
+			self.global_flags_cc.append("-mfpu=neon")
+			self.global_flags_cc.append("-mfloat-abi=softfp")
+			self.global_flags_ld.append("-mfpu=neon")
+			self.global_flags_ld.append("-mfloat-abi=softfp")
+			self.global_flags_cc.append("-D__ARM_ARCH_7__")
+			self.global_flags_cc.append("-D__ARM_NEON__")
+		
+		# the -mthumb must be set for all the android produc, some ot the not work coretly without this one ... (all android code is generated with this flags)
+		self.global_flags_cc.append("-mthumb")
+		# -----------------------
+		# -- Common flags :
+		# -----------------------
+		self.global_flags_cc.append("-fpic")
+		self.global_flags_cc.append("-ffunction-sections")
+		self.global_flags_cc.append("-funwind-tables")
+		self.global_flags_cc.append("-fstack-protector")
+		self.global_flags_cc.append("-Wno-psabi")
+		self.global_flags_cc.append("-mtune=xscale")
+		self.global_flags_cc.append("-fexceptions")
+		##self.global_flags_cc.append("-fno-exceptions")
+		self.global_flags_cc.append("-fomit-frame-pointer")
+		self.global_flags_cc.append("-fno-strict-aliasing")
+		
+		self.global_flags_xx.append("-frtti")
+		self.global_flags_xx.append("-Wa,--noexecstack")
+		
+		
+	
+	def check_right_package(self, pkgProperties, value):
+		for val in pkgProperties["RIGHT"]:
+			if value == val:
+				return True
+		return False
+	
+	def get_staging_folder_data(self, binaryName):
+		return self.get_staging_folder(binaryName) + self.folder_data
+	
+	def make_package(self, pkgName, pkgProperties, basePkgPath):
+		# http://alp.developpez.com/tutoriels/debian/creer-paquet/
+		debug.debug("------------------------------------------------------------------------")
+		debug.info("Generate package '" + pkgName + "'")
+		debug.debug("------------------------------------------------------------------------")
+		pkgNameApplicationName = pkgName
+		if self.config["mode"] == "debug":
+			pkgNameApplicationName += "debug"
+		# FINAL_FOLDER_JAVA_PROJECT
+		self.folder_javaProject=   self.get_staging_folder(pkgName) \
+		                         + "/src/" \
+		                         + pkgProperties["COMPAGNY_TYPE"] \
+		                         + "/" + pkgProperties["COMPAGNY_NAME2"] \
+		                         + "/" + pkgNameApplicationName + "/"
+		#FINAL_FILE_ABSTRACTION
+		self.file_finalAbstraction = self.folder_javaProject + "/" + pkgNameApplicationName + ".java"
+		
+		compleatePackageName = pkgProperties["COMPAGNY_TYPE"]+"."+pkgProperties["COMPAGNY_NAME2"]+"." + pkgNameApplicationName
+		
+		if "ADMOD_ID" in pkgProperties:
+			pkgProperties["RIGHT"].append("INTERNET")
+			pkgProperties["RIGHT"].append("ACCESS_NETWORK_STATE")
+		
+		
+		debug.print_element("pkg", "absractionFile", "<==", "dynamic file")
+		# Create folder :
+		tools.create_directory_of_file(self.file_finalAbstraction)
+		# Create file :
+		tmpFile = open(self.file_finalAbstraction, 'w')
+		if pkgProperties["ANDROID_APPL_TYPE"]=="APPL":
+			tmpFile.write( "/**\n")
+			tmpFile.write( " * @author Edouard DUPIN, Kevin BILLONNEAU\n")
+			tmpFile.write( " * @copyright 2011, Edouard DUPIN, all right reserved\n")
+			tmpFile.write( " * @license APACHE v2.0 (see license file)\n")
+			tmpFile.write( " * @note This file is autogenerate ==> see documantation to generate your own\n")
+			tmpFile.write( " */\n")
+			tmpFile.write( "package "+ compleatePackageName + ";\n")
+			tmpFile.write( "import org.ewol.EwolActivity;\n")
+			if "ADMOD_ID" in pkgProperties:
+				tmpFile.write( "import com.google.android.gms.ads.AdRequest;\n")
+				tmpFile.write( "import com.google.android.gms.ads.AdSize;\n")
+				tmpFile.write( "import com.google.android.gms.ads.AdView;\n")
+				tmpFile.write( "import android.widget.LinearLayout;\n")
+				tmpFile.write( "import android.widget.Button;\n")
+			tmpFile.write( "public class " + pkgNameApplicationName + " extends EwolActivity {\n")
+			if "ADMOD_ID" in pkgProperties:
+				tmpFile.write( "	/** The view to show the ad. */\n")
+				tmpFile.write( "	private AdView adView;\n")
+				tmpFile.write( "	private LinearLayout mLayout = null;\n")
+			tmpFile.write( "	public void onCreate(android.os.Bundle savedInstanceState) {\n")
+			tmpFile.write( "		super.onCreate(savedInstanceState);\n")
+			tmpFile.write( "		initApkPath(\"" + pkgProperties["COMPAGNY_TYPE"]+"\", \""+pkgProperties["COMPAGNY_NAME2"]+"\", \"" + pkgNameApplicationName + "\");\n")
+			if "ADMOD_ID" in pkgProperties:
+				tmpFile.write( "		mLayout = new LinearLayout(this);\n")
+				tmpFile.write( "		mLayout.setOrientation(android.widget.LinearLayout.VERTICAL);\n")
+				tmpFile.write( "		LinearLayout.LayoutParams paramsWindows = new LinearLayout.LayoutParams(\n")
+				tmpFile.write( "			LinearLayout.LayoutParams.FILL_PARENT,\n")
+				tmpFile.write( "			LinearLayout.LayoutParams.FILL_PARENT);\n")
+				tmpFile.write( "		\n")
+				tmpFile.write( "		setContentView(mLayout, paramsWindows);\n")
+				tmpFile.write( "		\n")
+				tmpFile.write( "		LinearLayout.LayoutParams paramsAdds = new LinearLayout.LayoutParams(\n")
+				tmpFile.write( "			LinearLayout.LayoutParams.FILL_PARENT,\n")
+				tmpFile.write( "			LinearLayout.LayoutParams.WRAP_CONTENT);\n")
+				tmpFile.write( "		paramsAdds.weight = 0;\n")
+				tmpFile.write( "		\n")
+				tmpFile.write( "		LinearLayout.LayoutParams paramsGLView = new LinearLayout.LayoutParams(\n")
+				tmpFile.write( "			LinearLayout.LayoutParams.FILL_PARENT,\n")
+				tmpFile.write( "			LinearLayout.LayoutParams.FILL_PARENT);\n")
+				tmpFile.write( "		paramsGLView.weight = 1;\n")
+				tmpFile.write( "		paramsGLView.height = 0;\n")
+				tmpFile.write( "		\n")
+				tmpFile.write( "		mLayout.setGravity(android.view.Gravity.TOP);\n")
+				tmpFile.write( "		\n")
+				tmpFile.write( "		// Create an adds.\n")
+				tmpFile.write( "		adView = new AdView(this);\n")
+				tmpFile.write( "		adView.setAdSize(AdSize.SMART_BANNER);\n")
+				tmpFile.write( "		adView.setAdUnitId(\"" + pkgProperties["ADMOD_ID"] + "\");\n")
+				tmpFile.write( "		\n")
+				tmpFile.write( "		// Create an ad request. Check logcat output for the hashed device ID to get test ads on a physical device.\n")
+				tmpFile.write( "		AdRequest adRequest = new AdRequest.Builder()\n")
+				tmpFile.write( "			.addTestDevice(AdRequest.DEVICE_ID_EMULATOR)\n")
+				tmpFile.write( "			.build();\n")
+				tmpFile.write( "		\n")
+				tmpFile.write( "		// Add the AdView to the view hierarchy. The view will have no size until the ad is loaded.\n")
+				if     "ADMOD_POSITION" in pkgProperties.keys() \
+				   and pkgProperties["ADMOD_POSITION"] == "top":
+					tmpFile.write( "		mLayout.addView(adView, paramsAdds);\n")
+					tmpFile.write( "		mLayout.addView(mGLView, paramsGLView);\n")
+				else:
+					tmpFile.write( "		mLayout.addView(mGLView, paramsGLView);\n")
+					tmpFile.write( "		mLayout.addView(adView, paramsAdds);\n")
+				tmpFile.write( "		\n")
+				tmpFile.write( "		// Start loading the ad in the background.\n")
+				tmpFile.write( "		adView.loadAd(adRequest);\n")
+			tmpFile.write( "	}\n")
+			if "ADMOD_ID" in pkgProperties:
+				tmpFile.write( "	@Override protected void onResume() {\n")
+				tmpFile.write( "		super.onResume();\n")
+				tmpFile.write( "		if (adView != null) {\n")
+				tmpFile.write( "			adView.resume();\n")
+				tmpFile.write( "		}\n")
+				tmpFile.write( "	}\n")
+				tmpFile.write( "	@Override protected void onPause() {\n")
+				tmpFile.write( "		if (adView != null) {\n")
+				tmpFile.write( "			adView.pause();\n")
+				tmpFile.write( "		}\n")
+				tmpFile.write( "		super.onPause();\n")
+				tmpFile.write( "	}\n")
+				tmpFile.write( "	@Override protected void onDestroy() {\n")
+				tmpFile.write( "		// Destroy the AdView.\n")
+				tmpFile.write( "		if (adView != null) {\n")
+				tmpFile.write( "			adView.destroy();\n")
+				tmpFile.write( "		}\n")
+				tmpFile.write( "		super.onDestroy();\n")
+				tmpFile.write( "	}\n")
+			tmpFile.write( "}\n")
+		else :
+			# wallpaper mode ...
+			tmpFile.write( "/**\n")
+			tmpFile.write( " * @author Edouard DUPIN, Kevin BILLONNEAU\n")
+			tmpFile.write( " * @copyright 2011, Edouard DUPIN, all right reserved\n")
+			tmpFile.write( " * @license APACHE v2.0 (see license file)\n")
+			tmpFile.write( " * @note This file is autogenerate ==> see documantation to generate your own\n")
+			tmpFile.write( " */\n")
+			tmpFile.write( "package "+ compleatePackageName + ";\n")
+			tmpFile.write( "import org.ewol.EwolWallpaper;\n")
+			tmpFile.write( "public class " + pkgNameApplicationName + " extends EwolWallpaper {\n")
+			tmpFile.write( "	public static final String SHARED_PREFS_NAME = \"" + pkgNameApplicationName + "settings\";\n")
+			tmpFile.write( "	public Engine onCreateEngine() {\n")
+			tmpFile.write( "		Engine tmpEngine = super.onCreateEngine();\n")
+			tmpFile.write( "		initApkPath(\"" + pkgProperties["COMPAGNY_TYPE"]+"\", \""+pkgProperties["COMPAGNY_NAME2"]+"\", \"" + pkgNameApplicationName + "\");\n")
+			tmpFile.write( "		return tmpEngine;\n")
+			tmpFile.write( "	}\n")
+			tmpFile.write( "}\n")
+		tmpFile.flush()
+		tmpFile.close()
+		
+		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)
+		else:
+			# to be sure that we have all time a resource ...
+			tmpFile = open(self.get_staging_folder(pkgName) + "/res/drawable/plop.txt", 'w')
+			tmpFile.write('plop\n')
+			tmpFile.flush()
+			tmpFile.close()
+		
+		if pkgProperties["ANDROID_MANIFEST"]!="":
+			debug.print_element("pkg", "AndroidManifest.xml", "<==", pkgProperties["ANDROID_MANIFEST"])
+			tools.copy_file(pkgProperties["ANDROID_MANIFEST"], self.get_staging_folder(pkgName) + "/AndroidManifest.xml", force=True)
+		else:
+			if "VERSION_CODE" not in pkgProperties:
+				pkgProperties["VERSION_CODE"] = "1"
+			debug.print_element("pkg", "AndroidManifest.xml", "<==", "package configurations")
+			tmpFile = open(self.get_staging_folder(pkgName) + "/AndroidManifest.xml", 'w')
+			tmpFile.write( '<?xml version="1.0" encoding="utf-8"?>\n')
+			tmpFile.write( '<!-- Manifest is autoGenerated with Ewol ... do not patch it-->\n')
+			tmpFile.write( '<manifest xmlns:android="http://schemas.android.com/apk/res/android" \n')
+			tmpFile.write( '          package="' + compleatePackageName + '" \n')
+			tmpFile.write( '          android:versionCode="'+pkgProperties["VERSION_CODE"]+'" \n')
+			tmpFile.write( '          android:versionName="'+pkgProperties["VERSION"]+'"> \n')
+			tmpFile.write( '	<uses-feature android:glEsVersion="0x00020000" android:required="true" />\n')
+			tmpFile.write( '	<uses-sdk android:minSdkVersion="' + str(self.boardId) + '" \n')
+			tmpFile.write( '	          android:targetSdkVersion="' + str(self.boardId) + '" /> \n')
+			if pkgProperties["ANDROID_APPL_TYPE"]=="APPL":
+				tmpFile.write( '	<application android:label="' + pkgNameApplicationName + '" \n')
+				if "ICON" in pkgProperties.keys():
+					tmpFile.write( '	             android:icon="@drawable/icon" \n')
+				if self.config["mode"] == "debug":
+					tmpFile.write( '	             android:debuggable="true" \n')
+				tmpFile.write( '	             >\n')
+				if "ADMOD_ID" in pkgProperties:
+					tmpFile.write( '		<meta-data android:name="com.google.android.gms.version" \n')
+					tmpFile.write( '		           android:value="@integer/google_play_services_version"/>\n')
+				
+				tmpFile.write( '		<activity android:name=".' + pkgNameApplicationName + '" \n')
+				tmpFile.write( '		          android:label="' + pkgProperties['NAME'])
+				if self.config["mode"] == "debug":
+					tmpFile.write("-debug")
+				tmpFile.write( '"\n')
+				if "ICON" in pkgProperties.keys():
+					tmpFile.write( '		          android:icon="@drawable/icon" \n')
+				tmpFile.write( '		          android:hardwareAccelerated="true" \n')
+				tmpFile.write( '		          android:configChanges="keyboard|keyboardHidden|orientation|screenSize"> \n')
+				tmpFile.write( '			<intent-filter> \n')
+				tmpFile.write( '				<action android:name="android.intent.action.MAIN" /> \n')
+				tmpFile.write( '				<category android:name="android.intent.category.LAUNCHER" /> \n')
+				tmpFile.write( '			</intent-filter> \n')
+				tmpFile.write( '		</activity> \n')
+				if "ADMOD_ID" in pkgProperties:
+					tmpFile.write( '		<activity android:name="com.google.android.gms.ads.AdActivity"\n')
+					tmpFile.write( '		          android:configChanges="keyboard|keyboardHidden|orientation|screenLayout|uiMode|screenSize|smallestScreenSize"/>\n')
+				
+				tmpFile.write( '	</application>\n')
+			else:
+				tmpFile.write( '	<application android:label="' + pkgNameApplicationName + '" \n')
+				tmpFile.write( '	             android:permission="android.permission.BIND_WALLPAPER" \n')
+				if "ICON" in pkgProperties.keys():
+					tmpFile.write( '	             android:icon="@drawable/icon"\n')
+				tmpFile.write( '	             >\n')
+				tmpFile.write( '		<service android:name=".' + pkgNameApplicationName + '" \n')
+				tmpFile.write( '		         android:label="' + pkgProperties['NAME'])
+				if self.config["mode"] == "debug":
+					tmpFile.write("-debug")
+				tmpFile.write( '"\n')
+				if "ICON" in pkgProperties.keys():
+					tmpFile.write( '		         android:icon="@drawable/icon"\n')
+				tmpFile.write( '		         >\n')
+				tmpFile.write( '			<intent-filter>\n')
+				tmpFile.write( '				<action android:name="android.service.wallpaper.WallpaperService" />\n')
+				tmpFile.write( '			</intent-filter>\n')
+				tmpFile.write( '			<meta-data android:name="android.service.wallpaper"\n')
+				tmpFile.write( '			           android:resource="@xml/' + pkgNameApplicationName + '_resource" />\n')
+				tmpFile.write( '		</service>\n')
+				if len(pkgProperties["ANDROID_WALLPAPER_PROPERTIES"])!=0:
+					tmpFile.write( '		<activity android:label="Setting"\n')
+					tmpFile.write( '		          android:name=".' + pkgNameApplicationName + 'Settings"\n')
+					tmpFile.write( '		          android:theme="@android:style/Theme.Light.WallpaperSettings"\n')
+					tmpFile.write( '		          android:exported="true"\n')
+					if "ICON" in pkgProperties.keys():
+						tmpFile.write( '		          android:icon="@drawable/icon"\n')
+					tmpFile.write( '		          >\n')
+					tmpFile.write( '		</activity>\n')
+				tmpFile.write( '	</application>\n')
+			# write package autorisations :
+			if True==self.check_right_package(pkgProperties, "WRITE_EXTERNAL_STORAGE"):
+				tmpFile.write( '	<permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" /> \n')
+				tmpFile.write( '	<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" /> \n')
+			if True==self.check_right_package(pkgProperties, "CAMERA"):
+				tmpFile.write( '	<permission android:name="android.permission.CAMERA" /> \n')
+				tmpFile.write( '	<uses-permission android:name="android.permission.CAMERA" /> \n')
+			if True==self.check_right_package(pkgProperties, "INTERNET"):
+				tmpFile.write( '	<permission android:name="android.permission.INTERNET" /> \n')
+				tmpFile.write( '	<uses-permission android:name="android.permission.INTERNET" /> \n')
+			if True==self.check_right_package(pkgProperties, "ACCESS_NETWORK_STATE"):
+				tmpFile.write( '	<permission android:name="android.permission.ACCESS_NETWORK_STATE" /> \n')
+				tmpFile.write( '	<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" /> \n')
+			if True==self.check_right_package(pkgProperties, "MODIFY_AUDIO_SETTINGS"):
+				tmpFile.write( '	<permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" /> \n')
+				tmpFile.write( '	<uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" /> \n')
+			if True==self.check_right_package(pkgProperties, "READ_CALENDAR"):
+				tmpFile.write( '	<permission android:name="android.permission.READ_CALENDAR" /> \n')
+				tmpFile.write( '	<uses-permission android:name="android.permission.READ_CALENDAR" /> \n')
+			if True==self.check_right_package(pkgProperties, "READ_CONTACTS"):
+				tmpFile.write( '	<permission android:name="android.permission.READ_CONTACTS" /> \n')
+				tmpFile.write( '	<uses-permission android:name="android.permission.READ_CONTACTS" /> \n')
+			if True==self.check_right_package(pkgProperties, "READ_FRAME_BUFFER"):
+				tmpFile.write( '	<permission android:name="android.permission.READ_FRAME_BUFFER" /> \n')
+				tmpFile.write( '	<uses-permission android:name="android.permission.READ_FRAME_BUFFER" /> \n')
+			if True==self.check_right_package(pkgProperties, "READ_PROFILE"):
+				tmpFile.write( '	<permission android:name="android.permission.READ_PROFILE" /> \n')
+				tmpFile.write( '	<uses-permission android:name="android.permission.READ_PROFILE" /> \n')
+			if True==self.check_right_package(pkgProperties, "RECORD_AUDIO"):
+				tmpFile.write( '	<permission android:name="android.permission.RECORD_AUDIO" /> \n')
+				tmpFile.write( '	<uses-permission android:name="android.permission.RECORD_AUDIO" /> \n')
+			if True==self.check_right_package(pkgProperties, "SET_ORIENTATION"):
+				tmpFile.write( '	<permission android:name="android.permission.SET_ORIENTATION" /> \n')
+				tmpFile.write( '	<uses-permission android:name="android.permission.SET_ORIENTATION" /> \n')
+			if True==self.check_right_package(pkgProperties, "VIBRATE"):
+				tmpFile.write( '	<permission android:name="android.permission.VIBRATE" /> \n')
+				tmpFile.write( '	<uses-permission android:name="android.permission.VIBRATE" /> \n')
+			if True==self.check_right_package(pkgProperties, "ACCESS_COARSE_LOCATION"):
+				tmpFile.write( '	<permission android:name="android.permission.ACCESS_COARSE_LOCATION" /> \n')
+				tmpFile.write( '	<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" /> \n')
+			if True==self.check_right_package(pkgProperties, "ACCESS_FINE_LOCATION"):
+				tmpFile.write( '	<permission android:name="android.permission.ACCESS_FINE_LOCATION" /> \n')
+				tmpFile.write( '	<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" /> \n')
+			tmpFile.write( '</manifest>\n\n')
+			tmpFile.flush()
+			tmpFile.close()
+			# end generating android manifest
+			
+			if pkgProperties["ANDROID_APPL_TYPE"]!="APPL":
+				#create the Wallpaper sub files : (main element for the application
+				debug.print_element("pkg", pkgNameApplicationName + "_resource.xml", "<==", "package configurations")
+				tools.create_directory_of_file(self.get_staging_folder(pkgName) + "/res/xml/" + pkgNameApplicationName + "_resource.xml")
+				tmpFile = open(self.get_staging_folder(pkgName) + "/res/xml/" + pkgNameApplicationName + "_resource.xml", 'w')
+				tmpFile.write( "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n")
+				tmpFile.write( "<wallpaper xmlns:android=\"http://schemas.android.com/apk/res/android\"\n")
+				if len(pkgProperties["ANDROID_WALLPAPER_PROPERTIES"])!=0:
+					tmpFile.write( "           android:settingsActivity=\""+compleatePackageName + "."+ pkgNameApplicationName + "Settings\"\n")
+				if "ICON" in pkgProperties.keys():
+					tmpFile.write( "           android:thumbnail=\"@drawable/icon\"\n")
+				tmpFile.write( "           />\n")
+				tmpFile.flush()
+				tmpFile.close()
+				# create wallpaper setting if needed (class and config file)
+				if len(pkgProperties["ANDROID_WALLPAPER_PROPERTIES"])!=0:
+					tools.create_directory_of_file(self.folder_javaProject + pkgNameApplicationName + "Settings.java")
+					debug.print_element("pkg", self.folder_javaProject + pkgNameApplicationName + "Settings.java", "<==", "package configurations")
+					tmpFile = open(self.folder_javaProject + pkgNameApplicationName + "Settings.java", 'w');
+					tmpFile.write( "package " + compleatePackageName + ";\n")
+					tmpFile.write( "\n")
+					tmpFile.write( "import " + compleatePackageName + ".R;\n")
+					tmpFile.write( "\n")
+					tmpFile.write( "import android.content.SharedPreferences;\n")
+					tmpFile.write( "import android.os.Bundle;\n")
+					tmpFile.write( "import android.preference.PreferenceActivity;\n")
+					tmpFile.write( "\n")
+					tmpFile.write( "public class " + pkgNameApplicationName + "Settings extends PreferenceActivity implements SharedPreferences.OnSharedPreferenceChangeListener\n")
+					tmpFile.write( "{\n")
+					tmpFile.write( "	@Override protected void onCreate(Bundle icicle) {\n")
+					tmpFile.write( "		super.onCreate(icicle);\n")
+					tmpFile.write( "		getPreferenceManager().setSharedPreferencesName("+ pkgNameApplicationName + ".SHARED_PREFS_NAME);\n")
+					tmpFile.write( "		addPreferencesFromResource(R.xml."+ pkgNameApplicationName  + "_settings);\n")
+					tmpFile.write( "		getPreferenceManager().getSharedPreferences().registerOnSharedPreferenceChangeListener(this);\n")
+					tmpFile.write( "	}\n")
+					tmpFile.write( "	@Override protected void onResume() {\n")
+					tmpFile.write( "		super.onResume();\n")
+					tmpFile.write( "	}\n")
+					tmpFile.write( "	@Override protected void onDestroy() {\n")
+					tmpFile.write( "		getPreferenceManager().getSharedPreferences().unregisterOnSharedPreferenceChangeListener(this);\n")
+					tmpFile.write( "		super.onDestroy();\n")
+					tmpFile.write( "	}\n")
+					tmpFile.write( "	public void onSharedPreferenceChanged(SharedPreferences sharedPreferences,String key) { }\n")
+					tmpFile.write( "}\n")
+					tmpFile.flush()
+					tmpFile.close()
+					
+					debug.print_element("pkg", self.get_staging_folder(pkgName) + "/res/xml/" + pkgNameApplicationName + "_settings.xml", "<==", "package configurations")
+					tools.create_directory_of_file(self.get_staging_folder(pkgName) + "/res/xml/" + pkgNameApplicationName + "_settings.xml")
+					tmpFile = open(self.get_staging_folder(pkgName) + "/res/xml/" + pkgNameApplicationName + "_settings.xml", 'w');
+					tmpFile.write( "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n")
+					tmpFile.write( "<PreferenceScreen xmlns:android=\"http://schemas.android.com/apk/res/android\"\n")
+					tmpFile.write( "                  android:title=\"Settings\"\n")
+					tmpFile.write( "                  android:key=\"" + pkgNameApplicationName  + "_settings\">\n")
+					WALL_haveArray = False
+					for WALL_type, WALL_key, WALL_title, WALL_summary, WALL_other in pkgProperties["ANDROID_WALLPAPER_PROPERTIES"]:
+						debug.info("find : '" + WALL_type + "'");
+						if WALL_type == "list":
+							debug.info("    create : LIST");
+							tmpFile.write( "	<ListPreference android:key=\"" + pkgNameApplicationName + "_" + WALL_key + "\"\n")
+							tmpFile.write( "	                android:title=\"" + WALL_title + "\"\n")
+							tmpFile.write( "	                android:summary=\"" + WALL_summary + "\"\n")
+							tmpFile.write( "	                android:entries=\"@array/" + pkgNameApplicationName + "_" + WALL_key + "_names\"\n")
+							tmpFile.write( "	                android:entryValues=\"@array/" + pkgNameApplicationName + "_" + WALL_key + "_prefix\"/>\n")
+							WALL_haveArray=True
+						elif WALL_type == "bool":
+							debug.info("    create : CHECKBOX");
+							tmpFile.write( "	<CheckBoxPreference android:key=\"" + pkgNameApplicationName + "_" + WALL_key + "\"\n")
+							tmpFile.write( "	                    android:title=\"" + WALL_title + "\"\n")
+							tmpFile.write( "	                    android:summary=\"" + WALL_summary + "\"\n")
+							tmpFile.write( "	                    android:summaryOn=\"" + WALL_other[0] + "\"\n")
+							tmpFile.write( "	                    android:summaryOff=\"" + WALL_other[1] + "\"/>\n")
+					tmpFile.write( "</PreferenceScreen>\n")
+					tmpFile.flush()
+					tmpFile.close()
+					if WALL_haveArray==True:
+						for WALL_type, WALL_key, WALL_title, WALL_summary, WALL_other in pkgProperties["ANDROID_WALLPAPER_PROPERTIES"]:
+							if WALL_type == "list":
+								debug.print_element("pkg", self.get_staging_folder(pkgName) + "/res/values/" + WALL_key + ".xml", "<==", "package configurations")
+								tools.create_directory_of_file(self.get_staging_folder(pkgName) + "/res/values/" + WALL_key + ".xml")
+								tmpFile = open(self.get_staging_folder(pkgName) + "/res/values/" + WALL_key + ".xml", 'w');
+								tmpFile.write( "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n")
+								tmpFile.write( "<resources xmlns:xliff=\"urn:oasis:names:tc:xliff:document:1.2\">\n")
+								tmpFile.write( "	<string-array name=\"" + pkgNameApplicationName + "_" + WALL_key + "_names\">\n")
+								for WALL_subKey, WALL_display in WALL_other:
+									tmpFile.write( "		<item>" + WALL_display + "</item>\n")
+								tmpFile.write( "	</string-array>\n")
+								tmpFile.write( "	<string-array name=\"" + pkgNameApplicationName + "_" + WALL_key + "_prefix\">\n")
+								for WALL_subKey, WALL_display in WALL_other:
+									tmpFile.write( "		<item>" + WALL_subKey + "</item>\n")
+								tmpFile.write( "	</string-array>\n")
+								tmpFile.write( "</resources>\n")
+								tmpFile.flush()
+								tmpFile.close()
+						
+		
+		#add properties on wallpaper : 
+		# myModule.pkg_add("ANDROID_WALLPAPER_PROPERTIES", ["list", key, title, summary, [["key","value display"],["key2","value display 2"]])
+		# myModule.pkg_add("ANDROID_WALLPAPER_PROPERTIES", ["list", "testpattern", "Select test pattern", "Choose which test pattern to display", [["key","value display"],["key2","value display 2"]]])
+		# myModule.pkg_add("ANDROID_WALLPAPER_PROPERTIES", ["bool", key, title, summary, ["enable string", "disable String"])
+		# myModule.pkg_add("ANDROID_WALLPAPER_PROPERTIES", ["bool", "movement", "Motion", "Apply movement to test pattern", ["Moving test pattern", "Still test pattern"]
+		#copy needed resources :
+		for res_source, res_dest in pkgProperties["ANDROID_RESOURCES"]:
+			if res_source == "":
+				continue
+			tools.copy_file(res_source , self.get_staging_folder(pkgName) + "/res/" + res_dest + "/" + os.path.basename(res_source), force=True)
+		
+		
+		# Doc :
+		# http://asantoso.wordpress.com/2009/09/15/how-to-build-android-application-package-apk-from-the-command-line-using-the-sdk-tools-continuously-integrated-using-cruisecontrol/
+		debug.print_element("pkg", "R.java", "<==", "Resources files")
+		tools.create_directory_of_file(self.get_staging_folder(pkgName) + "/src/noFile")
+		androidToolPath = self.folder_sdk + "/build-tools/"
+		# find android tool version
+		dirnames = tools.get_list_sub_folder(androidToolPath)
+		if len(dirnames) != 1:
+			debug.error("an error occured when getting the tools for android")
+		androidToolPath += dirnames[0] + "/"
+		
+		adModResouceFolder = ""
+		if "ADMOD_ID" in pkgProperties:
+			adModResouceFolder = " -S " + self.folder_sdk + "/extras/google/google_play_services/libproject/google-play-services_lib/res/ "
+		cmdLine = androidToolPath + "aapt p -f " \
+		          + "-M " + self.get_staging_folder(pkgName) + "/AndroidManifest.xml " \
+		          + "-F " + self.get_staging_folder(pkgName) + "/resources.res " \
+		          + "-I " + self.folder_sdk + "/platforms/android-" + str(self.boardId) + "/android.jar "\
+		          + "-S " + self.get_staging_folder(pkgName) + "/res/ " \
+		          + adModResouceFolder \
+		          + "-J " + self.get_staging_folder(pkgName) + "/src/ "
+		lutinMultiprocess.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}]
+		
+		tools.create_directory_of_file(self.get_staging_folder(pkgName) + "/build/classes/noFile")
+		debug.print_element("pkg", "*.class", "<==", "*.java")
+		# more information with : -Xlint
+		#          + self.file_finalAbstraction + " "\ # this generate ex: out/Android/debug/staging/tethys/src/com/edouarddupin/tethys/edn.java
+		
+		#generate android java files:
+		filesString=""
+		for element in pkgProperties["ANDROID_JAVA_FILES"]:
+			if element=="DEFAULT":
+				filesString += self.folder_ewol + "/sources/android/src/org/ewol/EwolAudioTask.java "
+				filesString += self.folder_ewol + "/sources/android/src/org/ewol/EwolCallback.java "
+				filesString += self.folder_ewol + "/sources/android/src/org/ewol/EwolConstants.java "
+				filesString += self.folder_ewol + "/sources/android/src/org/ewol/Ewol.java "
+				filesString += self.folder_ewol + "/sources/android/src/org/ewol/EwolRendererGL.java "
+				filesString += self.folder_ewol + "/sources/android/src/org/ewol/EwolSurfaceViewGL.java "
+				filesString += self.folder_ewol + "/sources/android/src/org/ewol/EwolActivity.java "
+				filesString += self.folder_ewol + "/sources/android/src/org/ewol/EwolWallpaper.java "
+			else:
+				filesString += element + " "
+		
+		if "ADMOD_ID" in pkgProperties:
+			filesString += self.folder_sdk + "/extras/google/google_play_services/libproject/google-play-services_lib/src/android/UnusedStub.java "
+			
+		if len(pkgProperties["ANDROID_WALLPAPER_PROPERTIES"])!=0:
+			filesString += self.folder_javaProject + pkgNameApplicationName + "Settings.java "
+		
+		adModJarFile = ""
+		if "ADMOD_ID" in pkgProperties:
+			adModJarFile = ":" + self.folder_sdk + "/extras/google/google_play_services/libproject/google-play-services_lib/libs/google-play-services.jar"
+		
+		cmdLine = "javac " \
+		          + "-d " + self.get_staging_folder(pkgName) + "/build/classes " \
+		          + "-classpath " + self.folder_sdk + "/platforms/android-" + str(self.boardId) + "/android.jar" \
+		          + adModJarFile + " " \
+		          + filesString \
+		          + self.file_finalAbstraction + " "  \
+		          + self.get_staging_folder(pkgName) + "/src/R.java "
+		lutinMultiprocess.run_command(cmdLine)
+		
+		debug.print_element("pkg", ".dex", "<==", "*.class")
+		cmdLine = androidToolPath + "dx " \
+		          + "--dex --no-strict " \
+		          + "--output=" + self.get_staging_folder(pkgName) + "/build/" + pkgNameApplicationName + ".dex " \
+		          + self.get_staging_folder(pkgName) + "/build/classes/ "
+		
+		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)
+		
+		debug.print_element("pkg", ".apk", "<==", ".dex, assets, .so, res")
+		#builderDebug="-agentlib:jdwp=transport=dt_socket,server=y,address=8050,suspend=y "
+		builderDebug=""
+		# note : set -u not signed application...
+		#+ ":" + self.folder_sdk + "/extras/google/google_play_services/libproject/google-play-services_lib/libs/google-play-services.jar "
+		cmdLine =   "java -Xmx128M " \
+		          + " -classpath " + self.folder_sdk + "/tools/lib/sdklib.jar " \
+		          + builderDebug \
+		          + " com.android.sdklib.build.ApkBuilderMain " \
+		          + self.get_staging_folder(pkgName) + "/build/" + pkgNameApplicationName + "-unalligned.apk " \
+		          + " -u " \
+		          + " -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)
+		
+		# 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":
+			debug.print_element("pkg", ".apk(signed debug)", "<==", ".apk (not signed)")
+			# verbose mode : 
+			#debugOption = "-verbose -certs "
+			debugOption = ""
+			cmdLine = "jarsigner " \
+			    + 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"
+			lutinMultiprocess.run_command(cmdLine)
+			tmpFile = open("tmpPass.boo", 'w')
+			tmpFile.write("\n")
+			tmpFile.flush()
+			tmpFile.close()
+		else:
+			print("On release mode we need the file :  and key an pasword to sign the application ...")
+			debug.print_element("pkg", ".apk(signed debug)", "<==", ".apk (not signed)")
+			cmdLine = "jarsigner " \
+			    + " -keystore " + basePkgPath + "/AndroidKey.jks " \
+			    + " -sigalg SHA1withRSA -digestalg SHA1 " \
+			    + self.get_staging_folder(pkgName) + "/build/" + pkgNameApplicationName + "-unalligned.apk " \
+			    + " " + pkgNameApplicationName
+			lutinMultiprocess.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)
+		
+		debug.print_element("pkg", ".apk(aligned)", "<==", ".apk (not aligned)")
+		tools.remove_file(self.get_staging_folder(pkgName) + "/" + pkgNameApplicationName + ".apk")
+		# verbose mode : -v
+		cmdLine = androidToolPath + "zipalign 4 " \
+		          + self.get_staging_folder(pkgName) + "/build/" + pkgNameApplicationName + "-unalligned.apk " \
+		          + self.get_staging_folder(pkgName) + "/" + pkgNameApplicationName + ".apk "
+		lutinMultiprocess.run_command(cmdLine)
+		
+		# copy file in the final stage :
+		tools.copy_file(self.get_staging_folder(pkgName) + "/" + pkgNameApplicationName + ".apk",
+		                self.get_final_folder() + "/" + pkgNameApplicationName + ".apk",
+		                force=True)
+	
+	def install_package(self, pkgName):
+		debug.debug("------------------------------------------------------------------------")
+		debug.info("Install package '" + pkgName + "'")
+		debug.debug("------------------------------------------------------------------------")
+		pkgNameApplicationName = pkgName
+		if self.config["mode"] == "debug":
+			pkgNameApplicationName += "debug"
+		cmdLine = self.folder_sdk + "/platform-tools/adb install -r " \
+		          + self.get_staging_folder(pkgName) + "/" + pkgNameApplicationName + ".apk "
+		lutinMultiprocess.run_command(cmdLine)
+	
+	def un_install_package(self, pkgName):
+		debug.debug("------------------------------------------------------------------------")
+		debug.info("Un-Install package '" + pkgName + "'")
+		debug.debug("------------------------------------------------------------------------")
+		pkgNameApplicationName = pkgName
+		if self.config["mode"] == "debug":
+			pkgNameApplicationName += "debug"
+		cmdLine = self.folder_sdk + "/platform-tools/adb uninstall " + pkgNameApplicationName
+		RlutinMultiprocess.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)
+
+

lutin/target/lutinTarget_IOs.py

@@ -0,0 +1,432 @@
+#!/usr/bin/python
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+
+import lutinDebug as debug
+import lutinTarget
+import lutinTools
+import lutinImage
+import os
+import stat
+import lutinMultiprocess
+import lutinHost
+import random
+import re
+
+class Target(lutinTarget.Target):
+	def __init__(self, config):
+		if config["compilator"] == "gcc":
+			debug.info("compile only with clang for IOs");
+			config["compilator"] = "clang"
+		#processor type selection (auto/arm/ppc/x86)
+		if config["arch"] == "auto":
+			config["arch"] = "arm"
+		#bus size selection (auto/32/64)
+		if config["bus-size"] == "auto":
+			config["bus-size"] = "64"
+		
+		# http://biolpc22.york.ac.uk/pub/linux-mac-cross/
+		# http://devs.openttd.org/~truebrain/compile-farm/apple-darwin9.txt
+		if config["simulation"] == True:
+			arch = "i386"
+		else:
+			arch="arm64" # for ipad air
+			#arch="armv7" # for Iphone 4
+		lutinTarget.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:
+			self.set_cross_base("/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/")
+		
+		# remove unneeded ranlib ...
+		self.ranlib=""
+		self.folder_bin=""
+		self.folder_data="/share"
+		self.folder_doc="/doc"
+		
+		self.suffix_lib_static='.a'
+		self.suffix_lib_dynamic='.dylib'
+		self.suffix_binary=''
+		self.suffix_package=''
+		if self.sumulator == True:
+			self.sysroot = "-isysroot /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator8.1.sdk"
+			self.global_flags_ld.append("-mios-simulator-version-min=8.0")
+			self.global_flags_cc.append("-mios-simulator-version-min=8.0")
+		else:
+			self.sysroot = "-isysroot /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS8.1.sdk"
+			self.global_flags_ld.append("-miphoneos-version-min=8.0")
+			self.global_flags_cc.append("-miphoneos-version-min=8.0")
+
+		self.global_flags_ld.append([
+			"-Xlinker",
+			"-objc_abi_version",
+			"-Xlinker 2",
+			"-Xlinker",
+			"-no_implicit_dylibs",
+			"-stdlib=libc++",
+			"-fobjc-arc",
+			"-fobjc-link-runtime"])
+	
+		self.global_flags_m.append("-fobjc-arc")
+		#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/"
+	
+	def get_staging_folder_data(self, binaryName):
+		return self.get_staging_folder(binaryName) + self.folder_data + "/"
+	
+	def make_package(self, pkgName, pkgProperties, basePkgPath):
+		debug.debug("------------------------------------------------------------------------")
+		debug.info("Generate package '" + pkgName + "'")
+		debug.debug("------------------------------------------------------------------------")
+		
+		if    "ICON" in pkgProperties.keys() \
+		   and pkgProperties["ICON"] != "":
+			# Resize all icon needed for Ios ...
+			# 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)
+			debug.print_element("pkg", "iTunesArtwork@2x.png", "<==", pkgProperties["ICON"])
+			lutinImage.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)
+			debug.print_element("pkg", "Icon-76.png", "<==", pkgProperties["ICON"])
+			lutinImage.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)
+			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)
+			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)
+			debug.print_element("pkg", "Icon-Small.png", "<==", pkgProperties["ICON"])
+			lutinImage.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)
+		
+		debug.print_element("pkg", "PkgInfo", "<==", "APPL????")
+		infoFile = self.get_staging_folder(pkgName) + "/PkgInfo"
+		# Create the info file
+		tmpFile = open(infoFile, 'w')
+		tmpFile.write("APPL????")
+		tmpFile.flush()
+		tmpFile.close()
+		
+		debug.print_element("pkg", "Info.plist", "<==", "Package properties")
+		# http://www.sandroid.org/imcross/#Deployment
+		dataFile  = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+		dataFile += "<!DOCTYPE plist PUBLIC \"-//Apple Computer//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"
+		dataFile += "<plist version=\"1.0\">\n"
+		dataFile += "		<dict>\n"
+		dataFile += "			<key>CFBundleDevelopmentRegion</key>\n"
+		dataFile += "			<string>en</string>\n"
+		dataFile += "			<key>CFBundleDisplayName</key>\n"
+		dataFile += "			<string>" + pkgProperties["NAME"] + "</string>\n"
+		dataFile += "			<key>CFBundleExecutable</key>\n"
+		dataFile += "			<string>" + pkgName + "</string>\n"
+		dataFile += "			<key>CFBundleIdentifier</key>\n"
+		dataFile += "			<string>com." + pkgProperties["COMPAGNY_NAME2"] + "." + pkgName + "</string>\n"
+		
+		dataFile += "			<key>CFBundleIconFiles</key>\n"
+		dataFile += "			<array>\n"
+		dataFile += "				<string>Icon-60@2x.png</string>\n"
+		dataFile += "				<string>Icon-76.png</string>\n"
+		dataFile += "				<string>Icon-76@2x.png</string>\n"
+		dataFile += "				<string>Icon-Small-40.png</string>\n"
+		dataFile += "				<string>Icon-Small-40@2x.png</string>\n"
+		dataFile += "				<string>Icon-Small.png</string>\n"
+		dataFile += "				<string>Icon-Small@2x.png</string>\n"
+		dataFile += "				<string>iTunesArtwork.png</string>\n"
+		dataFile += "				<string>iTunesArtwork@2x.png</string>\n"
+		dataFile += "			</array>\n"
+		
+		dataFile += "			<key>CFBundleInfoDictionaryVersion</key>\n"
+		dataFile += "			<string>6.0</string>\n"
+		dataFile += "			<key>CFBundleName</key>\n"
+		dataFile += "			<string>" + pkgName + "</string>\n"
+		dataFile += "			<key>CFBundlePackageType</key>\n"
+		dataFile += "			<string>APPL</string>\n"
+		dataFile += "			<key>CFBundleSignature</key>\n"
+		dataFile += "			<string>????</string>\n"
+		dataFile += "			<key>CFBundleSupportedPlatforms</key>\n"
+		dataFile += "			<array>\n"
+		dataFile += "				<string>iPhoneSimulator</string>\n"
+		dataFile += "			</array>\n"
+		dataFile += "			\n"
+		dataFile += "			<key>CFBundleShortVersionString</key>\n"
+		dataFile += "			<string>"+pkgProperties["VERSION"]+"</string>\n"
+		dataFile += "			<key>CFBundleVersion</key>\n"
+		dataFile += "			<string>"+pkgProperties["VERSION_CODE"]+"</string>\n"
+		dataFile += "			\n"
+		dataFile += "			<key>CFBundleResourceSpecification</key>\n"
+		dataFile += "			<string>ResourceRules.plist</string>\n"
+		if self.sumulator == False:
+			dataFile += "			<key>LSRequiresIPhoneOS</key>\n"
+			dataFile += "			<true/>\n"
+		else:
+			dataFile += "			<key>DTPlatformName</key>\n"
+			dataFile += "			<string>iphonesimulator</string>\n"
+			dataFile += "			<key>DTSDKName</key>\n"
+			dataFile += "			<string>iphonesimulator7.0</string>\n"
+		dataFile += "			\n"
+		dataFile += "			<key>UIDeviceFamily</key>\n"
+		dataFile += "			<array>\n"
+		dataFile += "				<integer>1</integer>\n"
+		dataFile += "				<integer>2</integer>\n"
+		dataFile += "			</array>\n"
+		dataFile += "			<key>UIRequiredDeviceCapabilities</key>\n"
+		dataFile += "			<array>\n"
+		dataFile += "				<string>armv7</string>\n"
+		dataFile += "			</array>\n"
+		dataFile += "			<key>UIStatusBarHidden</key>\n"
+		dataFile += "			<true/>\n"
+		dataFile += "			<key>UISupportedInterfaceOrientations</key>\n"
+		dataFile += "			<array>\n"
+		dataFile += "				<string>UIInterfaceOrientationPortrait</string>\n"
+		dataFile += "				<string>UIInterfaceOrientationPortraitUpsideDown</string>\n"
+		dataFile += "				<string>UIInterfaceOrientationLandscapeLeft</string>\n"
+		dataFile += "				<string>UIInterfaceOrientationLandscapeRight</string>\n"
+		dataFile += "			</array>\n"
+		dataFile += "			<key>UISupportedInterfaceOrientations~ipad</key>\n"
+		dataFile += "			<array>\n"
+		dataFile += "				<string>UIInterfaceOrientationPortrait</string>\n"
+		dataFile += "				<string>UIInterfaceOrientationPortraitUpsideDown</string>\n"
+		dataFile += "				<string>UIInterfaceOrientationLandscapeLeft</string>\n"
+		dataFile += "				<string>UIInterfaceOrientationLandscapeRight</string>\n"
+		dataFile += "			</array>\n"
+		dataFile += "    </dict>\n"
+		dataFile += "</plist>\n"
+		dataFile += "\n\n"
+		
+		infoFile = self.get_staging_folder(pkgName) + "/Info.plist"
+		# Create the info file
+		tmpFile = open(infoFile, 'w')
+		tmpFile.write(dataFile)
+		tmpFile.flush()
+		tmpFile.close()
+		"""
+		infoFile = self.get_staging_folder(pkgName) + "/" + pkgName + "-Info.plist"
+		# Create the info file
+		tmpFile = open(infoFile, 'w')
+		tmpFile.write(dataFile)
+		tmpFile.flush()
+		tmpFile.close()
+		cmdLine  = "builtin-infoPlistUtility "
+		cmdLine += " " + self.get_staging_folder(pkgName) + "/" + pkgName + "-Info.plist "
+		cmdLine += " -genpkginfo " + self.get_staging_folder(pkgName) + "/PkgInfo"
+		cmdLine += " -expandbuildsettings "
+		cmdLine += " -format binary "
+		if self.sumulator == False:
+			cmdLine += " -platform iphonesimulator "
+		else:
+			cmdLine += " -platform iphoneos "
+		cmdLine += " -o " + self.get_staging_folder(pkgName) + "/" + "Info.plist"
+		lutinMultiprocess.run_command(cmdLine)
+		"""
+		"""
+		
+			/Users/edouarddupin/dev/exampleProjectXcode/projectName/projectName/projectName-Info.plist
+			-genpkginfo
+			/Users/edouarddupin/Library/Developer/Xcode/DerivedData/projectName-gwycnyyzohokcmalgodeucqppxro/Build/Products/Debug-iphonesimulator/projectName.app/PkgInfo
+			-expandbuildsettings
+			-format binary
+			-platform iphonesimulator
+		    -additionalcontentfile /Users/edouarddupin/Library/Developer/Xcode/DerivedData/projectName-gwycnyyzohokcmalgodeucqppxro/Build/Intermediates/projectName.build/Debug-iphonesimulator/projectName.build/assetcatalog_generated_info.plist
+			-o /Users/edouarddupin/Library/Developer/Xcode/DerivedData/projectName-gwycnyyzohokcmalgodeucqppxro/Build/Products/Debug-iphonesimulator/projectName.app/Info.plist
+		 -additionalcontentfile /Users/edouarddupin/Library/Developer/Xcode/DerivedData/zdzdzd-bjuyukzpzhnyerdmxohjyuxfdllv/Build/Intermediates/zdzdzd.build/Debug-iphoneos/zdzdzd.build/assetcatalog_generated_info.plist -o /Users/edouarddupin/Library/Developer/Xcode/DerivedData/zdzdzd-bjuyukzpzhnyerdmxohjyuxfdllv/Build/Products/Debug-iphoneos/zdzdzd.app/Info.plist
+			
+			"""
+		#/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/dsymutil /Users/edouarddupin/Library/Developer/Xcode/DerivedData/projectName-gwycnyyzohokcmalgodeucqppxro/Build/Products/Debug-iphonesimulator/projectName.app/projectName -o /Users/edouarddupin/Library/Developer/Xcode/DerivedData/projectName-gwycnyyzohokcmalgodeucqppxro/Build/Products/Debug-iphonesimulator/projectName.app.dSYM
+			
+		debug.print_element("pkg", "ResourceRules.plist", "<==", "Resources autorisation")
+		dataFile  = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+		dataFile += "<!DOCTYPE plist PUBLIC \"-//Apple Computer//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"
+		dataFile += "<plist version=\"1.0\">\n"
+		dataFile += "	<dict>\n"
+		dataFile += "		<key>rules</key>\n"
+		dataFile += "		<dict>\n"
+		dataFile += "			<key>.*</key>\n"
+		dataFile += "			<true/>\n"
+		dataFile += "			<key>Info.plist</key>\n"
+		dataFile += "			<dict>\n"
+		dataFile += "				<key>omit</key>\n"
+		dataFile += "				<true/>\n"
+		dataFile += "				<key>weight</key>\n"
+		dataFile += "				<real>10</real>\n"
+		dataFile += "			</dict>\n"
+		dataFile += "			<key>ResourceRules.plist</key>\n"
+		dataFile += "			<dict>\n"
+		dataFile += "				<key>omit</key>\n"
+		dataFile += "				<true/>\n"
+		dataFile += "				<key>weight</key>\n"
+		dataFile += "				<real>100</real>\n"
+		dataFile += "			</dict>\n"
+		dataFile += "		</dict>\n"
+		dataFile += "	</dict>\n"
+		dataFile += "</plist>\n"
+		dataFile += "\n\n"
+
+		infoFile = self.get_staging_folder(pkgName) + "/ResourceRules.plist"
+		# Create the info file
+		tmpFile = open(infoFile, 'w')
+		tmpFile.write(dataFile)
+		tmpFile.flush()
+		tmpFile.close()
+
+		debug.print_element("pkg", "Entitlements.plist", "<==", "application mode")
+		dataFile  = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+		dataFile += "<!DOCTYPE plist PUBLIC \"-//Apple Computer//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"
+		dataFile += "<plist version=\"1.0\">\n"
+		dataFile += "	<dict>\n"
+		dataFile += "		<key>get-task-allow</key>\n"
+		dataFile += "		<true/>\n"
+		dataFile += "    </dict>\n"
+		dataFile += "</plist>\n"
+		dataFile += "\n\n"
+
+		infoFile = self.get_staging_folder(pkgName) + "/Entitlements.plist"
+		# Create the info file
+		tmpFile = open(infoFile, 'w')
+		tmpFile.write(dataFile)
+		tmpFile.flush()
+		tmpFile.close()
+
+		# Simulateur folder :
+		#~/Library/Application\ Support/iPhone\ Simulator/7.0.3/Applications/
+		# must have a 'uuidgen' UID generate value with this elemennt ...
+		# get the bundle path : ==> maybe usefull in MocOS ...
+		# NSLog(@"%@",[[NSBundle mainBundle] bundlePath]);
+		
+		# Must create the tarball of the application 
+		#cd $(TARGET_OUT_FINAL)/; tar -cf $(PROJECT_NAME).tar $(PROJECT_NAME).app
+		#cd $(TARGET_OUT_FINAL)/; tar -czf $(PROJECT_NAME).tar.gz $(PROJECT_NAME).app
+		
+		if self.sumulator == False:
+			# Create the info file
+			tmpFile = open(self.get_build_folder(pkgName) + "/worddown.xcent", 'w')
+			tmpFile.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n")
+			tmpFile.write("<!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n")
+			tmpFile.write("<plist version=\"1.0\">\n")
+			tmpFile.write("    <dict>\n")
+			tmpFile.write("        <key>application-identifier</key>\n")
+			tmpFile.write("        <string>" + pkgProperties["APPLE_APPLICATION_IOS_ID"] + "." + pkgProperties["COMPAGNY_TYPE"] + "." + pkgProperties["COMPAGNY_NAME2"] + "." + pkgName + "</string>\n")
+			tmpFile.write("        <key>get-task-allow</key>\n")
+			tmpFile.write("        <true/>\n")
+			tmpFile.write("        <key>keychain-access-groups</key>\n")
+			tmpFile.write("        <array>\n")
+			tmpFile.write("            <string>" + pkgProperties["APPLE_APPLICATION_IOS_ID"] + ".atriasoft.worddown</string>\n")
+			tmpFile.write("        </array>\n")
+			tmpFile.write("    </dict>\n")
+			tmpFile.write("</plist>\n")
+			tmpFile.flush()
+			tmpFile.close()
+			# application signing :
+			debug.print_element("pkg(signed)", "pkg", "<==", "Signing application")
+			iosDevelopperKeyFile = ".iosKey.txt"
+			if lutinTools.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 = 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)
+			
+			# --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
+			#		  --entitlements /Users/edouarddupin/Library/Developer/Xcode/DerivedData/worddown-cmuvjchgtiteexdiacyqoexsyadg/Build/Intermediates/worddown.build/Debug-iphoneos/worddown.build/worddown.xcent
+			#		  /Users/edouarddupin/Library/Developer/Xcode/DerivedData/worddown-cmuvjchgtiteexdiacyqoexsyadg/Build/Products/Debug-iphoneos/worddown.app
+
+	
+	def createRandomNumber(self, len):
+		out = ""
+		for iii in range(0,len):
+			out += random.choice(["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F"])
+		return out
+	
+	def install_package(self, pkgName):
+		debug.debug("------------------------------------------------------------------------")
+		debug.info("Install package '" + pkgName + "'")
+		debug.debug("------------------------------------------------------------------------")
+		if self.sumulator == False:
+			if lutinTools.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:
+				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)
+		else:
+			simulatorIdFile = ".iosSimutatorId_" + pkgName + ".txt"
+			if lutinTools.file_size(simulatorIdFile) < 10:
+				#create the file:
+				tmpFile = open(simulatorIdFile, 'w')
+				tmpFile.write(self.createRandomNumber(8))
+				tmpFile.write("-")
+				tmpFile.write(self.createRandomNumber(4))
+				tmpFile.write("-")
+				tmpFile.write(self.createRandomNumber(4))
+				tmpFile.write("-")
+				tmpFile.write(self.createRandomNumber(4))
+				tmpFile.write("-")
+				tmpFile.write(self.createRandomNumber(12))
+				tmpFile.flush()
+				tmpFile.close()
+			simulatorId = lutinTools.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")
+			cmdLine = "cp -rf " + self.get_staging_folder(pkgName) + " " + destinationFolder2
+			lutinMultiprocess.run_command(cmdLine)
+			cmdLine = "touch " + destinationFolderBase
+			lutinMultiprocess.run_command(cmdLine)
+			
+		#sudo dpkg -i $(TARGET_OUT_FINAL)/$(PROJECT_NAME) + self.suffix_package
+	
+	def un_install_package(self, pkgName):
+		debug.debug("------------------------------------------------------------------------")
+		debug.info("Un-Install package '" + pkgName + "'")
+		debug.debug("------------------------------------------------------------------------")
+		if self.sumulator == False:
+			debug.warning("not implemented")
+		else:
+			simulatorIdFile = ".iosSimutatorId_" + pkgName + ".txt"
+			if lutinTools.file_size(simulatorIdFile) < 10:
+				debug.warning("Can not get simulation O_ID : " + simulatorIdFile)
+		
+		#sudo dpkg -r $(TARGET_OUT_FINAL)/$(PROJECT_NAME) + self.suffix_package
+		
+	def Log(self, pkgName):
+		debug.debug("------------------------------------------------------------------------")
+		debug.info("log of iOs board")
+		debug.debug("------------------------------------------------------------------------")
+		if self.sumulator == False:
+			if lutinTools.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:
+				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)
+		else:
+			cmdLine = "tail -f ~/Library/Logs/iOS\ Simulator/7.1/system.log"
+			lutinMultiprocess.run_command(cmdLine)
+
+
+
+

lutin/target/lutinTarget_Linux.py

@@ -0,0 +1,140 @@
+#!/usr/bin/python
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+
+import lutinDebug as debug
+import lutinTarget
+import lutinTools as tools
+import os
+import stat
+import re
+import lutinMultiprocess
+import lutinHost
+
+class Target(lutinTarget.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, "")
+		if self.config["bus-size"] == "64":
+			# 64 bits
+			if lutinHost.BUS_SIZE != 64:
+				self.global_flags_cc.append("-m64")
+		else:
+			# 32 bits
+			if lutinHost.BUS_SIZE != 32:
+				self.global_flags_cc.append("-m32")
+	
+	def generate_list_separate_coma(self, list):
+		result = ""
+		fistTime = True
+		for elem in list:
+			if fistTime == True:
+				fistTime = False
+			else:
+				result += ","
+			result += elem
+		return result
+	
+	def make_package(self, pkgName, pkgProperties, basePkgPath):
+		# http://alp.developpez.com/tutoriels/debian/creer-paquet/
+		debianPkgName = re.sub("_", "-", pkgName)
+		debug.debug("------------------------------------------------------------------------")
+		debug.info("Generate package '" + debianPkgName + "' v"+pkgProperties["VERSION"])
+		debug.debug("------------------------------------------------------------------------")
+		self.get_staging_folder(pkgName)
+		targetOutFolderDebian = self.get_staging_folder(pkgName) + "/DEBIAN/"
+		finalFileControl = targetOutFolderDebian + "control"
+		finalFilepostRm = targetOutFolderDebian + "postrm"
+		# create the folders :
+		tools.create_directory_of_file(finalFileControl)
+		tools.create_directory_of_file(finalFilepostRm)
+		## Create the control file
+		tools.create_directory_of_file(finalFileControl)
+		tmpFile = open(finalFileControl, 'w')
+		tmpFile.write("Package: " + debianPkgName + "\n")
+		tmpFile.write("Version: " + pkgProperties["VERSION"] + "\n")
+		tmpFile.write("Section: " + self.generate_list_separate_coma(pkgProperties["SECTION"]) + "\n")
+		tmpFile.write("Priority: " + pkgProperties["PRIORITY"] + "\n")
+		tmpFile.write("Architecture: all\n")
+		tmpFile.write("Depends: bash\n")
+		tmpFile.write("Maintainer: " + self.generate_list_separate_coma(pkgProperties["MAINTAINER"]) + "\n")
+		tmpFile.write("Description: " + pkgProperties["DESCRIPTION"] + "\n")
+		tmpFile.write("\n")
+		tmpFile.flush()
+		tmpFile.close()
+		## Create the PostRm
+		tmpFile = open(finalFilepostRm, 'w')
+		tmpFile.write("#!/bin/bash\n")
+		tmpFile.write("touch ~/." + pkgName + "\n")
+		if pkgName != "":
+			tmpFile.write("touch ~/.local/share/" + pkgName + "\n")
+			tmpFile.write("rm -r ~/.local/share/" + pkgName + "\n")
+		tmpFile.write("\n")
+		tmpFile.flush()
+		tmpFile.close()
+		## Enable Execution in script
+		os.chmod(finalFilepostRm, stat.S_IRWXU + stat.S_IRGRP + stat.S_IXGRP + stat.S_IROTH + stat.S_IXOTH);
+		## Readme donumentation
+		readmeFileDest = self.get_staging_folder(pkgName) + "/usr/share/doc/"+ debianPkgName + "/README"
+		tools.create_directory_of_file(readmeFileDest)
+		if os.path.exists(basePkgPath + "/os-Linux/README")==True:
+			tools.copy_file(basePkgPath + "/os-Linux/README", readmeFileDest)
+		elif os.path.exists(basePkgPath + "/README")==True:
+			tools.copy_file(basePkgPath + "/README", readmeFileDest)
+		elif os.path.exists(basePkgPath + "/README.md")==True:
+			tools.copy_file(basePkgPath + "/README.md", readmeFileDest)
+		else:
+			debug.info("no file 'README', 'README.md' or 'os-Linux/README' ==> generate an empty one")
+			tmpFile = open(readmeFileDest, 'w')
+			tmpFile.write("No documentation for " + pkgName + "\n")
+			tmpFile.flush()
+			tmpFile.close()
+		## licence file
+		licenseFileDest = self.get_staging_folder(pkgName) + "/usr/share/doc/"+ debianPkgName + "/copyright"
+		tools.create_directory_of_file(licenseFileDest)
+		if os.path.exists(basePkgPath + "/license.txt")==True:
+			tools.copy_file(basePkgPath + "/license.txt", licenseFileDest)
+		else:
+			debug.info("no file 'license.txt' ==> generate an empty one")
+			tmpFile = open(licenseFileDest, 'w')
+			tmpFile.write("No license define by the developper for " + pkgName + "\n")
+			tmpFile.flush()
+			tmpFile.close()
+		##changeLog file
+		changeLogFileDest = self.get_staging_folder(pkgName) + "/usr/share/doc/"+ debianPkgName + "/changelog"
+		tools.create_directory_of_file(changeLogFileDest)
+		if os.path.exists(basePkgPath + "/changelog")==True:
+			tools.copy_file(basePkgPath + "/changelog", changeLogFileDest)
+		else:
+			debug.info("no file 'changelog' ==> generate an empty one")
+			tmpFile = open(changeLogFileDest, 'w')
+			tmpFile.write("No changelog data " + pkgName + "\n")
+			tmpFile.flush()
+			tmpFile.close()
+		## create the package :
+		debug.debug("package : " + self.get_staging_folder(pkgName) + "/" + debianPkgName + ".deb")
+		os.system("cd " + self.get_staging_folder("") + " ; dpkg-deb --build " + pkgName)
+		tools.create_directory_of_file(self.get_final_folder())
+		tools.copy_file(self.get_staging_folder("") + "/" + pkgName + self.suffix_package, self.get_final_folder() + "/" + pkgName + self.suffix_package)
+	
+	def install_package(self, pkgName):
+		debug.debug("------------------------------------------------------------------------")
+		debug.info("Install package '" + pkgName + "'")
+		debug.debug("------------------------------------------------------------------------")
+		os.system("sudo dpkg -i " + self.get_final_folder() + "/" + pkgName + self.suffix_package)
+	
+	def un_install_package(self, pkgName):
+		debug.debug("------------------------------------------------------------------------")
+		debug.info("Un-Install package '" + pkgName + "'")
+		debug.debug("------------------------------------------------------------------------")
+		os.system("sudo dpkg -r " + self.get_final_folder() + "/" + pkgName + self.suffix_package)

lutin/target/lutinTarget_MacOs.py

@@ -0,0 +1,105 @@
+#!/usr/bin/python
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+
+import lutinDebug as debug
+import lutinTarget
+import lutinTools
+import lutinHost
+import os
+import stat
+
+class Target(lutinTarget.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)
+		# 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, "")
+		
+		self.folder_bin="/MacOS"
+		self.folder_lib="/lib"
+		self.folder_data="/Resources"
+		self.folder_doc="/doc"
+		
+		self.suffix_lib_static='.a'
+		self.suffix_lib_dynamic='.dylib'
+		self.suffix_binary=''
+		self.suffix_package=''
+		
+	
+	def get_staging_folder(self, binaryName):
+		return lutinTools.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 + "/"
+	
+	def make_package(self, pkgName, pkgProperties, basePkgPath):
+		debug.debug("------------------------------------------------------------------------")
+		debug.info("Generate package '" + pkgName + "'")
+		debug.debug("------------------------------------------------------------------------")
+		
+		if    "ICON" in pkgProperties.keys() \
+		   and pkgProperties["ICON"] != "":
+			lutinTools.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"
+		# Create the info file
+		tmpFile = open(infoFile, 'w')
+		tmpFile.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n")
+		tmpFile.write("<!DOCTYPE plist PUBLIC \"-//Apple Computer//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n")
+		tmpFile.write("<plist version=\"1.0\">\n")
+		tmpFile.write("    <dict>\n")
+		tmpFile.write("        <key>CFBundleExecutableFile</key>\n")
+		tmpFile.write("        <string>"+pkgName+"</string>\n")
+		tmpFile.write("        <key>CFBundleName</key>\n")
+		tmpFile.write("        <string>"+pkgName+"</string>\n")
+		tmpFile.write("        <key>CFBundleIdentifier</key>\n")
+		tmpFile.write("        <string>" + pkgProperties["COMPAGNY_TYPE"] + "." + pkgProperties["COMPAGNY_NAME2"] + "." + pkgName + "</string>\n")
+		tmpFile.write("        <key>CFBundleSignature</key>\n")
+		tmpFile.write("        <string>????</string>\n")
+		tmpFile.write("        <key>CFBundleIconFile</key>\n")
+		tmpFile.write("        <string>icon.icns</string>\n")
+		tmpFile.write("    </dict>\n")
+		tmpFile.write("</plist>\n")
+		tmpFile.write("\n\n")
+		tmpFile.flush()
+		tmpFile.close()
+		infoFile=self.get_staging_folder(pkgName) + "/PkgInfo"
+		# Create the info file
+		tmpFile = open(infoFile, 'w')
+		tmpFile.write("APPL????")
+		tmpFile.flush()
+		tmpFile.close()
+		
+		# Must create the tarball of the application 
+		#cd $(TARGET_OUT_FINAL)/; tar -cf $(PROJECT_NAME).tar $(PROJECT_NAME).app
+		#cd $(TARGET_OUT_FINAL)/; tar -czf $(PROJECT_NAME).tar.gz $(PROJECT_NAME).app
+	
+	def install_package(self, pkgName):
+		debug.debug("------------------------------------------------------------------------")
+		debug.info("Install package '" + pkgName + "'")
+		debug.debug("------------------------------------------------------------------------")
+		debug.warning("    ==> TODO")
+		#sudo dpkg -i $(TARGET_OUT_FINAL)/$(PROJECT_NAME) + self.suffix_package
+	
+	def un_install_package(self, pkgName):
+		debug.debug("------------------------------------------------------------------------")
+		debug.info("Un-Install package '" + pkgName + "'")
+		debug.debug("------------------------------------------------------------------------")
+		debug.warning("    ==> TODO")
+		#sudo dpkg -r $(TARGET_OUT_FINAL)/$(PROJECT_NAME) + self.suffix_package
+
+
+
+

lutin/target/lutinTarget_Windows.py

@@ -0,0 +1,133 @@
+#!/usr/bin/python
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+
+import lutinDebug as debug
+import lutinTarget
+import lutinTools as tools
+import lutinHost
+import os
+import stat
+import sys
+import lutinZip as zip
+
+class Target(lutinTarget.Target):
+	def __init__(self, config):
+		if config["compilator"] != "gcc":
+			debug.error("Windows does not support '" + config["compilator"] + "' compilator ... availlable : [gcc]")
+			config["compilator"] = "gcc"
+		
+		#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, "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":
+			self.set_cross_base("c:\\MinGW\\bin\\")
+			sys.path.append("c:\\MinGW\\bin" )
+			os.environ['PATH'] += ";c:\\MinGW\\bin\\"
+		else:
+			if self.config["bus-size"] == "64":
+				# 64 bits
+				self.set_cross_base("x86_64-w64-mingw32-")
+			else:
+				# 32 bits
+				self.set_cross_base("i686-w64-mingw32-")
+		# force static link to prenvent many errors ...
+		self.global_flags_ld.append(["-static-libgcc",
+		                             "-static-libstdc++",
+		                             "-static"])
+		
+		self.folder_bin=""
+		self.folder_lib="/lib"
+		self.folder_data="/data"
+		self.folder_doc="/doc"
+		
+		self.suffix_lib_static='.a'
+		self.suffix_lib_dynamic='.dll'
+		self.suffix_binary='.exe'
+		self.suffix_package=''
+	
+	
+	def get_staging_folder_data(self, binaryName):
+		return self.get_staging_folder(binaryName) + self.folder_data
+	
+	def make_package(self, pkgName, pkgProperties, basePkgPath):
+		debug.debug("------------------------------------------------------------------------")
+		debug.info("Generate package '" + pkgName + "'")
+		debug.debug("------------------------------------------------------------------------")
+		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("------------------------------------------------------------------------")
+		debug.info("Install package '" + pkgName + "'")
+		debug.debug("------------------------------------------------------------------------")
+		debug.warning("    ==> TODO")
+		#sudo dpkg -i $(TARGET_OUT_FINAL)/$(PROJECT_NAME) + self.suffix_package
+	
+	def un_install_package(self, pkgName):
+		debug.debug("------------------------------------------------------------------------")
+		debug.info("Un-Install package '" + pkgName + "'")
+		debug.debug("------------------------------------------------------------------------")
+		debug.warning("    ==> TODO")
+		#sudo dpkg -r $(TARGET_OUT_FINAL)/$(PROJECT_NAME) + self.suffix_package
+

lutin/tools.py

@@ -0,0 +1,146 @@
+#!/usr/bin/python
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+
+import os
+import shutil
+import errno
+from . import debug
+import fnmatch
+from . import multiprocess as lutinMultiprocess
+from . import depend as dependency
+
+
+"""
+	
+"""
+def get_run_folder():
+	return os.getcwd()
+
+"""
+	
+"""
+def get_current_path(file):
+	return os.path.dirname(os.path.realpath(file))
+
+def create_directory_of_file(file):
+	folder = os.path.dirname(file)
+	try:
+		os.stat(folder)
+	except:
+		os.makedirs(folder)
+
+def get_list_sub_folder(path):
+	# TODO : os.listdir(path)
+	for dirname, dirnames, filenames in os.walk(path):
+		return dirnames
+	return []
+
+def remove_folder_and_sub_folder(path):
+	if os.path.isdir(path):
+		debug.verbose("remove folder : '" + path + "'")
+		shutil.rmtree(path)
+
+def remove_file(path):
+	if os.path.isfile(path):
+		os.remove(path)
+
+def file_size(path):
+	if not os.path.isfile(path):
+		return 0
+	statinfo = os.stat(path)
+	return statinfo.st_size
+
+def file_read_data(path, binary=False):
+	if not os.path.isfile(path):
+		return ""
+	if binary == True:
+		file = open(path, "rb")
+	else:
+		file = open(path, "r")
+	data_file = file.read()
+	file.close()
+	return data_file
+
+def file_write_data(path, data):
+	file = open(path, "w")
+	file.write(data)
+	file.close()
+
+def list_to_str(list):
+	if type(list) == type(str()):
+		return list + " "
+	else:
+		result = ""
+		# mulyiple imput in the list ...
+		for elem in list:
+			result += list_to_str(elem)
+		return result
+
+def add_prefix(prefix,list):
+	if type(list) == type(None):
+		return ""
+	if type(list) == type(str()):
+		return prefix+list
+	else:
+		if len(list)==0:
+			return ''
+		else:
+			result=[]
+			for elem in list:
+				result.append(prefix+elem)
+			return result
+
+def copy_file(src, dst, cmd_file=None, force=False):
+	if os.path.exists(src) == 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:
+		return
+	debug.print_element("copy file", src, "==>", dst)
+	create_directory_of_file(dst)
+	shutil.copyfile(src, dst)
+	lutinMultiprocess.store_command(cmd_line, cmd_file)
+
+
+def copy_anything(src, dst):
+	tmpPath = os.path.dirname(os.path.realpath(src))
+	tmpRule = os.path.basename(src)
+	for root, dirnames, filenames in os.walk(tmpPath):
+		debug.verbose(" root='" + str(root) + "' dir='" + str(dirnames) + "' filenames=" + str(filenames))
+		tmpList = filenames
+		if len(tmpRule)>0:
+			tmpList = fnmatch.filter(filenames, tmpRule)
+		# Import the module :
+		for cycleFile in tmpList:
+			#for cycleFile in filenames:
+			debug.verbose("Might copy : '" + tmpPath+cycleFile + "' ==> '" + dst + "'")
+			copy_file(tmpPath+"/"+cycleFile, dst+"/"+cycleFile)
+
+
+def copy_anything_target(target, src, dst):
+	tmpPath = os.path.dirname(os.path.realpath(src))
+	tmpRule = os.path.basename(src)
+	for root, dirnames, filenames in os.walk(tmpPath):
+		debug.verbose(" root='" + str(root) + "' dir='" + str(dirnames) + "' filenames=" + str(filenames))
+		tmpList = filenames
+		if len(tmpRule)>0:
+			tmpList = fnmatch.filter(filenames, tmpRule)
+		# Import the module :
+		for cycleFile in tmpList:
+			#for cycleFile in filenames:
+			newDst = dst
+			if len(newDst) != 0 and newDst[-1] != "/":
+				newDst += "/"
+			if root[len(src)-1:] != "":
+				newDst += root[len(src)-1:]
+				if len(newDst) != 0 and newDst[-1] != "/":
+					newDst += "/"
+			debug.verbose("Might copy : '" + root+"/"+cycleFile + "' ==> '" + newDst+cycleFile + "'" )
+			target.add_file_staging(root+"/"+cycleFile, newDst+cycleFile)

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
+
+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()
+	
+