From 7e41e6f393e06804ab1fbf2da77f7c6bf1892dc8 Mon Sep 17 00:00:00 2001 From: Edouard DUPIN Date: Thu, 18 Jun 2015 21:06:06 +0200 Subject: [PATCH] [DEV] rework the build of java file for android --- lutin/env.py | 62 ++++++++------- lutin/heritage.py | 15 +++- lutin/module.py | 64 +++++++++++----- lutin/target.py | 46 +++++++++--- lutin/tools.py | 12 +++ lutin/z_builder/lutinBuilder_c.py | 33 ++++---- lutin/z_builder/lutinBuilder_cpp.py | 63 +++++++--------- lutin/z_builder/lutinBuilder_jar.py | 67 +++++++++++++++++ lutin/z_builder/lutinBuilder_java.py | 51 ++++++++++++- .../z_builder/lutinBuilder_libraryDynamic.py | 5 +- lutin/z_builder/lutinBuilder_libraryStatic.py | 2 +- lutin/z_builder/lutinBuilder_m.py | 63 +++++++--------- lutin/z_builder/lutinBuilder_mm.py | 75 +++++++------------ 13 files changed, 353 insertions(+), 205 deletions(-) create mode 100644 lutin/z_builder/lutinBuilder_jar.py diff --git a/lutin/env.py b/lutin/env.py index 7bbe9ca..071f111 100644 --- a/lutin/env.py +++ b/lutin/env.py @@ -39,44 +39,54 @@ def get_print_pretty_mode(): global printPrettyMode return printPrettyMode +def end_with(name, list): + for appl in list: + if name[len(name)-len(appl):] == appl: + return True + return False + + def print_pretty(myString, force=False): global printPrettyMode if printPrettyMode == True \ or force == True: - if myString[len(myString)-1]==' ' : + if myString[len(myString)-1] == ' ': tmpcmdLine = myString[:len(myString)-1] - else : + else: tmpcmdLine = myString + cmdApplication = tmpcmdLine.split(' ')[0] tmpcmdLine = tmpcmdLine.replace(' ', '\n\t') tmpcmdLine = tmpcmdLine.replace('\n\t\n\t', '\n\t') tmpcmdLine = tmpcmdLine.replace('\n\t\n\t', '\n\t') tmpcmdLine = tmpcmdLine.replace('\n\t\n\t', '\n\t') - baseElementList = ["-o", - "-D", - "-I", - "-L", - "g++", - "gcc", - "clang", - "clang++", - "ar", - "ld", - "ranlib", - "-framework", - "-isysroot", - "-arch", - "-keystore", - "-sigalg", - "-digestalg", - "<", - "<<", - ">", - ">>"] + baseElementList = [] + if end_with(cmdApplication, ["g++", "gcc", "clang", "clang++", "ar", "ld", "ranlib"]) == True: + baseElementList = [ + "-o", + "-D", + "-I", + "-L", + "-framework", + "-isysroot", + "-arch", + "-keystore", + "-sigalg", + "-digestalg"] + elif end_with(cmdApplication, ["javac"]) == True: + baseElementList = [ + "-d", + "-D", + "-classpath", + "-sourcepath" + ] + elif end_with(cmdApplication, ["jar"]) == True: + baseElementList = [ + "cf" + ] for element in baseElementList: tmpcmdLine = tmpcmdLine.replace(element+'\n\t', element+' ') - baseElementList = ["g++", "gcc", "clang", "clang++", "ar", "ld", "ranlib"] - for element in baseElementList: - tmpcmdLine = tmpcmdLine.replace('/'+element+' ', '/'+element+'\n\t') + for element in ["<", "<<", ">", ">>"]: + tmpcmdLine = tmpcmdLine.replace(element+'\n\t', element+' ') tmpcmdLine = tmpcmdLine.replace('\n\t', ' \\\n\t') return tmpcmdLine diff --git a/lutin/heritage.py b/lutin/heritage.py index 8c2947d..36953cd 100644 --- a/lutin/heritage.py +++ b/lutin/heritage.py @@ -29,7 +29,7 @@ class HeritageList: self.flags={} # sources list: self.src=[] - self.path=[] + self.path={} self.listHeritage=[] if heritage != None: @@ -61,7 +61,7 @@ class HeritageList: self.flags={} # sources list: self.src=[] - self.path=[] + self.path={} # reorder heritage list : listHeritage = self.listHeritage self.listHeritage = [] @@ -99,7 +99,12 @@ class HeritageList: self.flags[flags] = value else: append_to_list(self.flags[flags], value) - append_to_list(self.path, element.path) + for ppp in element.path: + value = element.path[ppp] + if ppp not in self.path: + self.path[ppp] = value + else: + append_to_list(self.path[ppp], value) append_to_list(self.src, element.src) if "c-version" in element.flags: ver = element.flags["c-version"] @@ -124,7 +129,7 @@ class heritage: self.flags={} # sources list: self.src=[] - self.path=[] + self.path={} # update is set at true when data are newly created ==> force upper element to update self.hasBeenUpdated=False @@ -143,6 +148,8 @@ class heritage: append_to_list(self.path, list) def add_sources(self, list): + if type(list) == type(None): + debug.error("try add element none in a list ...") append_to_list(self.src, list) def need_update(self, list): diff --git a/lutin/module.py b/lutin/module.py index 68b0be4..b1cc20d 100644 --- a/lutin/module.py +++ b/lutin/module.py @@ -47,8 +47,8 @@ class Module: # Documentation list: self.documentation = None # export PATH - self.path = {"export":[], - "local":[] + self.path = {"export":{}, + "local":{} } self.flags = {"export":{}, "local":{} @@ -242,7 +242,6 @@ class Module: list_sub_file_needed_to_build.append(resFile) except ValueError: debug.warning(" UN-SUPPORTED file format: '" + self.origin_folder + "/" + file + "'") - # when multiprocess availlable, we need to synchronize here ... multiprocess.pool_synchrosize() @@ -252,15 +251,30 @@ class Module: elif self.type=='LIBRARY': try: tmp_builder = builder.get_builder_with_output("a"); - resFile = tmp_builder.link(list_sub_file_needed_to_build, - package_name, - target, - self.sub_heritage_list, - name = self.name, - basic_folder = self.origin_folder) - self.local_heritage.add_sources(resFile) + list_file = tools.filter_extention(list_sub_file_needed_to_build, tmp_builder.get_input_type()) + if len(list_file) > 0: + resFile = tmp_builder.link(list_file, + 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'") + try: + tmp_builder = builder.get_builder_with_output("jar"); + list_file = tools.filter_extention(list_sub_file_needed_to_build, tmp_builder.get_input_type()) + if len(list_file) > 0: + resFile = tmp_builder.link(list_file, + 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: '.jat'") elif self.type=='BINARY': try: tmp_builder = builder.get_builder_with_output("bin"); @@ -278,10 +292,12 @@ class Module: target.copy_to_staging(self.name) elif self.type=="PACKAGE": if target.name=="Android": - # special case for android wrapper : + # special case for android wrapper: try: tmp_builder = builder.get_builder_with_output("so"); - resFile = tmp_builder.link(list_sub_file_needed_to_build, + list_file = tools.filter_extention(list_sub_file_needed_to_build, tmp_builder.get_input_type()) + debug.info("plopppp " + str(list_file)) + resFile = tmp_builder.link(list_file, package_name, target, self.sub_heritage_list, @@ -380,11 +396,11 @@ class Module: def add_optionnal_module_depend(self, module_name, compilation_flags=["", ""], export=False): self.append_and_check(self.depends_optionnal, [module_name, compilation_flags, export], True) - def add_export_path(self, list): - self.append_to_internalList(self.path["export"], list) + def add_export_path(self, list, type='c'): + self.append_to_internalList2(self.path["export"], type, list) - def add_path(self, list): - self.append_to_internalList(self.path["local"], list) + def add_path(self, list, type='c'): + self.append_to_internalList2(self.path["local"], type, list) def add_export_flag(self, type, list): self.append_to_internalList2(self.flags["export"], type, list) @@ -452,17 +468,25 @@ class Module: self.print_list('depends',self.depends) self.print_list('depends_optionnal', self.depends_optionnal) - for element,value in self.flags["local"]: + for element in self.flags["local"]: + value = self.flags["local"][element] self.print_list('flags ' + element, value) - for element,value in self.flags["export"]: + for element in self.flags["export"]: + value = self.flags["export"][element] self.print_list('flags export ' + element, value) self.print_list('src',self.src) self.print_list('files',self.files) self.print_list('folders',self.folders) - self.print_list('export path',self.path["export"]) - self.print_list('local path',self.path["local"]) + for element in self.path["local"]: + value = self.path["local"][element] + self.print_list('local path ' + element, value) + + for element in self.path["export"]: + value = self.path["export"][element] + self.print_list('export path ' + element, value) + def pkg_set(self, variable, value): if "COMPAGNY_TYPE" == variable: diff --git a/lutin/target.py b/lutin/target.py index fd240af..214b51c 100644 --- a/lutin/target.py +++ b/lutin/target.py @@ -137,6 +137,8 @@ class Target: def set_cross_base(self, cross=""): self.cross = cross debug.debug("== Target='" + self.cross + "'"); + self.java = "javac" + self.jar = "jar" self.ar = self.cross + "ar" self.ranlib = self.cross + "ranlib" if self.config["compilator"] == "clang": @@ -206,13 +208,32 @@ class Target: self.folder_ewol = folder - def file_generate_object(self,binaryName,moduleName,basePath,file): - list=[] - list.append(basePath + "/" + file) - list.append(self.get_build_folder(moduleName) + "/" + file + self.suffix_obj) - list.append(self.get_build_folder(moduleName) + "/" + file + self.suffix_dependence) - list.append(self.get_build_folder(moduleName) + "/" + file + self.suffix_cmdLine) - return list + def get_full_name_source(self, basePath, file): + return basePath + "/" + file + + def get_full_name_cmd(self, moduleName, basePath, file): + return self.get_build_folder(moduleName) + "/" + file + self.suffix_cmdLine + + def get_full_name_destination(self, moduleName, basePath, file, suffix, remove_suffix=False): + # special patch for java file: + if file[-4:] == "java": + for elem in ["org/", "com/"]: + pos = file.find(elem); + if pos > 0: + file = file[pos:] + if remove_suffix == True: + file = file[:file.rfind(".")] + '.' + else: + file += "." + if len(suffix) >= 1: + suffix = suffix[0] + else: + suffix = "" + return self.get_build_folder(moduleName) + "/" + file + suffix + + def get_full_dependency(self, moduleName, basePath, file): + return self.get_build_folder(moduleName) + "/" + file + self.suffix_dependence + """ return a list of 3 elements : 0 : sources files (can be a list) @@ -225,17 +246,22 @@ class Target: list.append(file) list.append(self.get_staging_folder(binaryName) + "/" + self.folder_bin + "/" + moduleName + self.suffix_binary) list.append(self.get_build_folder(moduleName) + "/" + moduleName + self.suffix_dependence) - list.append(self.get_build_folder(binaryName) + "/" + self.folder_bin + "/" + moduleName + self.suffix_cmdLine) + list.append(self.get_build_folder(binaryName) + "/" + self.folder_bin + "/" + moduleName + self.suffix_binary + self.suffix_cmdLine) elif (type=="lib-shared"): list.append(file) list.append(self.get_staging_folder(binaryName) + "/" + self.folder_lib + "/" + moduleName + self.suffix_lib_dynamic) list.append(self.get_build_folder(moduleName) + "/" + moduleName + self.suffix_dependence) - list.append(self.get_build_folder(binaryName) + "/" + self.folder_lib + "/" + moduleName + self.suffix_cmdLine) + list.append(self.get_build_folder(binaryName) + "/" + self.folder_lib + "/" + moduleName + self.suffix_lib_dynamic + self.suffix_cmdLine) elif (type=="lib-static"): list.append(file) list.append(self.get_build_folder(moduleName) + "/" + moduleName + self.suffix_lib_static) list.append(self.get_build_folder(moduleName) + "/" + moduleName + self.suffix_dependence) - list.append(self.get_build_folder(moduleName) + "/" + moduleName + self.suffix_cmdLine) + list.append(self.get_build_folder(moduleName) + "/" + moduleName + self.suffix_lib_static + self.suffix_cmdLine) + elif (type=="jar"): + list.append(file) + list.append(self.get_build_folder(moduleName) + "/" + moduleName + ".jar") + list.append(self.get_build_folder(moduleName) + "/" + moduleName + ".jar" + self.suffix_dependence) + list.append(self.get_build_folder(moduleName) + "/" + moduleName + ".jar" + self.suffix_cmdLine) elif (type=="image"): list.append(self.get_build_folder(binaryName) + "/data/" + file + self.suffix_cmdLine) else: diff --git a/lutin/tools.py b/lutin/tools.py index 15bb228..133b896 100644 --- a/lutin/tools.py +++ b/lutin/tools.py @@ -144,3 +144,15 @@ def copy_anything_target(target, src, dst): newDst += "/" debug.verbose("Might copy : '" + root+"/"+cycleFile + "' ==> '" + newDst+cycleFile + "'" ) target.add_file_staging(root+"/"+cycleFile, newDst+cycleFile) + + +def filter_extention(list_files, extentions): + out = [] + for ext in extentions: + for file in list_files: + if file[-len(ext):] == ext: + out.append(file) + return out + + + diff --git a/lutin/z_builder/lutinBuilder_c.py b/lutin/z_builder/lutinBuilder_c.py index 1b43c99..5412b6e 100644 --- a/lutin/z_builder/lutinBuilder_c.py +++ b/lutin/z_builder/lutinBuilder_c.py @@ -41,7 +41,10 @@ def get_output_type(): ## @brief Commands for running gcc to compile a C file in object file. ## def compile(file, binary, target, depancy, flags, path, name, basic_folder): - file_src, file_dst, file_depend, file_cmd = target.file_generate_object(binary, name, basic_folder,file) + file_src = target.get_full_name_source(basic_folder, file) + file_cmd = target.get_full_name_cmd(name, basic_folder, file) + file_dst = target.get_full_name_destination(name, basic_folder, file, get_output_type()) + file_depend = target.get_full_dependency(name, basic_folder, file) # create the command line befor requesting start: cmd = [ @@ -50,16 +53,13 @@ def compile(file, binary, target, depancy, flags, path, name, basic_folder): target.arch, target.sysroot, target.global_include_cc] + for view in ["export", "local"]: + try: + cmd.append(tools.add_prefix("-I", path[view]["c"])) + except: + pass try: - cmd.append(tools.add_prefix("-I", path["export"])) - except: - pass - try: - cmd.append(tools.add_prefix("-I", path["local"])) - except: - pass - try: - cmd.append(tools.add_prefix("-I", depancy.path)) + cmd.append(tools.add_prefix("-I", depancy.path["c"])) except: pass try: @@ -74,14 +74,11 @@ def compile(file, binary, target, depancy, flags, path, name, basic_folder): cmd.append(depancy.flags["c"]) except: pass - try: - cmd.append(flags["local"]["c"]) - except: - pass - try: - cmd.append(flags["export"]["c"]) - except: - pass + for view in ["local", "export"]: + try: + cmd.append(flags[view]["c"]) + except: + pass cmd.append("-c") cmd.append("-MMD") cmd.append("-MP") diff --git a/lutin/z_builder/lutinBuilder_cpp.py b/lutin/z_builder/lutinBuilder_cpp.py index aedf41c..4239e06 100644 --- a/lutin/z_builder/lutinBuilder_cpp.py +++ b/lutin/z_builder/lutinBuilder_cpp.py @@ -40,7 +40,10 @@ def get_output_type(): ## @brief Commands for running gcc to compile a C++ file in object file. ## def compile(file, binary, target, depancy, flags, path, name, basic_folder): - file_src, file_dst, file_depend, file_cmd = target.file_generate_object(binary, name, basic_folder, file) + file_src = target.get_full_name_source(basic_folder, file) + file_cmd = target.get_full_name_cmd(name, basic_folder, file) + file_dst = target.get_full_name_destination(name, basic_folder, file, get_output_type()) + file_depend = target.get_full_dependency(name, basic_folder, file) # create the command line befor requesting start: cmd = [ @@ -50,18 +53,17 @@ def compile(file, binary, target, depancy, flags, path, name, basic_folder): target.sysroot, target.global_include_cc ] - try: - cmd.append(tools.add_prefix("-I",path["export"])) - except: - pass - try: - cmd.append(tools.add_prefix("-I",path["local"])) - except: - pass - try: - cmd.append(tools.add_prefix("-I",depancy.path)) - except: - pass + for view in ["export", "local"]: + for type in ["c", "c++"]: + try: + cmd.append(tools.add_prefix("-I",path[view][type])) + except: + pass + for type in ["c", "c++"]: + try: + cmd.append(tools.add_prefix("-I",depancy.path[type])) + except: + pass try: cmd.append(get_version_compilation_flags(flags, depancy.flags)) except: @@ -74,30 +76,17 @@ def compile(file, binary, target, depancy, flags, path, name, basic_folder): 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 + for type in ["c", "c++"]: + try: + cmd.append(depancy.flags[type]) + except: + pass + for view in ["local", "export"]: + for type in ["c", "c++"]: + try: + cmd.append(flags[view][type]) + except: + pass cmd.append(["-c", "-MMD", "-MP"]) cmd.append(file_src) # Create cmd line diff --git a/lutin/z_builder/lutinBuilder_jar.py b/lutin/z_builder/lutinBuilder_jar.py new file mode 100644 index 0000000..93665fd --- /dev/null +++ b/lutin/z_builder/lutinBuilder_jar.py @@ -0,0 +1,67 @@ +## +## Dynamic library builder +## +from lutin import multiprocess +from lutin import tools +from lutin import debug +from lutin import depend +from lutin import env +import os + +## +## Initialize the builder, if needed ... to get dependency between builder (for example) +## +def init(): + pass + +## +## Get the current builder type. +## Return the type of builder +## +def get_type(): + return "linker" + +## +## @brief Get builder input file type +## @return List of extention supported +## +def get_input_type(): + return ["class"] + +## +## @brief Get builder output file type +## @return List of extention supported +## +def get_output_type(): + return ["jar"] + +## +## @brief Commands for running gcc to link a shared library. +## +def link(file, binary, target, depancy, name, basic_folder): + file_src, file_dst, file_depend, file_cmd = target.generate_file(binary, name, basic_folder, file, "jar") + #create command Line + cmd = [ + target.jar, + "cf", file_dst + ] + try: + cmd.append(file_src) + except: + pass + cmdLine=tools.list_to_str(cmd) + """ + # check the dependency for this file : + if depend.need_re_package(file_dst, file_src, True, file_cmd, cmdLine) == False: + return tmpList[1] + """ + tools.create_directory_of_file(file_dst) + debug.print_element("jar", name, "==>", file_dst) + multiprocess.run_command(cmdLine) + # write cmd line only after to prevent errors ... + multiprocess.store_command(cmdLine, file_cmd) + #debug.print_element("SharedLib", self.name, "==>", tmpList[1]) + return file_dst + + + diff --git a/lutin/z_builder/lutinBuilder_java.py b/lutin/z_builder/lutinBuilder_java.py index aa6c513..d7d8e36 100644 --- a/lutin/z_builder/lutinBuilder_java.py +++ b/lutin/z_builder/lutinBuilder_java.py @@ -31,4 +31,53 @@ def get_input_type(): ## @return List of extention supported ## def get_output_type(): - return ["class"] \ No newline at end of file + return ["class"] + +## +## @brief Commands for running gcc to compile a C++ file in object file. +## +def compile(file, binary, target, depancy, flags, path, name, basic_folder): + file_src = target.get_full_name_source(basic_folder, file) + file_cmd = target.get_full_name_cmd(name, basic_folder, file) + file_dst = target.get_full_name_destination(name, basic_folder, file, get_output_type(), remove_suffix=True) + file_depend = target.get_full_dependency(name, basic_folder, file) + + + # create the command line befor requesting start: + cmd = [ + target.java, + "-d", target.get_build_folder(name) + ] + # add source dependency: + list_sources_path = [] + for view in ["export", "local"]: + try: + list = path[view]["java"] + for elem in list: + list_sources_path.append(elem) + except: + pass + if len(list_sources_path) > 0: + cmd.append("-sourcepath") + out = "" + for elem in list_sources_path: + if len(out) > 0: + out += ":" + out += elem + cmd.append(out) + + # dependency : + "-classpath " + self.folder_sdk + "/platforms/android-" + str(self.boardId) + "/android.jar" \ + cmd.append("-classpath " + target.folder_sdk + "/platforms/android-" + str(target.boardId) + "/android.jar") + cmd.append(file_src) + # Create cmd line + cmdLine=tools.list_to_str(cmd) + + # check the dependency for this file : + if depend.need_re_build(file_dst, file_src, file_depend, file_cmd, cmdLine) == False: + return file_dst + tools.create_directory_of_file(file_dst) + comment = ["java", name, "<==", file] + #process element + multiprocess.run_in_pool(cmdLine, comment, file_cmd) + return file_dst + diff --git a/lutin/z_builder/lutinBuilder_libraryDynamic.py b/lutin/z_builder/lutinBuilder_libraryDynamic.py index 4ab3a6d..b7cb74d 100644 --- a/lutin/z_builder/lutinBuilder_libraryDynamic.py +++ b/lutin/z_builder/lutinBuilder_libraryDynamic.py @@ -26,7 +26,7 @@ def get_type(): ## @return List of extention supported ## def get_input_type(): - return ["o"] + return ["o", "a"] ## ## @brief Get builder output file type @@ -59,7 +59,8 @@ def link(file, binary, target, depancy, name, basic_folder): except: pass try: - cmd.append(depancy.src) + # keep only compilated files ... + cmd.append(tools.filter_extention(depancy.src, get_input_type())) except: pass try: diff --git a/lutin/z_builder/lutinBuilder_libraryStatic.py b/lutin/z_builder/lutinBuilder_libraryStatic.py index 3aa9d42..3149b74 100644 --- a/lutin/z_builder/lutinBuilder_libraryStatic.py +++ b/lutin/z_builder/lutinBuilder_libraryStatic.py @@ -26,7 +26,7 @@ def get_type(): ## @return List of extention supported ## def get_input_type(): - return ["o"] + return ["o", "a"] ## ## @brief Get builder output file type diff --git a/lutin/z_builder/lutinBuilder_m.py b/lutin/z_builder/lutinBuilder_m.py index 181a41c..02946f1 100644 --- a/lutin/z_builder/lutinBuilder_m.py +++ b/lutin/z_builder/lutinBuilder_m.py @@ -42,7 +42,10 @@ def get_output_type(): ## @brief Commands for running gcc to compile a m file in object file. ## def compile(file, binary, target, depancy, flags, path, name, basic_folder): - file_src, file_dst, file_depend, file_cmd = target.file_generate_object(binary, name, basic_folder, file) + file_src = target.get_full_name_source(basic_folder, file) + file_cmd = target.get_full_name_cmd(name, basic_folder, file) + file_dst = target.get_full_name_destination(name, basic_folder, file, get_output_type()) + file_depend = target.get_full_dependency(name, basic_folder, file) # create the command line befor requesting start: cmd = [ target.cc, @@ -50,18 +53,17 @@ def compile(file, binary, target, depancy, flags, path, name, basic_folder): target.arch, target.sysroot, target.global_include_cc] - try: - cmd.append(tools.add_prefix("-I",path["export"])) - except: - pass - try: - cmd.append(tools.add_prefix("-I",path["local"])) - except: - pass - try: - cmd.append(tools.add_prefix("-I",depancy.path)) - except: - pass + for view in ["export", "local"]: + for type in ["c", "m"]: + try: + cmd.append(tools.add_prefix("-I",path[view][type])) + except: + pass + for type in ["c", "m"]: + try: + cmd.append(tools.add_prefix("-I",depancy.path[type])) + except: + pass try: cmd.append(local_ref_on_builder_c.get_version_compilation_flags(flags, depancy.flags)) except: @@ -74,30 +76,17 @@ def compile(file, binary, target, depancy, flags, path, name, basic_folder): 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 + for type in ["c", "m"]: + try: + cmd.append(depancy.flags[type]) + except: + pass + for view in ["local", "export"]: + for type in ["c", "m"]: + try: + cmd.append(flags[view][type]) + except: + pass cmd.append("-c -MMD -MP") cmd.append("-x objective-c") cmd.append(file_src) diff --git a/lutin/z_builder/lutinBuilder_mm.py b/lutin/z_builder/lutinBuilder_mm.py index 625bd20..e23ba1e 100644 --- a/lutin/z_builder/lutinBuilder_mm.py +++ b/lutin/z_builder/lutinBuilder_mm.py @@ -42,7 +42,10 @@ def get_output_type(): ## @brief Commands for running gcc to compile a m++ file in object file. ## def compile(file, binary, target, depancy, flags, path, name, basic_folder): - file_src, file_dst, file_depend, file_cmd = target.file_generate_object(binary, name, basic_folder, file) + file_src = target.get_full_name_source(basic_folder, file) + file_cmd = target.get_full_name_cmd(name, basic_folder, file) + file_dst = target.get_full_name_destination(name, basic_folder, file, get_output_type()) + file_depend = target.get_full_dependency(name, basic_folder, file) # create the command line befor requesting start: cmd = [ target.xx, @@ -50,18 +53,17 @@ def compile(file, binary, target, depancy, flags, path, name, basic_folder): target.arch, target.sysroot, target.global_include_cc] - try: - cmd.append(tools.add_prefix("-I",path["export"])) - except: - pass - try: - cmd.append(tools.add_prefix("-I",path["local"])) - except: - pass - try: - cmd.append(tools.add_prefix("-I",depancy.path)) - except: - pass + for view in ["export", "local"]: + for type in ["c", "c++", "m", "mm"]: + try: + cmd.append(tools.add_prefix("-I",path[view][type])) + except: + pass + for type in ["c", "c++", "m", "mm"]: + try: + cmd.append(tools.add_prefix("-I",depancy.path[type])) + except: + pass try: cmd.append(local_ref_on_builder_cpp.get_version_compilation_flags(flags, depancy.flags)) except: @@ -74,42 +76,17 @@ def compile(file, binary, target, depancy, flags, path, name, basic_folder): 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 + for type in ["c", "c++", "m", "mm"]: + try: + cmd.append(depancy.flags[type]) + except: + pass + for view in ["export", "local"]: + for type in ["c", "c++", "m", "mm"]: + try: + cmd.append(flags[view][type]) + except: + pass cmd.append("-c -MMD -MP") cmd.append("-x objective-c++") cmd.append(file_src)