diff --git a/builder/lutinBuilder_binary.py b/builder/lutinBuilder_binary.py index 909c370..dd5fbf1 100644 --- a/builder/lutinBuilder_binary.py +++ b/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") diff --git a/builder/lutinBuilder_c.py b/builder/lutinBuilder_c.py index da493c6..9e231d8 100644 --- a/builder/lutinBuilder_c.py +++ b/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): - file_src, file_dst, file_depend, file_cmd = target.file_generate_object(binary,self.name,self.originFolder,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: - cmdLine=lutinTools.list_to_str([ + cmd = [ target.cc, "-o", file_dst, target.arch, target.sysroot, - target.global_include_cc, - lutinTools.add_prefix("-I",self.export_path), - lutinTools.add_prefix("-I",self.local_path), - lutinTools.add_prefix("-I",depancy.path), - self.get_c_version_compilation_flags(depancy.flags_cc_version), - target.global_flags_cc, - depancy.flags_cc, - self.flags_cc, - self.export_flags_cc, - " -c -MMD -MP", - file_src]) - + 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 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 - \ No newline at end of file + + +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 diff --git a/builder/lutinBuilder_cpp.py b/builder/lutinBuilder_cpp.py index 106e26a..da047e1 100644 --- a/builder/lutinBuilder_cpp.py +++ b/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): - file_src, file_dst, file_depend, file_cmd = target.file_generate_object(binary,self.name,self.originFolder,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: - cmdLine=lutinTools.list_to_str([ + cmd = [ target.xx, "-o", file_dst, target.arch, target.sysroot, - target.global_include_cc, - lutinTools.add_prefix("-I",self.export_path), - lutinTools.add_prefix("-I",self.local_path), - lutinTools.add_prefix("-I",depancy.path), - self.get_xx_version_compilation_flags(depancy.flags_xx_version), - target.global_flags_cc, - target.global_flags_xx, - depancy.flags_cc, - depancy.flags_xx, - self.flags_xx, - self.flags_cc, - self.export_flags_xx, - self.export_flags_cc, - " -c -MMD -MP", - file_src]) + 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 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 diff --git a/builder/lutinBuilder_java.py b/builder/lutinBuilder_java.py index 84ae4a8..4e36c22 100644 --- a/builder/lutinBuilder_java.py +++ b/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"] \ No newline at end of file diff --git a/builder/lutinBuilder_libraryDynamic.py b/builder/lutinBuilder_libraryDynamic.py index c43667c..bc79c8b 100644 --- a/builder/lutinBuilder_libraryDynamic.py +++ b/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") diff --git a/builder/lutinBuilder_libraryStatic.py b/builder/lutinBuilder_libraryStatic.py index d30afa8..38f3015 100644 --- a/builder/lutinBuilder_libraryStatic.py +++ b/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") diff --git a/builder/lutinBuilder_m.py b/builder/lutinBuilder_m.py index e86a796..017ade0 100644 --- a/builder/lutinBuilder_m.py +++ b/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): - file_src, file_dst, file_depend, file_cmd = target.file_generate_object(binary,self.name,self.originFolder,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: - cmdLine=lutinTools.list_to_str([ + cmd = [ target.cc, "-o", file_dst , target.arch, target.sysroot, - target.global_include_cc, - lutinTools.add_prefix("-I",self.export_path), - lutinTools.add_prefix("-I",self.local_path), - lutinTools.add_prefix("-I",depancy.path), - self.get_c_version_compilation_flags(depancy.flags_cc_version), - target.global_flags_cc, - target.global_flags_m, - depancy.flags_cc, - depancy.flags_m, - self.flags_m, - self.flags_cc, - self.export_flags_m, - self.export_flags_cc, - "-c -MMD -MP", - "-x objective-c", - file_src]) + 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", self.name, "<==", file] + comment = ["m", name, "<==", file] #process element lutinMultiprocess.run_in_pool(cmdLine, comment, file_cmd) return file_dst diff --git a/builder/lutinBuilder_mm.py b/builder/lutinBuilder_mm.py index 327a709..1d0a5b1 100644 --- a/builder/lutinBuilder_mm.py +++ b/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): - file_src, file_dst, file_depend, file_cmd = target.file_generate_object(binary,self.name,self.originFolder,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: - cmdLine=lutinTools.list_to_str([ + cmd = [ target.xx, "-o", file_dst, target.arch, target.sysroot, - target.global_include_cc, - lutinTools.add_prefix("-I",self.export_path), - lutinTools.add_prefix("-I",self.local_path), - lutinTools.add_prefix("-I",depancy.path), - self.get_xx_version_compilation_flags(depancy.flags_xx_version), - target.global_flags_cc, - target.global_flags_mm, - depancy.flags_cc, - depancy.flags_mm, - self.flags_mm, - self.flags_cc, - self.export_flags_mm, - self.export_flags_cc, - "-c -MMD -MP", - "-x objective-c++", - file_src]) + 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++", self.name, "<==", file] + comment = ["m++", name, "<==", file] #process element lutinMultiprocess.run_in_pool(cmdLine, comment, file_cmd) return file_dst diff --git a/builder/lutinBuilder_s.py b/builder/lutinBuilder_s.py index 3fb52b8..86ad493 100644 --- a/builder/lutinBuilder_s.py +++ b/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"] diff --git a/lutin.py b/lutin.py index 2825245..5aa4629 100755 --- a/lutin.py +++ b/lutin.py @@ -234,7 +234,7 @@ if __name__ == '__main__': lutinSystem.import_path(folder) lutinTarget.import_path(folder) #lutinSystem.display() - exit(-1) + lutinBuilder.init() Start() diff --git a/lutinBuilder.py b/lutinBuilder.py index bb04692..b9f5ab2 100644 --- a/lutinBuilder.py +++ b/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 diff --git a/lutinHeritage.py b/lutinHeritage.py index 351391e..fbbbfa2 100644 --- a/lutinHeritage.py +++ b/lutinHeritage.py @@ -26,13 +26,7 @@ def append_to_list(listout, list): class HeritageList: def __init__(self, heritage = None): - self.flags_ld=[] - self.flags_cc=[] - self.flags_xx=[] - self.flags_m=[] - self.flags_mm=[] - self.flags_xx_version=1999 - self.flags_cc_version=1989 + self.flags={} # sources list: self.src=[] self.path=[] @@ -42,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_cc=[] - self.flags_xx=[] - self.flags_xx_version=1999 - self.flags_xx_version=1989 - self.flags_m=[] - self.flags_mm=[] + self.flags={} # 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) - append_to_list(self.flags_cc, element.flags_cc) - append_to_list(self.flags_xx, element.flags_xx) - append_to_list(self.flags_m, element.flags_m) - append_to_list(self.flags_mm, element.flags_mm) + debug.debug("elem : " + str(element.flags)) + for flags in element.flags: + 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 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_cc=[] - self.flags_xx=[] - self.flags_xx_version=1999 - self.flags_cc_version=1989 - self.flags_m=[] - self.flags_mm=[] + self.flags={} # sources list: self.src=[] self.path=[] @@ -138,33 +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_cc = module.export_flags_cc - self.flags_xx = module.export_flags_xx - self.flags_m = module.export_flags_m - self.flags_mm = module.export_flags_mm - self.path = module.export_path - self.flags_xx_version = module.xx_version_api - self.flags_cc_version = module.cc_version_api + 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) - 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) - self.add_flag_CC(other.flags_cc) - self.add_flag_XX(other.flags_xx) - self.add_flag_M(other.flags_m) - self.add_flag_MM(other.flags_mm) + for flags in other.flags: + value = other.flags[flags] + if flags not in self.flags: + self.flags[flags] = value + else: + append_to_list(self.flags[flags], value) self.add_import_path(other.path) self.add_sources(other.src) + """ if self.flags_xx_version < module.xx_version_api: self.flags_xx_version = module.xx_version_api if self.flags_cc_version < module.cc_version_api: self.flags_cc_version = module.cc_version_api + """ diff --git a/lutinModule.py b/lutinModule.py index 05fe7a0..e0d2ece 100644 --- a/lutinModule.py +++ b/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.local_path = [] + self.path = {"export":[], + "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"]: - resFile = self.compile_cc_to_o(file, packageName, target, self.subHeritageList) - listSubFileNeededTobuild.append(resFile) - elif fileExt in ["cpp", "CPP", "cxx", "CXX", "xx", "XX", "CC", "cc"]: - resFile = self.compile_xx_to_o(file, packageName, target, self.subHeritageList) - listSubFileNeededTobuild.append(resFile) - elif fileExt in ["mm", "MM"]: - resFile = self.compile_mm_to_o(file, packageName, target, self.subHeritageList) - listSubFileNeededTobuild.append(resFile) - elif fileExt in ["m", "M"]: - resFile = self.compile_m_to_o(file, packageName, target, self.subHeritageList) + tmpBuilder = builder.getBuilder(fileExt); + if tmpBuilder != None: + resFile = tmpBuilder.compile(file, + packageName, + target, + self.subHeritageList, + flags = self.flags, + path = self.path, + name = self.name, + basic_folder = self.originFolder) 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 - self.xx_version_gnu = gnu - if self.xx_version_gnu == True and same_as_api == True: + api_version = version + self.flags["local"]["c++-version"] = { "version":version, + "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 - self.cc_version_gnu = gnu - if self.cc_version_gnu == True and same_as_api == True: + api_version = version + self.flags["local"]["c-version"] = { "version":version, + "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) - self.print_list('flags_xx',self.flags_xx) - self.print_list('flags_m',self.flags_m) - self.print_list('flags_mm',self.flags_mm) - self.print_list('flags_s',self.flags_s) + + 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.export_path) - self.print_list('export_flags_ld',self.export_flags_ld) - self.print_list('export_flags_cc',self.export_flags_cc) - self.print_list('export_flags_xx',self.export_flags_xx) - self.print_list('export_flags_m',self.export_flags_m) - self.print_list('export_flags_mm',self.export_flags_mm) - self.print_list('local_path',self.local_path) + 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: