[DEV] continue reintegration

builder/lutinBuilder_binary.py

@@ -2,6 +2,12 @@
 ## Executable/binary builder
 ##
 
+##
+## 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
@@ -10,10 +16,25 @@ def getType():
 	return "linker"
 
 
+##
+## @brief Get builder input file type
+## @return List of extention supported
+##
+def getInputType():
+	return ["o"]
+
+##
+## @brief Get builder output file type
+## @return List of extention supported
+##
+def getOutputType():
+	return ["", "exe"]
+
+
 ##
 ## @brief Commands for running gcc to link an executable.
 ##
-def link(self, file, binary, target, depancy, libName=""):
+def link(file, binary, target, depancy, libName=""):
 	if libName=="":
 		libName = self.name
 	file_src, file_dst, file_depend, file_cmd = target.generate_file(binary, libName,self.originFolder,file,"bin")

builder/lutinBuilder_c.py

@@ -1,6 +1,19 @@
 ##
 ## C builder
 ##
+import lutinMultiprocess
+import lutinTools
+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.
@@ -10,41 +23,113 @@ def getType():
 	return "compiler"
 
 ##
-## @brief Get builder file type
+## @brief Get builder input file type
 ## @return List of extention supported
 ##
-def getBuildType():
+def getInputType():
 	return ["c", "C"]
 
+##
+## @brief Get builder output file type
+## @return List of extention supported
+##
+def getOutputType():
+	return ["o"]
+
 ##
 ## @brief Commands for running gcc to compile a C file in object file.
 ##
-def compile(self, file, binary, target, depancy):
+def compile(file, binary, target, depancy, flags, path, name, basic_folder):
-	file_src, file_dst, file_depend, file_cmd = target.file_generate_object(binary,self.name,self.originFolder,file)
+	file_src, file_dst, file_depend, file_cmd = target.file_generate_object(binary, name, basic_folder,file)
+	
 	# create the command line befor requesting start:
-	cmdLine=lutinTools.list_to_str([
+	cmd = [
 		target.cc,
 		"-o", file_dst,
 		target.arch,
 		target.sysroot,
-		target.global_include_cc,
+		target.global_include_cc]
-		lutinTools.add_prefix("-I",self.export_path),
+	try:
-		lutinTools.add_prefix("-I",self.local_path),
+		cmd.append(lutinTools.add_prefix("-I", path["export"]))
-		lutinTools.add_prefix("-I",depancy.path),
+	except:
-		self.get_c_version_compilation_flags(depancy.flags_cc_version),
+		pass
-		target.global_flags_cc,
+	try:
-		depancy.flags_cc,
+		cmd.append(lutinTools.add_prefix("-I", path["local"]))
-		self.flags_cc,
+	except:
-		self.export_flags_cc,
+		pass
-		" -c -MMD -MP",
+	try:
-		file_src])
+		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 False==dependency.need_re_build(file_dst, file_src, file_depend, file_cmd, cmdLine):
+	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", self.name, "<==", file]
+	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

builder/lutinBuilder_cpp.py

@@ -1,6 +1,18 @@
 ##
 ## C++ builder
 ##
+import lutinMultiprocess
+import lutinTools
+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.
@@ -10,45 +22,129 @@ def getType():
 	return "compiler"
 
 ##
-## @brief Get builder file type
+## @brief Get builder input file type
 ## @return List of extention supported
 ##
-def getBuildType():
+def getInputType():
 	return ["cpp", "CPP", "cxx", "CXX", "xx", "XX", "CC", "cc"]
 
+##
+## @brief Get builder output file type
+## @return List of extention supported
+##
+def getOutputType():
+	return ["o"]
 
 ##
 ## @brief Commands for running gcc to compile a C++ file in object file.
 ##
-def compile(self, file, binary, target, depancy):
+def compile(file, binary, target, depancy, flags, path, name, basic_folder):
-	file_src, file_dst, file_depend, file_cmd = target.file_generate_object(binary,self.name,self.originFolder,file)
+	file_src, file_dst, file_depend, file_cmd = target.file_generate_object(binary, name, basic_folder, file)
 	
 	# create the command line befor requesting start:
-	cmdLine=lutinTools.list_to_str([
+	cmd = [
 		target.xx,
 		"-o", file_dst,
 		target.arch,
 		target.sysroot,
-		target.global_include_cc,
+		target.global_include_cc
-		lutinTools.add_prefix("-I",self.export_path),
+		]
-		lutinTools.add_prefix("-I",self.local_path),
+	try:
-		lutinTools.add_prefix("-I",depancy.path),
+		cmd.append(lutinTools.add_prefix("-I",path["export"]))
-		self.get_xx_version_compilation_flags(depancy.flags_xx_version),
+	except:
-		target.global_flags_cc,
+		pass
-		target.global_flags_xx,
+	try:
-		depancy.flags_cc,
+		cmd.append(lutinTools.add_prefix("-I",path["local"]))
-		depancy.flags_xx,
+	except:
-		self.flags_xx,
+		pass
-		self.flags_cc,
+	try:
-		self.export_flags_xx,
+		cmd.append(lutinTools.add_prefix("-I",depancy.path))
-		self.export_flags_cc,
+	except:
-		" -c -MMD -MP",
+		pass
-		file_src])
+	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 False==dependency.need_re_build(file_dst, file_src, file_depend, file_cmd, cmdLine):
+	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++", self.name, "<==", file]
+	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

builder/lutinBuilder_java.py

@@ -1,6 +1,15 @@
 ##
 ## Java 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.
@@ -10,8 +19,15 @@ def getType():
 	return "compiler"
 
 ##
-## @brief Get builder file type
+## @brief Get builder input file type
 ## @return List of extention supported
 ##
-def getBuildType():
+def getInputType():
 	return ["java"]
+
+##
+## @brief Get builder output file type
+## @return List of extention supported
+##
+def getOutputType():
+	return ["class"]

builder/lutinBuilder_libraryDynamic.py

@@ -1,6 +1,15 @@
 ##
 ## Dynamic library 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.
@@ -9,10 +18,24 @@
 def getType():
 	return "linker"
 
+##
+## @brief Get builder input file type
+## @return List of extention supported
+##
+def getInputType():
+	return ["o"]
+
+##
+## @brief Get builder output file type
+## @return List of extention supported
+##
+def getOutputType():
+	return ["so", "dynlib", "dll"]
+
 ##
 ## @brief Commands for running gcc to link a shared library.
 ##
-def link(self, file, binary, target, depancy, libName=""):
+def link(file, binary, target, depancy, libName=""):
 	if libName=="":
 		libName = self.name
 	file_src, file_dst, file_depend, file_cmd = target.generate_file(binary, libName,self.originFolder,file,"lib-shared")

builder/lutinBuilder_libraryStatic.py

@@ -1,6 +1,15 @@
 ##
 ## Static library 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.
@@ -9,10 +18,24 @@
 def getType():
 	return "linker"
 
+##
+## @brief Get builder input file type
+## @return List of extention supported
+##
+def getInputType():
+	return ["o"]
+
+##
+## @brief Get builder output file type
+## @return List of extention supported
+##
+def getOutputType():
+	return ["a"]
+
 ##
 ## @brief Commands for running ar.
 ##
-def link(self, file, binary, target, depancy, libName=""):
+def link(file, binary, target, depancy, libName=""):
 	if libName == "":
 		libName = self.name
 	file_src, file_dst, file_depend, file_cmd = target.generate_file(binary, libName,self.originFolder,file,"lib-static")

builder/lutinBuilder_m.py

@@ -1,6 +1,21 @@
 ##
 ## 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.getBuilder("c")
 
 ##
 ## Get the current builder type.
@@ -10,44 +25,89 @@ def getType():
 	return "compiler"
 
 ##
-## @brief Get builder file type
+## @brief Get builder input file type
 ## @return List of extention supported
 ##
-def getBuildType():
+def getInputType():
 	return ["m", "M"]
 
+##
+## @brief Get builder output file type
+## @return List of extention supported
+##
+def getOutputType():
+	return ["o"]
+
 ##
 ## @brief Commands for running gcc to compile a m file in object file.
 ##
-def compile(self, file, binary, target, depancy):
+def compile(file, binary, target, depancy, flags, path, name, basic_folder):
-	file_src, file_dst, file_depend, file_cmd = target.file_generate_object(binary,self.name,self.originFolder,file)
+	file_src, file_dst, file_depend, file_cmd = target.file_generate_object(binary, name, basic_folder, file)
 	# create the command line befor requesting start:
-	cmdLine=lutinTools.list_to_str([
+	cmd = [
 		target.cc,
 		"-o", file_dst ,
 		target.arch,
 		target.sysroot,
-		target.global_include_cc,
+		target.global_include_cc]
-		lutinTools.add_prefix("-I",self.export_path),
+	try:
-		lutinTools.add_prefix("-I",self.local_path),
+		cmd.append(lutinTools.add_prefix("-I",path["export"]))
-		lutinTools.add_prefix("-I",depancy.path),
+	except:
-		self.get_c_version_compilation_flags(depancy.flags_cc_version),
+		pass
-		target.global_flags_cc,
+	try:
-		target.global_flags_m,
+		cmd.append(lutinTools.add_prefix("-I",path["local"]))
-		depancy.flags_cc,
+	except:
-		depancy.flags_m,
+		pass
-		self.flags_m,
+	try:
-		self.flags_cc,
+		cmd.append(lutinTools.add_prefix("-I",depancy.path))
-		self.export_flags_m,
+	except:
-		self.export_flags_cc,
+		pass
-		"-c -MMD -MP",
+	try:
-		"-x objective-c",
+		cmd.append(local_ref_on_builder_c.get_version_compilation_flags(flags, depancy.flags))
-		file_src])
+	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", self.name, "<==", file]
+	comment = ["m", name, "<==", file]
 	#process element
 	lutinMultiprocess.run_in_pool(cmdLine, comment, file_cmd)
 	return file_dst

builder/lutinBuilder_mm.py

@@ -1,6 +1,21 @@
 ##
 ## 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.getBuilder("cpp")
 
 ##
 ## Get the current builder type.
@@ -10,44 +25,101 @@ def getType():
 	return "compiler"
 
 ##
-## @brief Get builder file type
+## @brief Get builder input file type
 ## @return List of extention supported
 ##
-def getBuildType():
+def getInputType():
 	return ["mm", "MM"]
 
+##
+## @brief Get builder output file type
+## @return List of extention supported
+##
+def getOutputType():
+	return ["o"]
+
 ##
 ## @brief Commands for running gcc to compile a m++ file in object file.
 ##
-def compile(self, file, binary, target, depancy):
+def compile(file, binary, target, depancy, flags, path, name, basic_folder):
-	file_src, file_dst, file_depend, file_cmd = target.file_generate_object(binary,self.name,self.originFolder,file)
+	file_src, file_dst, file_depend, file_cmd = target.file_generate_object(binary, name, basic_folder, file)
 	# create the command line befor requesting start:
-	cmdLine=lutinTools.list_to_str([
+	cmd = [
 		target.xx,
 		"-o", file_dst,
 		target.arch,
 		target.sysroot,
-		target.global_include_cc,
+		target.global_include_cc]
-		lutinTools.add_prefix("-I",self.export_path),
+	try:
-		lutinTools.add_prefix("-I",self.local_path),
+		cmd.append(lutinTools.add_prefix("-I",path["export"]))
-		lutinTools.add_prefix("-I",depancy.path),
+	except:
-		self.get_xx_version_compilation_flags(depancy.flags_xx_version),
+		pass
-		target.global_flags_cc,
+	try:
-		target.global_flags_mm,
+		cmd.append(lutinTools.add_prefix("-I",path["local"]))
-		depancy.flags_cc,
+	except:
-		depancy.flags_mm,
+		pass
-		self.flags_mm,
+	try:
-		self.flags_cc,
+		cmd.append(lutinTools.add_prefix("-I",depancy.path))
-		self.export_flags_mm,
+	except:
-		self.export_flags_cc,
+		pass
-		"-c -MMD -MP",
+	try:
-		"-x objective-c++",
+		cmd.append(local_ref_on_builder_cpp.get_version_compilation_flags(flags, depancy.flags))
-		file_src])
+	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++", self.name, "<==", file]
+	comment = ["m++", name, "<==", file]
 	#process element
 	lutinMultiprocess.run_in_pool(cmdLine, comment, file_cmd)
 	return file_dst

builder/lutinBuilder_s.py

@@ -1,6 +1,15 @@
 ##
 ## 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.
@@ -10,8 +19,15 @@ def getType():
 	return "compiler"
 
 ##
-## @brief Get builder file type
+## @brief Get builder input file type
 ## @return List of extention supported
 ##
-def getBuildType():
+def getInputType():
 	return ["s", "S"]
+
+##
+## @brief Get builder output file type
+## @return List of extention supported
+##
+def getOutputType():
+	return ["o"]

lutin.py

@@ -234,7 +234,7 @@ if __name__ == '__main__':
 					lutinSystem.import_path(folder)
 					lutinTarget.import_path(folder)
 		#lutinSystem.display()
-	exit(-1)
+	lutinBuilder.init()
 	Start()
 
 

lutinBuilder.py

@@ -44,5 +44,26 @@ def import_path(path):
 			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})
+			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()))
+
+# 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 getBuilder(input_type):
+	global builder_list
+	for element in builder_list:
+		if element["element"] != None:
+			if input_type in element["element"].getInputType():
+				return element["element"]
+	# we can not find the builder ...
+	debug.error("Can not find builder for type : '" + str(input_type) + "'")
+	return None
 

lutinHeritage.py

@@ -26,13 +26,7 @@ def append_to_list(listout, list):
 
 class HeritageList:
 	def __init__(self, heritage = None):
-		self.flags_ld=[]
+		self.flags={}
-		self.flags_cc=[]
-		self.flags_xx=[]
-		self.flags_m=[]
-		self.flags_mm=[]
-		self.flags_xx_version=1999
-		self.flags_cc_version=1989
 		# sources list:
 		self.src=[]
 		self.path=[]
@@ -42,7 +36,8 @@ class HeritageList:
 			self.add_heritage(heritage)
 	
 	def add_heritage(self, heritage):
-		if type(heritage) == type(None) or heritage.name == "":
+		if    type(heritage) == type(None) \
+		   or heritage.name == "":
 			return
 		for element in self.listHeritage:
 			if element.name == heritage.name:
@@ -63,13 +58,7 @@ class HeritageList:
 		self.regenerateTree()
 	
 	def regenerateTree(self):
-		self.flags_ld=[]
+		self.flags={}
-		self.flags_cc=[]
-		self.flags_xx=[]
-		self.flags_xx_version=1999
-		self.flags_xx_version=1989
-		self.flags_m=[]
-		self.flags_mm=[]
 		# sources list:
 		self.src=[]
 		self.path=[]
@@ -102,17 +91,22 @@ class HeritageList:
 		for element in self.listHeritage:
 			debug.verbose("	" + element.name + " " + str(element.depends))
 		for element in reversed(self.listHeritage):
-			append_to_list(self.flags_ld, element.flags_ld)
+			debug.debug("elem : " + str(element.flags))
-			append_to_list(self.flags_cc, element.flags_cc)
+			for flags in element.flags:
-			append_to_list(self.flags_xx, element.flags_xx)
+				value = element.flags[flags]
-			append_to_list(self.flags_m, element.flags_m)
+				debug.debug("    elem : " + str(flags))
-			append_to_list(self.flags_mm, element.flags_mm)
+				if flags not in self.flags:
+					self.flags[flags] = value
+				else:
+					append_to_list(self.flags[flags], value)
 			append_to_list(self.path, element.path)
 			append_to_list(self.src, element.src)
+			"""
 			if self.flags_xx_version < element.flags_xx_version:
 				self.flags_xx_version = element.flags_xx_version
 			if self.flags_cc_version < element.flags_cc_version:
 				self.flags_cc_version = element.flags_cc_version
+			"""
 
 
 class heritage:
@@ -121,13 +115,7 @@ class heritage:
 		self.depends=[]
 		## Remove all variable to prevent error of multiple definition
 		# all the parameter that the upper classe need when build
-		self.flags_ld=[]
+		self.flags={}
-		self.flags_cc=[]
-		self.flags_xx=[]
-		self.flags_xx_version=1999
-		self.flags_cc_version=1989
-		self.flags_m=[]
-		self.flags_mm=[]
 		# sources list:
 		self.src=[]
 		self.path=[]
@@ -138,33 +126,17 @@ class heritage:
 			# all the parameter that the upper classe need when build
 			self.name = module.name
 			self.depends = copy.deepcopy(module.depends)
-			self.flags_ld = module.export_flags_ld
+			self.flags = module.flags["export"]
-			self.flags_cc = module.export_flags_cc
+			self.path = module.path["export"]
-			self.flags_xx = module.export_flags_xx
+			if "c++-version" in self.flags:
-			self.flags_m = module.export_flags_m
+				self.flags["c++-version"] = self.flags["c++-version"]["api-version"]
-			self.flags_mm = module.export_flags_mm
+			if "c-version" in self.flags:
-			self.path = module.export_path
+				self.flags["c-version"] = self.flags["c-version"]["api-version"]
-			self.flags_xx_version = module.xx_version_api
+			
-			self.flags_cc_version = module.cc_version_api
 	
 	def add_depends(self, depend):
 		self.depends.append(depend)
 	
-	def add_flag_LD(self, list):
-		append_to_list(self.flags_ld, list)
-	
-	def add_flag_CC(self, list):
-		append_to_list(self.flags_cc, list)
-	
-	def add_flag_XX(self, list):
-		append_to_list(self.flags_xx, list)
-	
-	def add_flag_M(self, list):
-		append_to_list(self.flags_m, list)
-	
-	def add_flag_MM(self, list):
-		append_to_list(self.flags_mm, list)
-	
 	def add_import_path(self, list):
 		append_to_list(self.path, list)
 	
@@ -180,16 +152,19 @@ class heritage:
 			return
 		if other.hasBeenUpdated == True:
 			self.hasBeenUpdated = True
-		self.add_flag_LD(other.flags_ld)
+		for flags in other.flags:
-		self.add_flag_CC(other.flags_cc)
+			value = other.flags[flags]
-		self.add_flag_XX(other.flags_xx)
+			if flags not in self.flags:
-		self.add_flag_M(other.flags_m)
+				self.flags[flags] = value
-		self.add_flag_MM(other.flags_mm)
+			else:
+				append_to_list(self.flags[flags], value)
 		self.add_import_path(other.path)
 		self.add_sources(other.src)
+		"""
 		if self.flags_xx_version < module.xx_version_api:
 			self.flags_xx_version = module.xx_version_api
 		if self.flags_cc_version < module.cc_version_api:
 			self.flags_cc_version = module.cc_version_api
+		"""
 
 

lutinModule.py

@@ -17,6 +17,7 @@ import lutinTools
 import lutinDebug as debug
 import lutinHeritage as heritage
 import lutinDepend as dependency
+import lutinBuilder as builder
 import lutinMultiprocess
 import lutinEnv
 
@@ -48,8 +49,13 @@ class Module:
 		# Documentation list:
 		self.documentation = None
 		# export PATH
-		self.export_path = []
+		self.path = {"export":[],
-		self.local_path = []
+		             "local":[]
+		            }
+		self.flags = {"export":{},
+		              "local":{}
+		             }
+		"""
 		self.export_flags_ld = []
 		self.export_flags_cc = []
 		self.export_flags_xx = []
@@ -63,6 +69,7 @@ class Module:
 		self.flags_mm = []
 		self.flags_s = []
 		self.flags_ar = []
+		"""
 		# sources list:
 		self.src = []
 		# copy files and folders:
@@ -70,13 +77,6 @@ class Module:
 		self.files = []
 		self.folders = []
 		self.isbuild = False
-		# CPP version:
-		self.xx_version = 1999
-		self.xx_version_gnu = False
-		self.xx_version_api = 1999
-		self.cc_version = 1989
-		self.cc_version_gnu = False
-		self.cc_version_api = 1989
 		
 		## end of basic INIT ...
 		if    moduleType == 'BINARY' \
@@ -140,60 +140,6 @@ class Module:
 			])
 		# only for gcc :"-Wno-unused-but-set-variable"
 	
-	def get_c_version_compilation_flags(self, dependency_version):
-		cc_version = max(self.cc_version, dependency_version)
-		if cc_version == 2011:
-			if self.cc_version_gnu ==True:
-				local_cc_version_flags=["-std=gnu11", "-D__C_VERSION__=2011"]
-			else:
-				local_cc_version_flags=["-std=c11", "-D__C_VERSION__=1989"]
-		elif cc_version == 1999:
-			if self.cc_version_gnu ==True:
-				local_cc_version_flags=["-std=gnu99", "-D__C_VERSION__=1999"]
-			else:
-				local_cc_version_flags=["-std=c99", "-D__C_VERSION__=1989"]
-		elif cc_version == 1990:
-			if self.cc_version_gnu ==True:
-				local_cc_version_flags=["-std=gnu90", "-D__C_VERSION__=1990"]
-			else:
-				local_cc_version_flags=["-std=c90", "-D__C_VERSION__=1989"]
-		else:
-			if self.cc_version_gnu ==True:
-				local_cc_version_flags=["-std=gnu89", "-D__C_VERSION__=1989"]
-			else:
-				local_cc_version_flags=["-std=c89", "-D__C_VERSION__=1989"]
-		return local_cc_version_flags
-	
-	
-	def get_xx_version_compilation_flags(self, dependency_version):
-		xx_version = max(self.xx_version, dependency_version)
-		if xx_version == 2014:
-			debug.error("not supported flags for X14 ...");
-			if self.xx_version_gnu == True:
-				local_xx_version_flags=["-std=gnu++14", "-D__CPP_VERSION__=2014"]
-			else:
-				local_xx_version_flags=["-std=c++14", "-D__CPP_VERSION__=2014"]
-		elif xx_version == 2011:
-			if self.xx_version_gnu == True:
-				local_xx_version_flags=["-std=gnu++11", "-D__CPP_VERSION__=2011"]
-			else:
-				local_xx_version_flags=["-std=c++11", "-D__CPP_VERSION__=2011"]
-		elif xx_version == 2003:
-			if self.xx_version_gnu == True:
-				local_xx_version_flags=["-std=gnu++03", "-D__CPP_VERSION__=2003"]
-			else:
-				local_xx_version_flags=["-std=c++03", "-D__CPP_VERSION__=2003"]
-		else:
-			if self.xx_version_gnu == True:
-				local_xx_version_flags=["-std=gnu++98", "-D__CPP_VERSION__=1999"]
-			else:
-				local_xx_version_flags=["-std=c++98", "-D__CPP_VERSION__=1999"]
-		return local_xx_version_flags
-	
-	
-	
-	
-	
 	##
 	## @brief Commands for copying files
 	##
@@ -285,20 +231,20 @@ class Module:
 		for file in self.src:
 			#debug.info(" " + self.name + " <== " + file);
 			fileExt = file.split(".")[-1]
-			if    fileExt in ["c", "C"]:
+			tmpBuilder = builder.getBuilder(fileExt);
-				resFile = self.compile_cc_to_o(file, packageName, target, self.subHeritageList)
+			if tmpBuilder != None:
-				listSubFileNeededTobuild.append(resFile)
+				resFile = tmpBuilder.compile(file,
-			elif    fileExt in ["cpp", "CPP", "cxx", "CXX", "xx", "XX", "CC", "cc"]:
+				                             packageName,
-				resFile = self.compile_xx_to_o(file, packageName, target, self.subHeritageList)
+				                             target,
-				listSubFileNeededTobuild.append(resFile)
+				                             self.subHeritageList,
-			elif    fileExt in ["mm", "MM"]:
+				                             flags = self.flags,
-				resFile = self.compile_mm_to_o(file, packageName, target, self.subHeritageList)
+				                             path = self.path,
-				listSubFileNeededTobuild.append(resFile)
+				                             name = self.name,
-			elif    fileExt in ["m", "M"]:
+				                             basic_folder = self.originFolder)
-				resFile = self.compile_m_to_o(file, packageName, target, self.subHeritageList)
 				listSubFileNeededTobuild.append(resFile)
 			else:
 				debug.warning(" UN-SUPPORTED file format:  '" + self.originFolder + "/" + file + "'")
+		
 		# when multiprocess availlable, we need to synchronize here ...
 		lutinMultiprocess.pool_synchrosize()
 		
@@ -379,6 +325,13 @@ class Module:
 		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)
@@ -394,65 +347,73 @@ class Module:
 		self.append_and_check(self.depends_optionnal, [module_name, compilation_flags, export], True)
 	
 	def add_export_path(self, list):
-		self.append_to_internalList(self.export_path, list)
+		self.append_to_internalList(self.path["export"], list)
 	
 	def add_path(self, list):
-		self.append_to_internalList(self.local_path, list)
+		self.append_to_internalList(self.path["local"], list)
 	
 	def add_export_flag_LD(self, list):
-		self.append_to_internalList(self.export_flags_ld, list)
+		self.append_to_internalList2(self.flags["export"], "link", list)
 	
 	def add_export_flag_CC(self, list):
-		self.append_to_internalList(self.export_flags_cc, list)
+		self.append_to_internalList2(self.flags["export"], "c", list)
 	
 	def add_export_flag_XX(self, list):
-		self.append_to_internalList(self.export_flags_xx, list)
+		self.append_to_internalList2(self.flags["export"], "c++", list)
 	
 	def add_export_flag_M(self, list):
-		self.append_to_internalList(self.export_flags_m, list)
+		self.append_to_internalList2(self.flags["export"], "m", list)
 	
 	def add_export_flag_MM(self, list):
-		self.append_to_internalList(self.export_flags_mm, 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_internalList(self.flags_ld, list)
+		self.append_to_internalList2(self.flags["local"], "link", list)
 	
 	def compile_flags_CC(self, list):
-		self.append_to_internalList(self.flags_cc, list)
+		self.append_to_internalList2(self.flags["local"], "c", list)
 	
 	def compile_flags_XX(self, list):
-		self.append_to_internalList(self.flags_xx, list)
+		self.append_to_internalList2(self.flags["local"], "c++", list)
 	
 	def compile_flags_M(self, list):
-		self.append_to_internalList(self.flags_m, list)
+		self.append_to_internalList2(self.flags["local"], "m", list)
 	
 	def compile_flags_MM(self, list):
-		self.append_to_internalList(self.flags_mm, list)
+		self.append_to_internalList2(self.flags["local"], "mm", list)
 	
 	def compile_flags_S(self, list):
-		self.append_to_internalList(self.flags_s, 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))
-		self.xx_version = version
+		# select API version:
+		api_version = 1999
 		if same_as_api == True:
-			self.xx_version_api = self.xx_version
+			api_version = version
-		self.xx_version_gnu = gnu
+		self.flags["local"]["c++-version"] = { "version":version,
-		if self.xx_version_gnu == True and same_as_api == True:
+		                                       "api-version":api_version,
+		                                       "gnu":gnu
+		                                     }
+		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))
-		self.cc_version = version
+		# select API version:
+		api_version = 1999
 		if same_as_api == True:
-			self.cc_version_api = self.cc_version
+			api_version = version
-		self.cc_version_gnu = gnu
+		self.flags["local"]["c-version"] = { "version":version,
-		if self.cc_version_gnu == True and same_as_api == True:
+		                                     "api-version":api_version,
+		                                     "gnu":gnu
+		                                   }
+		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):
@@ -480,24 +441,21 @@ class Module:
 		print('    type:"' + str(self.type) + "'")
 		print('    file:"' + str(self.originFile) + "'")
 		print('    folder:"' + str(self.originFolder) + "'")
+		
 		self.print_list('depends',self.depends)
 		self.print_list('depends_optionnal', self.depends_optionnal)
-		self.print_list('flags_ld',self.flags_ld)
+		
-		self.print_list('flags_cc',self.flags_cc)
+		for element,value in self.flags["local"]:
-		self.print_list('flags_xx',self.flags_xx)
+			self.print_list('flags ' + element, value)
-		self.print_list('flags_m',self.flags_m)
+		
-		self.print_list('flags_mm',self.flags_mm)
+		for element,value in self.flags["export"]:
-		self.print_list('flags_s',self.flags_s)
+			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.export_path)
+		self.print_list('export path',self.path["export"])
-		self.print_list('export_flags_ld',self.export_flags_ld)
+		self.print_list('local  path',self.path["local"])
-		self.print_list('export_flags_cc',self.export_flags_cc)
-		self.print_list('export_flags_xx',self.export_flags_xx)
-		self.print_list('export_flags_m',self.export_flags_m)
-		self.print_list('export_flags_mm',self.export_flags_mm)
-		self.print_list('local_path',self.local_path)
 	
 	def pkg_set(self, variable, value):
 		if "COMPAGNY_TYPE" == variable: