[DEV] work again with separate elements

builder/lutinBuilder_binary.py

@@ -1,6 +1,12 @@
 ##
 ## 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)
@@ -12,7 +18,7 @@ def init():
 ## Get the current builder type.
 ## Return the type of builder
 ##
-def getType():
+def get_type():
 	return "linker"
 
 
@@ -20,49 +26,76 @@ def getType():
 ## @brief Get builder input file type
 ## @return List of extention supported
 ##
-def getInputType():
+def get_input_type():
 	return ["o"]
 
 ##
 ## @brief Get builder output file type
 ## @return List of extention supported
 ##
-def getOutputType():
+def get_output_type():
-	return ["", "exe"]
+	return ["", "exe", "bin"]
 
 
 ##
 ## @brief Commands for running gcc to link an executable.
 ##
-def link(file, binary, target, depancy, libName=""):
+def link(file, binary, target, depancy, name, basic_folder):
-	if libName=="":
+	file_src, file_dst, file_depend, file_cmd = target.generate_file(binary, name, basic_folder, file, "bin")
-		libName = self.name
-	file_src, file_dst, file_depend, file_cmd = target.generate_file(binary, libName,self.originFolder,file,"bin")
 	#create comdLine :
-	cmdLine=lutinTools.list_to_str([
+	cmd = [
-		target.xx,
+		target.xx
-		target.arch,
+		]
-		target.sysroot,
+	try:
-		target.global_sysroot,
+		cmd.append(target.arch)
-		"-o", file_dst,
+	except:
-		file_src,
+		pass
-		depancy.src,
+	try:
-		self.flags_ld,
+		cmd.append(target.sysroot)
-		depancy.flags_ld,
+	except:
-		target.global_flags_ld])
+		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", libName, "==>", 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)", libName, "", "")
+		debug.print_element("Executable(strip)", name, "", "")
 		cmdLineStrip=lutinTools.list_to_str([
 			target.strip,
 			file_dst])

builder/lutinBuilder_c.py

@@ -3,6 +3,7 @@
 ##
 import lutinMultiprocess
 import lutinTools
+import lutinDebug as debug
 import lutinDepend as dependency
 
 # C version:
@@ -19,21 +20,21 @@ def init():
 ## Get the current builder type.
 ## Return the type of builder
 ##
-def getType():
+def get_type():
 	return "compiler"
 
 ##
 ## @brief Get builder input file type
 ## @return List of extention supported
 ##
-def getInputType():
+def get_input_type():
 	return ["c", "C"]
 
 ##
 ## @brief Get builder output file type
 ## @return List of extention supported
 ##
-def getOutputType():
+def get_output_type():
 	return ["o"]
 
 ##

builder/lutinBuilder_cpp.py

@@ -3,6 +3,7 @@
 ##
 import lutinMultiprocess
 import lutinTools
+import lutinDebug as debug
 import lutinDepend as dependency
 # C++ default version:
 default_version = 1999
@@ -18,21 +19,21 @@ def init():
 ## Get the current builder type.
 ## Return the type of builder
 ##
-def getType():
+def get_type():
 	return "compiler"
 
 ##
 ## @brief Get builder input file type
 ## @return List of extention supported
 ##
-def getInputType():
+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 getOutputType():
+def get_output_type():
 	return ["o"]
 
 ##

builder/lutinBuilder_java.py

@@ -3,6 +3,7 @@
 ##
 import lutinMultiprocess
 import lutinTools
+import lutinDebug as debug
 import lutinDepend as dependency
 
 ##
@@ -15,19 +16,19 @@ def init():
 ## Get the current builder type.
 ## Return the type of builder
 ##
-def getType():
+def get_type():
 	return "compiler"
 
 ##
 ## @brief Get builder input file type
 ## @return List of extention supported
 ##
-def getInputType():
+def get_input_type():
 	return ["java"]
 
 ##
 ## @brief Get builder output file type
 ## @return List of extention supported
 ##
-def getOutputType():
+def get_output_type():
 	return ["class"]

builder/lutinBuilder_libraryDynamic.py

@@ -3,7 +3,9 @@
 ##
 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)
@@ -15,56 +17,76 @@ def init():
 ## Get the current builder type.
 ## Return the type of builder
 ##
-def getType():
+def get_type():
 	return "linker"
 
 ##
 ## @brief Get builder input file type
 ## @return List of extention supported
 ##
-def getInputType():
+def get_input_type():
 	return ["o"]
 
 ##
 ## @brief Get builder output file type
 ## @return List of extention supported
 ##
-def getOutputType():
+def get_output_type():
 	return ["so", "dynlib", "dll"]
 
 ##
 ## @brief Commands for running gcc to link a shared library.
 ##
-def link(file, binary, target, depancy, libName=""):
+def link(file, binary, target, depancy, name, basic_folder):
-	if libName=="":
+	file_src, file_dst, file_depend, file_cmd = target.generate_file(binary, name, basic_folder, file, "lib-shared")
-		libName = self.name
-	file_src, file_dst, file_depend, file_cmd = target.generate_file(binary, libName,self.originFolder,file,"lib-shared")
 	#create command Line
-	cmdLine=lutinTools.list_to_str([
+	cmd = [
 		target.xx,
-		"-o", file_dst,
+		"-o", file_dst
-		target.global_sysroot,
+		]
-		target.arch,
+	try:
-		"-shared",
+		cmd.append(target.global_sysroot)
-		file_src,
+	except:
-		depancy.src,
+		pass
-		self.flags_ld,
+	try:
-		depancy.flags_ld,
+		cmd.append(target.arch)
-		target.global_flags_ld])
+	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", libName, "==>", 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)", libName, "", "")
+		debug.print_element("SharedLib(strip)", name, "", "")
 		cmdLineStrip=lutinTools.list_to_str([
 			target.strip,
 			file_dst])

builder/lutinBuilder_libraryStatic.py

@@ -3,7 +3,9 @@
 ##
 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)
@@ -15,45 +17,55 @@ def init():
 ## Get the current builder type.
 ## Return the type of builder
 ##
-def getType():
+def get_type():
 	return "linker"
 
 ##
 ## @brief Get builder input file type
 ## @return List of extention supported
 ##
-def getInputType():
+def get_input_type():
 	return ["o"]
 
 ##
 ## @brief Get builder output file type
 ## @return List of extention supported
 ##
-def getOutputType():
+def get_output_type():
 	return ["a"]
 
 ##
 ## @brief Commands for running ar.
 ##
-def link(file, binary, target, depancy, libName=""):
+def link(file, binary, target, depancy, name, basic_folder):
-	if libName == "":
+	file_src, file_dst, file_depend, file_cmd = target.generate_file(binary, name, basic_folder, file, "lib-static")
-		libName = self.name
-	file_src, file_dst, file_depend, file_cmd = target.generate_file(binary, libName,self.originFolder,file,"lib-static")
 	#$(Q)$(TARGET_AR) $(TARGET_GLOBAL_ARFLAGS) $(PRIVATE_ARFLAGS) $@ $(PRIVATE_ALL_OBJECTS)
-	cmdLine=lutinTools.list_to_str([
+	cmd = [
-		target.ar,
+		target.ar
-		target.global_flags_ar,
+		]
-		self.flags_ar,
+	try:
-		file_dst,
+		cmd.append(target.global_flags_ar)
-		file_src])#,
+	except:
-		#depancy.src])
+		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", libName, "==>", 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)

builder/lutinBuilder_m.py

@@ -15,27 +15,27 @@ local_ref_on_builder_c = None
 def init():
 	global local_ref_on_builder_c
 	debug.debug("m builder get dependency on the C builder")
-	local_ref_on_builder_c = lutinBuilder.getBuilder("c")
+	local_ref_on_builder_c = lutinBuilder.get_builder("c")
 
 ##
 ## Get the current builder type.
 ## Return the type of builder
 ##
-def getType():
+def get_type():
 	return "compiler"
 
 ##
 ## @brief Get builder input file type
 ## @return List of extention supported
 ##
-def getInputType():
+def get_input_type():
 	return ["m", "M"]
 
 ##
 ## @brief Get builder output file type
 ## @return List of extention supported
 ##
-def getOutputType():
+def get_output_type():
 	return ["o"]
 
 ##

builder/lutinBuilder_mm.py

@@ -15,27 +15,27 @@ local_ref_on_builder_cpp = None
 def init():
 	global local_ref_on_builder_cpp
 	debug.debug("mm builder get dependency on the CPP builder")
-	local_ref_on_builder_cpp = lutinBuilder.getBuilder("cpp")
+	local_ref_on_builder_cpp = lutinBuilder.get_builder("cpp")
 
 ##
 ## Get the current builder type.
 ## Return the type of builder
 ##
-def getType():
+def get_type():
 	return "compiler"
 
 ##
 ## @brief Get builder input file type
 ## @return List of extention supported
 ##
-def getInputType():
+def get_input_type():
 	return ["mm", "MM"]
 
 ##
 ## @brief Get builder output file type
 ## @return List of extention supported
 ##
-def getOutputType():
+def get_output_type():
 	return ["o"]
 
 ##

builder/lutinBuilder_s.py

@@ -15,19 +15,19 @@ def init():
 ## Get the current builder type.
 ## Return the type of builder
 ##
-def getType():
+def get_type():
 	return "compiler"
 
 ##
 ## @brief Get builder input file type
 ## @return List of extention supported
 ##
-def getInputType():
+def get_input_type():
 	return ["s", "S"]
 
 ##
 ## @brief Get builder output file type
 ## @return List of extention supported
 ##
-def getOutputType():
+def get_output_type():
 	return ["o"]

lutinBuilder.py

@@ -47,7 +47,7 @@ def import_path(path):
 			builder_list.append({"name":builder_name,
 			                     "element":the_builder
 			                    })
-			debug.debug('BUILDER:     type=' + the_builder.getType() + " in=" + str(the_builder.getInputType()) + " out=" + str(the_builder.getOutputType()))
+			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():
@@ -57,13 +57,23 @@ def init():
 		if element["element"] != None:
 			element["element"].init()
 
-def getBuilder(input_type):
+def get_builder(input_type):
 	global builder_list
 	for element in builder_list:
 		if element["element"] != None:
-			if input_type in element["element"].getInputType():
+			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) + "'")
-	return None
+	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))

lutinHeritage.py

@@ -43,7 +43,7 @@ class HeritageList:
 			if element.name == heritage.name:
 				return
 		self.listHeritage.append(heritage)
-		self.regenerateTree()
+		self.regenerate_tree()
 		
 	def add_heritage_list(self, heritage_list):
 		if type(heritage_list) == type(None):
@@ -55,9 +55,9 @@ class HeritageList:
 					find = True
 			if find == False:
 				self.listHeritage.append(herit)
-		self.regenerateTree()
+		self.regenerate_tree()
 	
-	def regenerateTree(self):
+	def regenerate_tree(self):
 		self.flags={}
 		# sources list:
 		self.src=[]
@@ -91,22 +91,28 @@ class HeritageList:
 		for element in self.listHeritage:
 			debug.verbose("	" + element.name + " " + str(element.depends))
 		for element in reversed(self.listHeritage):
-			debug.debug("elem : " + str(element.flags))
 			for flags in element.flags:
+				if flags in ["c-version", "c++-version"]:
+					continue
 				value = element.flags[flags]
-				debug.debug("    elem : " + str(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:
-			if self.flags_xx_version < element.flags_xx_version:
+				ver = element.flags["c-version"]
-				self.flags_xx_version = element.flags_xx_version
+				if "c-version" in self.flags:
-			if self.flags_cc_version < element.flags_cc_version:
+					if self.flags["c-version"] > ver:
-				self.flags_cc_version = element.flags_cc_version
+						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:
@@ -126,13 +132,9 @@ class heritage:
 			# 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"]
-			if "c++-version" in self.flags:
-				self.flags["c++-version"] = self.flags["c++-version"]["api-version"]
-			if "c-version" in self.flags:
-				self.flags["c-version"] = self.flags["c-version"]["api-version"]
-			
 	
 	def add_depends(self, depend):
 		self.depends.append(depend)
@@ -160,11 +162,17 @@ class heritage:
 				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"]:
-		if self.flags_xx_version < module.xx_version_api:
+			ver = module.flags["export"]["c-version"]
-			self.flags_xx_version = module.xx_version_api
+			if "c-version" in self.flags:
-		if self.flags_cc_version < module.cc_version_api:
+				if self.flags["c-version"] > ver:
-			self.flags_cc_version = module.cc_version_api
+					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
 
 

lutinModule.py

@@ -35,8 +35,8 @@ class Module:
 	def __init__(self, file, moduleName, moduleType):
 		## Remove all variable to prevent error of multiple deffinition of the module ...
 		debug.verbose("Create a new module : '" + moduleName + "' TYPE=" + moduleType)
-		self.originFile=''
+		self.origin_file=''
-		self.originFolder=''
+		self.origin_folder=''
 		# type of the module:
 		self.type='LIBRARY'
 		# Name of the module
@@ -88,30 +88,30 @@ class Module:
 			debug.error('for module "%s"' %moduleName)
 			debug.error('    ==> error : "%s" ' %moduleType)
 			raise 'Input value error'
-		self.originFile = file;
+		self.origin_file = file;
-		self.originFolder = lutinTools.get_current_path(self.originFile)
+		self.origin_folder = lutinTools.get_current_path(self.origin_file)
-		self.localHeritage = heritage.heritage(self)
+		self.local_heritage = heritage.heritage(self)
 		
-		self.packageProp = { "COMPAGNY_TYPE" : set(""),
+		self.package_prop = { "COMPAGNY_TYPE" : set(""),
-		                     "COMPAGNY_NAME" : set(""),
+		                      "COMPAGNY_NAME" : set(""),
-		                     "COMPAGNY_NAME2" : set(""),
+		                      "COMPAGNY_NAME2" : set(""),
-		                     "MAINTAINER" : set([]),
+		                      "MAINTAINER" : set([]),
-		                     #"ICON" : set(""),
+		                      #"ICON" : set(""),
-		                     "SECTION" : set([]),
+		                      "SECTION" : set([]),
-		                     "PRIORITY" : set(""),
+		                      "PRIORITY" : set(""),
-		                     "DESCRIPTION" : set(""),
+		                      "DESCRIPTION" : set(""),
-		                     "VERSION" : set("0.0.0"),
+		                      "VERSION" : set("0.0.0"),
-		                     "VERSION_CODE" : "",
+		                      "VERSION_CODE" : "",
-		                     "NAME" : set("no-name"), # name of the application
+		                      "NAME" : set("no-name"), # name of the application
-		                     "ANDROID_MANIFEST" : "", # By default generate the manifest
+		                      "ANDROID_MANIFEST" : "", # By default generate the manifest
-		                     "ANDROID_JAVA_FILES" : ["DEFAULT"], # when user want to create his own services and activities
+		                      "ANDROID_JAVA_FILES" : ["DEFAULT"], # when user want to create his own services and activities
-		                     "ANDROID_RESOURCES" : [],
+		                      "ANDROID_RESOURCES" : [],
-		                     "ANDROID_APPL_TYPE" : "APPL", # the other mode is "WALLPAPER" ... and later "WIDGET"
+		                      "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)
+		                      "ANDROID_WALLPAPER_PROPERTIES" : [], # To create properties of the wallpaper (no use of EWOL display)
-		                     "RIGHT" : [],
+		                      "RIGHT" : [],
-		                     "ADMOD_POSITION" : "top"
+		                      "ADMOD_POSITION" : "top"
-		                    }
+		                     }
-		self.subHeritageList = None
+		self.sub_heritage_list = None
 	
 	##
 	## @brief add Some copilation flags for this module (and only this one)
@@ -143,7 +143,7 @@ class Module:
 	##
 	## @brief Commands for copying files
 	##
-	def image_to_staging(self, binaryName, target):
+	def image_to_staging(self, binary_name, target):
 		for source, destination, sizeX, sizeY in self.imageToCopy:
 			extension = source[source.rfind('.'):]
 			if     extension != ".png" \
@@ -151,14 +151,14 @@ class Module:
 			   and sizeX > 0:
 				debug.error("Can not manage image other than .png and jpg to resize : " + source);
 			displaySource = source
-			source = self.originFolder + "/" + source
+			source = self.origin_folder + "/" + source
 			if destination == "":
 				destination = source[source.rfind('/')+1:]
 				debug.verbose("Regenerate Destination : '" + destination + "'")
-			file_cmd = target.generate_file(binaryName, self.name, self.originFolder, destination, "image")[0]
+			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.originFolder+"/" + source)
+				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)
@@ -167,14 +167,14 @@ class Module:
 	##
 	## @brief Commands for copying files
 	##
-	def files_to_staging(self, binaryName, target):
+	def files_to_staging(self, binary_name, target):
 		for source, destination in self.files:
 			displaySource = source
-			source = self.originFolder + "/" + source
+			source = self.origin_folder + "/" + source
 			if destination == "":
 				destination = source[source.rfind('/')+1:]
 				debug.verbose("Regenerate Destination : '" + destination + "'")
-			file_cmd = target.generate_file(binaryName, self.name, self.originFolder, destination, "image")[0]
+			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)
@@ -182,38 +182,38 @@ class Module:
 	##
 	## @brief Commands for copying files
 	##
-	def folders_to_staging(self, binaryName, target):
+	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.originFolder + "/" + source, destination)
+			lutinTools.copy_anything_target(target, self.origin_folder + "/" + source, destination)
 	
 	# call here to build the module
-	def build(self, target, packageName):
+	def build(self, target, package_name):
 		# ckeck if not previously build
 		if target.is_module_build(self.name)==True:
-			if self.subHeritageList == None:
+			if self.sub_heritage_list == None:
-				self.localHeritage = heritage.heritage(self)
+				self.local_heritage = heritage.heritage(self)
-			return self.subHeritageList
+			return self.sub_heritage_list
-		# create the packege heritage
+		# create the package heritage
-		self.localHeritage = heritage.heritage(self)
+		self.local_heritage = heritage.heritage(self)
 		
-		if     packageName==None \
+		if     package_name==None \
 		   and (    self.type=="BINARY" \
 		         or self.type=="PACKAGE" ) :
 			# this is the endpoint binary ...
-			packageName = self.name
+			package_name = self.name
 		else :
 			# TODO : Set it better ...
 			None
 		
 		# build dependency before
-		listSubFileNeededTobuild = []
+		list_sub_file_needed_to_build = []
-		self.subHeritageList = heritage.HeritageList()
+		self.sub_heritage_list = heritage.HeritageList()
 		# optionnal dependency :
 		for dep, option, export in self.depends_optionnal:
-			inheritList, isBuilt = target.build_optionnal(dep, packageName)
+			inherit_list, isBuilt = target.build_optionnal(dep, package_name)
 			if isBuilt == True:
-				self.localHeritage.add_depends(dep);
+				self.local_heritage.add_depends(dep);
 				# TODO : Add optionnal Flags ...
 				#     ==> do it really better ...
 				if export == False:
@@ -221,29 +221,29 @@ class Module:
 				else:
 					self.add_export_flag_CC("-D"+option);
 			# add at the heritage list :
-			self.subHeritageList.add_heritage_list(inheritList)
+			self.sub_heritage_list.add_heritage_list(inherit_list)
 		for dep in self.depends:
-			inheritList = target.build(dep, packageName)
+			inherit_list = target.build(dep, package_name)
 			# add at the heritage list :
-			self.subHeritageList.add_heritage_list(inheritList)
+			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]
-			tmpBuilder = builder.getBuilder(fileExt);
+			try:
-			if tmpBuilder != None:
+				tmp_builder = builder.get_builder(fileExt);
-				resFile = tmpBuilder.compile(file,
+				resFile = tmp_builder.compile(file,
-				                             packageName,
+				                             package_name,
 				                             target,
-				                             self.subHeritageList,
+				                             self.sub_heritage_list,
 				                             flags = self.flags,
 				                             path = self.path,
 				                             name = self.name,
-				                             basic_folder = self.originFolder)
+				                             basic_folder = self.origin_folder)
-				listSubFileNeededTobuild.append(resFile)
+				list_sub_file_needed_to_build.append(resFile)
-			else:
+			except ValueError:
-				debug.warning(" UN-SUPPORTED file format:  '" + self.originFolder + "/" + file + "'")
+				debug.warning(" UN-SUPPORTED file format:  '" + self.origin_folder + "/" + file + "'")
 		
 		# when multiprocess availlable, we need to synchronize here ...
 		lutinMultiprocess.pool_synchrosize()
@@ -252,10 +252,28 @@ class Module:
 		if self.type=='PREBUILD':
 			debug.print_element("Prebuild", self.name, "==>", "find")
 		elif self.type=='LIBRARY':
-			resFile = self.link_to_a(listSubFileNeededTobuild, packageName, target, self.subHeritageList)
+			try:
-			self.localHeritage.add_sources(resFile)
+				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':
-			resFile = self.link_to_bin(listSubFileNeededTobuild, packageName, target, self.subHeritageList)
+			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)
@@ -263,36 +281,54 @@ class Module:
 		elif self.type=="PACKAGE":
 			if target.name=="Android":
 				# special case for android wrapper :
-				resFile = self.link_to_so(listSubFileNeededTobuild, packageName, target, self.subHeritageList, "libewol")
+				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:
-				resFile = self.link_to_bin(listSubFileNeededTobuild, packageName, target, self.subHeritageList)
+				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.packageProp, self.originFolder + "/..")
+				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.subHeritageList.add_heritage(self.localHeritage)
+		self.sub_heritage_list.add_heritage(self.local_heritage)
 		# return local dependency ...
-		return self.subHeritageList
+		return self.sub_heritage_list
 	
 	# call here to build the module
-	def build_tree(self, target, packageName):
+	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(packageName, target)
+		self.image_to_staging(package_name, target)
-		self.files_to_staging(packageName, target)
+		self.files_to_staging(package_name, target)
-		self.folders_to_staging(packageName, target)
+		self.folders_to_staging(package_name, target)
 		#build tree of all submodules
 		for dep in self.depends:
-			inherit = target.build_tree(dep, packageName)
+			inherit = target.build_tree(dep, package_name)
 	
 	
 	# call here to clean the module
@@ -395,9 +431,9 @@ class Module:
 		if same_as_api == True:
 			api_version = version
 		self.flags["local"]["c++-version"] = { "version":version,
-		                                       "api-version":api_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");
 	
@@ -410,9 +446,9 @@ class Module:
 		if same_as_api == True:
 			api_version = version
 		self.flags["local"]["c-version"] = { "version":version,
-		                                     "api-version":api_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");
 	
@@ -439,8 +475,8 @@ class Module:
 		print(' package : "' + self.name + "'")
 		print('-----------------------------------------------')
 		print('    type:"' + str(self.type) + "'")
-		print('    file:"' + str(self.originFile) + "'")
+		print('    file:"' + str(self.origin_file) + "'")
-		print('    folder:"' + str(self.originFolder) + "'")
+		print('    folder:"' + str(self.origin_folder) + "'")
 		
 		self.print_list('depends',self.depends)
 		self.print_list('depends_optionnal', self.depends_optionnal)
@@ -470,18 +506,18 @@ class Module:
 			if value not in ["com", "net", "org", "gov", "mil", "edu", "pri", "museum"]:
 				debug.error("can not set the value for this Input : '" + variable + "' : '" + value + "'")
 			else:
-				self.packageProp[variable] = value
+				self.package_prop[variable] = value
 		elif "COMPAGNY_NAME" == variable:
-			self.packageProp[variable] = value
+			self.package_prop[variable] = value
 			val2 = value.lower()
 			val2 = val2.replace(' ', '')
 			val2 = val2.replace('-', '')
 			val2 = val2.replace('_', '')
-			self.packageProp["COMPAGNY_NAME2"] = val2
+			self.package_prop["COMPAGNY_NAME2"] = val2
 		elif "ICON" == variable:
-			self.packageProp[variable] = value
+			self.package_prop[variable] = value
 		elif "MAINTAINER" == variable:
-			self.packageProp[variable] = value
+			self.package_prop[variable] = value
 		elif "SECTION" == variable:
 			# project section : (must be separate by coma
 			#    refer to : http://packages.debian.org/sid/
@@ -493,39 +529,39 @@ class Module:
 			#        mail math misc net news ocaml oldlibs otherosfs
 			#        perl php python ruby science shells sound tex
 			#        text utils vcs video virtual web x11 xfce zope ...
-			self.packageProp[variable] = value
+			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.packageProp[variable] = value
+				self.package_prop[variable] = value
 		elif "DESCRIPTION" == variable:
-			self.packageProp[variable] = value
+			self.package_prop[variable] = value
 		elif "VERSION" == variable:
-			self.packageProp[variable] = value
+			self.package_prop[variable] = value
 		elif "VERSION_CODE" == variable:
-			self.packageProp[variable] = value
+			self.package_prop[variable] = value
 		elif "NAME" == variable:
-			self.packageProp[variable] = value
+			self.package_prop[variable] = value
 		elif "ANDROID_MANIFEST" == variable:
-			self.packageProp[variable] = value
+			self.package_prop[variable] = value
 		elif "ANDROID_JAVA_FILES" == variable:
-			self.packageProp[variable] = value
+			self.package_prop[variable] = value
 		elif "RIGHT" == variable:
-			self.packageProp[variable] = value
+			self.package_prop[variable] = value
 		elif "ANDROID_RESOURCES" == variable:
-			self.packageProp[variable] = value
+			self.package_prop[variable] = value
 		elif "ANDROID_APPL_TYPE" == variable:
-			self.packageProp[variable] = value
+			self.package_prop[variable] = value
 		elif "ADMOD_ID" == variable:
-			self.packageProp[variable] = value
+			self.package_prop[variable] = value
 		elif "APPLE_APPLICATION_IOS_ID" == variable:
-			self.packageProp[variable] = value
+			self.package_prop[variable] = value
 		elif "ADMOD_POSITION" == variable:
 			if value in ["top", "bottom"]:
-				self.packageProp[variable] = value
+				self.package_prop[variable] = value
 			else:
 				debug.error("not know pkg element : '" + variable + "' with value : '" + value + "' must be [top|bottom]")
 		else:
@@ -533,20 +569,20 @@ class Module:
 	
 	def pkg_add(self, variable, value):
 		# TODO : Check values...
-		self.packageProp[variable].append(value)
+		self.package_prop[variable].append(value)
 	
-	def ext_project_add_module(self, target, projectMng, addedModule = []):
+	def ext_project_add_module(self, target, projectMng, added_module = []):
-		if self.name in addedModule:
+		if self.name in added_module:
 			return
-		addedModule.append(self.name)
+		added_module.append(self.name)
 		debug.verbose("add a module to the project generator :" + self.name)
-		debug.verbose("local path :" + self.originFolder)
+		debug.verbose("local path :" + self.origin_folder)
-		projectMng.add_files(self.name, self.originFolder, self.src)
+		projectMng.add_files(self.name, self.origin_folder, self.src)
-		#projectMng.add_data_file(self.originFolder, self.files)
+		#projectMng.add_data_file(self.origin_folder, self.files)
-		#projectMng.add_data_folder(self.originFolder, self.folders)
+		#projectMng.add_data_folder(self.origin_folder, self.folders)
 		"""
 		for depend in self.depends:
-			target.project_add_module(depend, projectMng, addedModule)
+			target.project_add_module(depend, projectMng, added_module)
 		"""
 	
 	def create_project(self, target, projectMng):