diff --git a/builder/lutinBuilder_binary.py b/builder/lutinBuilder_binary.py index dd5fbf1..070ae96 100644 --- a/builder/lutinBuilder_binary.py +++ b/builder/lutinBuilder_binary.py @@ -1,6 +1,12 @@ ## ## Executable/binary builder ## +import lutinMultiprocess +import lutinTools +import lutinDebug as debug +import lutinDepend as dependency +import lutinEnv +import os ## ## Initialize the builder, if needed ... to get dependency between builder (for example) @@ -12,7 +18,7 @@ def init(): ## Get the current builder type. ## Return the type of builder ## -def getType(): +def get_type(): return "linker" @@ -20,49 +26,76 @@ def getType(): ## @brief Get builder input file type ## @return List of extention supported ## -def getInputType(): +def get_input_type(): return ["o"] ## ## @brief Get builder output file type ## @return List of extention supported ## -def getOutputType(): - return ["", "exe"] +def get_output_type(): + return ["", "exe", "bin"] ## ## @brief Commands for running gcc to link an executable. ## -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") - #create comdLine : - cmdLine=lutinTools.list_to_str([ - target.xx, - target.arch, - target.sysroot, - target.global_sysroot, - "-o", file_dst, - file_src, - depancy.src, - self.flags_ld, - depancy.flags_ld, - target.global_flags_ld]) +def link(file, binary, target, depancy, name, basic_folder): + file_src, file_dst, file_depend, file_cmd = target.generate_file(binary, name, basic_folder, file, "bin") + #create comdLine : + cmd = [ + target.xx + ] + try: + cmd.append(target.arch) + except: + pass + try: + cmd.append(target.sysroot) + except: + pass + try: + cmd.append(target.global_sysroot) + except: + pass + try: + cmd.append(["-o", file_dst]) + except: + pass + try: + cmd.append(file_src) + except: + pass + try: + cmd.append(depancy.src) + except: + pass + try: + cmd.append(flags["local"]["link"]) + except: + pass + try: + cmd.append(depancy.flags["link"]) + except: + pass + try: + cmd.append(target.global_flags_ld) + except: + pass + cmdLine=lutinTools.list_to_str(cmd) # check the dependency for this file : if dependency.need_re_package(file_dst, file_src, True, file_cmd, cmdLine) == False \ and dependency.need_re_package(file_dst, depancy.src, False, file_cmd, cmdLine) == False: return file_dst lutinTools.create_directory_of_file(file_dst) - debug.print_element("Executable", libName, "==>", file_dst) + debug.print_element("Executable", name, "==>", file_dst) lutinMultiprocess.run_command(cmdLine) if target.config["mode"] == "release"\ or lutinEnv.get_force_strip_mode() == True: # get the file size of the non strip file originSize = lutinTools.file_size(file_dst); - debug.print_element("Executable(strip)", libName, "", "") + debug.print_element("Executable(strip)", name, "", "") cmdLineStrip=lutinTools.list_to_str([ target.strip, file_dst]) diff --git a/builder/lutinBuilder_c.py b/builder/lutinBuilder_c.py index 9e231d8..a37183e 100644 --- a/builder/lutinBuilder_c.py +++ b/builder/lutinBuilder_c.py @@ -3,6 +3,7 @@ ## import lutinMultiprocess import lutinTools +import lutinDebug as debug import lutinDepend as dependency # C version: @@ -19,21 +20,21 @@ def init(): ## Get the current builder type. ## Return the type of builder ## -def getType(): +def get_type(): return "compiler" ## ## @brief Get builder input file type ## @return List of extention supported ## -def getInputType(): +def get_input_type(): return ["c", "C"] ## ## @brief Get builder output file type ## @return List of extention supported ## -def getOutputType(): +def get_output_type(): return ["o"] ## diff --git a/builder/lutinBuilder_cpp.py b/builder/lutinBuilder_cpp.py index da047e1..2d7cbbb 100644 --- a/builder/lutinBuilder_cpp.py +++ b/builder/lutinBuilder_cpp.py @@ -3,6 +3,7 @@ ## import lutinMultiprocess import lutinTools +import lutinDebug as debug import lutinDepend as dependency # C++ default version: default_version = 1999 @@ -18,21 +19,21 @@ def init(): ## Get the current builder type. ## Return the type of builder ## -def getType(): +def get_type(): return "compiler" ## ## @brief Get builder input file type ## @return List of extention supported ## -def getInputType(): +def get_input_type(): return ["cpp", "CPP", "cxx", "CXX", "xx", "XX", "CC", "cc"] ## ## @brief Get builder output file type ## @return List of extention supported ## -def getOutputType(): +def get_output_type(): return ["o"] ## diff --git a/builder/lutinBuilder_java.py b/builder/lutinBuilder_java.py index 4e36c22..f0ca142 100644 --- a/builder/lutinBuilder_java.py +++ b/builder/lutinBuilder_java.py @@ -3,6 +3,7 @@ ## import lutinMultiprocess import lutinTools +import lutinDebug as debug import lutinDepend as dependency ## @@ -15,19 +16,19 @@ def init(): ## Get the current builder type. ## Return the type of builder ## -def getType(): +def get_type(): return "compiler" ## ## @brief Get builder input file type ## @return List of extention supported ## -def getInputType(): +def get_input_type(): return ["java"] ## ## @brief Get builder output file type ## @return List of extention supported ## -def getOutputType(): +def get_output_type(): return ["class"] \ No newline at end of file diff --git a/builder/lutinBuilder_libraryDynamic.py b/builder/lutinBuilder_libraryDynamic.py index bc79c8b..a9e9d91 100644 --- a/builder/lutinBuilder_libraryDynamic.py +++ b/builder/lutinBuilder_libraryDynamic.py @@ -3,7 +3,9 @@ ## import lutinMultiprocess import lutinTools +import lutinDebug as debug import lutinDepend as dependency +import os ## ## Initialize the builder, if needed ... to get dependency between builder (for example) @@ -15,56 +17,76 @@ def init(): ## Get the current builder type. ## Return the type of builder ## -def getType(): +def get_type(): return "linker" ## ## @brief Get builder input file type ## @return List of extention supported ## -def getInputType(): +def get_input_type(): return ["o"] ## ## @brief Get builder output file type ## @return List of extention supported ## -def getOutputType(): +def get_output_type(): return ["so", "dynlib", "dll"] ## ## @brief Commands for running gcc to link a shared library. ## -def link(file, binary, target, depancy, libName=""): - if libName=="": - libName = self.name - file_src, file_dst, file_depend, file_cmd = target.generate_file(binary, libName,self.originFolder,file,"lib-shared") +def link(file, binary, target, depancy, name, basic_folder): + file_src, file_dst, file_depend, file_cmd = target.generate_file(binary, name, basic_folder, file, "lib-shared") #create command Line - cmdLine=lutinTools.list_to_str([ + cmd = [ target.xx, - "-o", file_dst, - target.global_sysroot, - target.arch, - "-shared", - file_src, - depancy.src, - self.flags_ld, - depancy.flags_ld, - target.global_flags_ld]) - + "-o", file_dst + ] + try: + cmd.append(target.global_sysroot) + except: + pass + try: + cmd.append(target.arch) + except: + pass + cmd.append("-shared") + try: + cmd.append(file_src) + except: + pass + try: + cmd.append(depancy.src) + except: + pass + try: + cmd.append(flags["local"]["link"]) + except: + pass + try: + cmd.append(depancy.flags["link"]) + except: + pass + try: + cmd.append(target.global_flags_ld) + except: + pass + cmdLine=lutinTools.list_to_str(cmd) # check the dependency for this file : if dependency.need_re_package(file_dst, file_src, True, file_cmd, cmdLine) == False \ and dependency.need_re_package(file_dst, depancy.src, False, file_cmd, cmdLine) == False: return tmpList[1] lutinTools.create_directory_of_file(file_dst) - debug.print_element("SharedLib", libName, "==>", file_dst) + debug.print_element("SharedLib", name, "==>", file_dst) lutinMultiprocess.run_command(cmdLine) # strip the output file: if target.config["mode"] == "release" \ or lutinEnv.get_force_strip_mode() == True: # get the file size of the non strip file originSize = lutinTools.file_size(file_dst); - debug.print_element("SharedLib(strip)", libName, "", "") + debug.print_element("SharedLib(strip)", name, "", "") cmdLineStrip=lutinTools.list_to_str([ target.strip, file_dst]) diff --git a/builder/lutinBuilder_libraryStatic.py b/builder/lutinBuilder_libraryStatic.py index 38f3015..0717a6a 100644 --- a/builder/lutinBuilder_libraryStatic.py +++ b/builder/lutinBuilder_libraryStatic.py @@ -3,7 +3,9 @@ ## import lutinMultiprocess import lutinTools +import lutinDebug as debug import lutinDepend as dependency +import os ## ## Initialize the builder, if needed ... to get dependency between builder (for example) @@ -15,45 +17,55 @@ def init(): ## Get the current builder type. ## Return the type of builder ## -def getType(): +def get_type(): return "linker" ## ## @brief Get builder input file type ## @return List of extention supported ## -def getInputType(): +def get_input_type(): return ["o"] ## ## @brief Get builder output file type ## @return List of extention supported ## -def getOutputType(): +def get_output_type(): return ["a"] ## ## @brief Commands for running ar. ## -def link(file, binary, target, depancy, libName=""): - if libName == "": - libName = self.name - file_src, file_dst, file_depend, file_cmd = target.generate_file(binary, libName,self.originFolder,file,"lib-static") +def link(file, binary, target, depancy, name, basic_folder): + file_src, file_dst, file_depend, file_cmd = target.generate_file(binary, name, basic_folder, file, "lib-static") #$(Q)$(TARGET_AR) $(TARGET_GLOBAL_ARFLAGS) $(PRIVATE_ARFLAGS) $@ $(PRIVATE_ALL_OBJECTS) - cmdLine=lutinTools.list_to_str([ - target.ar, - target.global_flags_ar, - self.flags_ar, - file_dst, - file_src])#, - #depancy.src]) - + cmd = [ + target.ar + ] + try: + cmd.append(target.global_flags_ar) + except: + pass + try: + cmd.append(flags["local"]["link"]) + except: + pass + try: + cmd.append(file_dst) + except: + pass + try: + cmd.append(file_src) + except: + pass + cmdLine=lutinTools.list_to_str(cmd) # check the dependency for this file : if dependency.need_re_package(file_dst, file_src, True, file_cmd, cmdLine) == False \ and dependency.need_re_package(file_dst, depancy.src, False, file_cmd, cmdLine) == False: return file_dst lutinTools.create_directory_of_file(file_dst) - debug.print_element("StaticLib", libName, "==>", file_dst) + debug.print_element("StaticLib", name, "==>", file_dst) # explicitly remove the destination to prevent error ... if os.path.exists(file_dst) and os.path.isfile(file_dst): os.remove(file_dst) diff --git a/builder/lutinBuilder_m.py b/builder/lutinBuilder_m.py index 017ade0..738ae1e 100644 --- a/builder/lutinBuilder_m.py +++ b/builder/lutinBuilder_m.py @@ -15,27 +15,27 @@ local_ref_on_builder_c = None def init(): global local_ref_on_builder_c debug.debug("m builder get dependency on the C builder") - local_ref_on_builder_c = lutinBuilder.getBuilder("c") + local_ref_on_builder_c = lutinBuilder.get_builder("c") ## ## Get the current builder type. ## Return the type of builder ## -def getType(): +def get_type(): return "compiler" ## ## @brief Get builder input file type ## @return List of extention supported ## -def getInputType(): +def get_input_type(): return ["m", "M"] ## ## @brief Get builder output file type ## @return List of extention supported ## -def getOutputType(): +def get_output_type(): return ["o"] ## diff --git a/builder/lutinBuilder_mm.py b/builder/lutinBuilder_mm.py index 1d0a5b1..185ec3b 100644 --- a/builder/lutinBuilder_mm.py +++ b/builder/lutinBuilder_mm.py @@ -15,27 +15,27 @@ local_ref_on_builder_cpp = None def init(): global local_ref_on_builder_cpp debug.debug("mm builder get dependency on the CPP builder") - local_ref_on_builder_cpp = lutinBuilder.getBuilder("cpp") + local_ref_on_builder_cpp = lutinBuilder.get_builder("cpp") ## ## Get the current builder type. ## Return the type of builder ## -def getType(): +def get_type(): return "compiler" ## ## @brief Get builder input file type ## @return List of extention supported ## -def getInputType(): +def get_input_type(): return ["mm", "MM"] ## ## @brief Get builder output file type ## @return List of extention supported ## -def getOutputType(): +def get_output_type(): return ["o"] ## diff --git a/builder/lutinBuilder_s.py b/builder/lutinBuilder_s.py index 86ad493..61cd345 100644 --- a/builder/lutinBuilder_s.py +++ b/builder/lutinBuilder_s.py @@ -15,19 +15,19 @@ def init(): ## Get the current builder type. ## Return the type of builder ## -def getType(): +def get_type(): return "compiler" ## ## @brief Get builder input file type ## @return List of extention supported ## -def getInputType(): +def get_input_type(): return ["s", "S"] ## ## @brief Get builder output file type ## @return List of extention supported ## -def getOutputType(): +def get_output_type(): return ["o"] diff --git a/lutinBuilder.py b/lutinBuilder.py index b9f5ab2..99f51d2 100644 --- a/lutinBuilder.py +++ b/lutinBuilder.py @@ -47,7 +47,7 @@ def import_path(path): builder_list.append({"name":builder_name, "element":the_builder }) - debug.debug('BUILDER: type=' + the_builder.getType() + " in=" + str(the_builder.getInputType()) + " out=" + str(the_builder.getOutputType())) + debug.debug('BUILDER: type=' + the_builder.get_type() + " in=" + str(the_builder.get_input_type()) + " out=" + str(the_builder.get_output_type())) # we must have call all import before ... def init(): @@ -57,13 +57,23 @@ def init(): if element["element"] != None: element["element"].init() -def getBuilder(input_type): +def get_builder(input_type): global builder_list for element in builder_list: if element["element"] != None: - if input_type in element["element"].getInputType(): + if input_type in element["element"].get_input_type(): return element["element"] # we can not find the builder ... debug.error("Can not find builder for type : '" + str(input_type) + "'") - return None + raise ValueError('type error :' + str(input_type)) + +def get_builder_with_output(input_type): + global builder_list + for element in builder_list: + if element["element"] != None: + if input_type in element["element"].get_output_type(): + return element["element"] + # we can not find the builder ... + debug.error("Can not find builder for type : '" + str(input_type) + "'") + raise ValueError('type error :' + str(input_type)) \ No newline at end of file diff --git a/lutinHeritage.py b/lutinHeritage.py index fbbbfa2..aeac200 100644 --- a/lutinHeritage.py +++ b/lutinHeritage.py @@ -43,7 +43,7 @@ class HeritageList: if element.name == heritage.name: return self.listHeritage.append(heritage) - self.regenerateTree() + self.regenerate_tree() def add_heritage_list(self, heritage_list): if type(heritage_list) == type(None): @@ -55,9 +55,9 @@ class HeritageList: find = True if find == False: self.listHeritage.append(herit) - self.regenerateTree() + self.regenerate_tree() - def regenerateTree(self): + def regenerate_tree(self): self.flags={} # sources list: self.src=[] @@ -91,22 +91,28 @@ class HeritageList: for element in self.listHeritage: debug.verbose(" " + element.name + " " + str(element.depends)) for element in reversed(self.listHeritage): - debug.debug("elem : " + str(element.flags)) for flags in element.flags: + if flags in ["c-version", "c++-version"]: + continue value = element.flags[flags] - debug.debug(" elem : " + str(flags)) if flags not in self.flags: self.flags[flags] = value else: append_to_list(self.flags[flags], value) append_to_list(self.path, element.path) append_to_list(self.src, element.src) - """ - if 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 - """ + if "c-version" in element.flags: + ver = element.flags["c-version"] + if "c-version" in self.flags: + if self.flags["c-version"] > ver: + ver = self.flags["c-version"] + self.flags["c-version"] = ver + if "c++-version" in element.flags: + ver = element.flags["c++-version"] + if "c++-version" in self.flags: + if self.flags["c++-version"] > ver: + ver = self.flags["c++-version"] + self.flags["c++-version"] = ver class heritage: @@ -126,13 +132,9 @@ class heritage: # all the parameter that the upper classe need when build self.name = module.name self.depends = copy.deepcopy(module.depends) + # keep reference because the flags can change in time self.flags = module.flags["export"] self.path = module.path["export"] - if "c++-version" in self.flags: - self.flags["c++-version"] = self.flags["c++-version"]["api-version"] - if "c-version" in self.flags: - self.flags["c-version"] = self.flags["c-version"]["api-version"] - def add_depends(self, depend): self.depends.append(depend) @@ -160,11 +162,17 @@ class heritage: append_to_list(self.flags[flags], value) self.add_import_path(other.path) self.add_sources(other.src) - """ - if 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 - """ + if "c-version" in module.flags["export"]: + ver = module.flags["export"]["c-version"] + if "c-version" in self.flags: + if self.flags["c-version"] > ver: + ver = self.flags["c-version"] + self.flags["c-version"] = ver + if "c++-version" in module.flags["export"]: + ver = module.flags["export"]["c++-version"] + if "c++-version" in self.flags: + if self.flags["c++-version"] > ver: + ver = self.flags["c++-version"] + self.flags["c++-version"] = ver diff --git a/lutinModule.py b/lutinModule.py index e0d2ece..ed82a01 100644 --- a/lutinModule.py +++ b/lutinModule.py @@ -35,8 +35,8 @@ class Module: def __init__(self, file, moduleName, moduleType): ## Remove all variable to prevent error of multiple deffinition of the module ... debug.verbose("Create a new module : '" + moduleName + "' TYPE=" + moduleType) - self.originFile='' - self.originFolder='' + self.origin_file='' + self.origin_folder='' # type of the module: self.type='LIBRARY' # Name of the module @@ -88,30 +88,30 @@ class Module: debug.error('for module "%s"' %moduleName) debug.error(' ==> error : "%s" ' %moduleType) raise 'Input value error' - self.originFile = file; - self.originFolder = lutinTools.get_current_path(self.originFile) - self.localHeritage = heritage.heritage(self) + self.origin_file = file; + self.origin_folder = lutinTools.get_current_path(self.origin_file) + self.local_heritage = heritage.heritage(self) - self.packageProp = { "COMPAGNY_TYPE" : set(""), - "COMPAGNY_NAME" : set(""), - "COMPAGNY_NAME2" : set(""), - "MAINTAINER" : set([]), - #"ICON" : set(""), - "SECTION" : set([]), - "PRIORITY" : set(""), - "DESCRIPTION" : set(""), - "VERSION" : set("0.0.0"), - "VERSION_CODE" : "", - "NAME" : set("no-name"), # name of the application - "ANDROID_MANIFEST" : "", # By default generate the manifest - "ANDROID_JAVA_FILES" : ["DEFAULT"], # when user want to create his own services and activities - "ANDROID_RESOURCES" : [], - "ANDROID_APPL_TYPE" : "APPL", # the other mode is "WALLPAPER" ... and later "WIDGET" - "ANDROID_WALLPAPER_PROPERTIES" : [], # To create properties of the wallpaper (no use of EWOL display) - "RIGHT" : [], - "ADMOD_POSITION" : "top" - } - self.subHeritageList = None + self.package_prop = { "COMPAGNY_TYPE" : set(""), + "COMPAGNY_NAME" : set(""), + "COMPAGNY_NAME2" : set(""), + "MAINTAINER" : set([]), + #"ICON" : set(""), + "SECTION" : set([]), + "PRIORITY" : set(""), + "DESCRIPTION" : set(""), + "VERSION" : set("0.0.0"), + "VERSION_CODE" : "", + "NAME" : set("no-name"), # name of the application + "ANDROID_MANIFEST" : "", # By default generate the manifest + "ANDROID_JAVA_FILES" : ["DEFAULT"], # when user want to create his own services and activities + "ANDROID_RESOURCES" : [], + "ANDROID_APPL_TYPE" : "APPL", # the other mode is "WALLPAPER" ... and later "WIDGET" + "ANDROID_WALLPAPER_PROPERTIES" : [], # To create properties of the wallpaper (no use of EWOL display) + "RIGHT" : [], + "ADMOD_POSITION" : "top" + } + self.sub_heritage_list = None ## ## @brief add Some copilation flags for this module (and only this one) @@ -143,7 +143,7 @@ class Module: ## ## @brief Commands for copying files ## - def image_to_staging(self, binaryName, target): + def image_to_staging(self, binary_name, target): for source, destination, sizeX, sizeY in self.imageToCopy: extension = source[source.rfind('.'):] if extension != ".png" \ @@ -151,14 +151,14 @@ class Module: and sizeX > 0: debug.error("Can not manage image other than .png and jpg to resize : " + source); displaySource = source - source = self.originFolder + "/" + source + source = self.origin_folder + "/" + source if destination == "": destination = source[source.rfind('/')+1:] debug.verbose("Regenerate Destination : '" + destination + "'") - file_cmd = target.generate_file(binaryName, self.name, self.originFolder, destination, "image")[0] + file_cmd = target.generate_file(binary_name, self.name, self.origin_folder, destination, "image")[0] if sizeX > 0: debug.verbose("Image file : " + displaySource + " ==> " + destination + " resize=(" + str(sizeX) + "," + str(sizeY) + ")") - fileName, fileExtension = os.path.splitext(self.originFolder+"/" + source) + fileName, fileExtension = os.path.splitext(self.origin_folder+"/" + source) target.add_image_staging(source, destination, sizeX, sizeY, file_cmd) else: debug.verbose("Might copy file : " + displaySource + " ==> " + destination) @@ -167,14 +167,14 @@ class Module: ## ## @brief Commands for copying files ## - def files_to_staging(self, binaryName, target): + def files_to_staging(self, binary_name, target): for source, destination in self.files: displaySource = source - source = self.originFolder + "/" + source + source = self.origin_folder + "/" + source if destination == "": destination = source[source.rfind('/')+1:] debug.verbose("Regenerate Destination : '" + destination + "'") - file_cmd = target.generate_file(binaryName, self.name, self.originFolder, destination, "image")[0] + file_cmd = target.generate_file(binary_name, self.name, self.origin_folder, destination, "image")[0] # TODO : when destination is missing ... debug.verbose("Might copy file : " + displaySource + " ==> " + destination) target.add_file_staging(source, destination, file_cmd) @@ -182,38 +182,38 @@ class Module: ## ## @brief Commands for copying files ## - def folders_to_staging(self, binaryName, target): + def folders_to_staging(self, binary_name, target): for source, destination in self.folders: debug.debug("Might copy folder : " + source + "==>" + destination) - lutinTools.copy_anything_target(target, self.originFolder + "/" + source, destination) + lutinTools.copy_anything_target(target, self.origin_folder + "/" + source, destination) # call here to build the module - def build(self, target, packageName): + def build(self, target, package_name): # ckeck if not previously build if target.is_module_build(self.name)==True: - if self.subHeritageList == None: - self.localHeritage = heritage.heritage(self) - return self.subHeritageList - # create the packege heritage - self.localHeritage = heritage.heritage(self) + if self.sub_heritage_list == None: + self.local_heritage = heritage.heritage(self) + return self.sub_heritage_list + # create the package heritage + self.local_heritage = heritage.heritage(self) - if packageName==None \ + if package_name==None \ and ( self.type=="BINARY" \ or self.type=="PACKAGE" ) : # this is the endpoint binary ... - packageName = self.name + package_name = self.name else : # TODO : Set it better ... None # build dependency before - listSubFileNeededTobuild = [] - self.subHeritageList = heritage.HeritageList() + list_sub_file_needed_to_build = [] + self.sub_heritage_list = heritage.HeritageList() # optionnal dependency : for dep, option, export in self.depends_optionnal: - inheritList, isBuilt = target.build_optionnal(dep, packageName) + inherit_list, isBuilt = target.build_optionnal(dep, package_name) if isBuilt == True: - self.localHeritage.add_depends(dep); + self.local_heritage.add_depends(dep); # TODO : Add optionnal Flags ... # ==> do it really better ... if export == False: @@ -221,29 +221,29 @@ class Module: else: self.add_export_flag_CC("-D"+option); # add at the heritage list : - self.subHeritageList.add_heritage_list(inheritList) + self.sub_heritage_list.add_heritage_list(inherit_list) for dep in self.depends: - inheritList = target.build(dep, packageName) + inherit_list = target.build(dep, package_name) # add at the heritage list : - self.subHeritageList.add_heritage_list(inheritList) + self.sub_heritage_list.add_heritage_list(inherit_list) # build local sources for file in self.src: #debug.info(" " + self.name + " <== " + file); fileExt = file.split(".")[-1] - tmpBuilder = builder.getBuilder(fileExt); - if tmpBuilder != None: - resFile = tmpBuilder.compile(file, - packageName, + try: + tmp_builder = builder.get_builder(fileExt); + resFile = tmp_builder.compile(file, + package_name, target, - self.subHeritageList, + self.sub_heritage_list, 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 + "'") + basic_folder = self.origin_folder) + list_sub_file_needed_to_build.append(resFile) + except ValueError: + debug.warning(" UN-SUPPORTED file format: '" + self.origin_folder + "/" + file + "'") # when multiprocess availlable, we need to synchronize here ... lutinMultiprocess.pool_synchrosize() @@ -252,10 +252,28 @@ class Module: if self.type=='PREBUILD': debug.print_element("Prebuild", self.name, "==>", "find") elif self.type=='LIBRARY': - resFile = self.link_to_a(listSubFileNeededTobuild, packageName, target, self.subHeritageList) - self.localHeritage.add_sources(resFile) + try: + tmp_builder = builder.get_builder_with_output("a"); + resFile = tmp_builder.link(list_sub_file_needed_to_build, + package_name, + target, + self.sub_heritage_list, + name = self.name, + basic_folder = self.origin_folder) + self.local_heritage.add_sources(resFile) + except ValueError: + debug.error(" UN-SUPPORTED link format: '.a'") elif self.type=='BINARY': - resFile = self.link_to_bin(listSubFileNeededTobuild, packageName, target, self.subHeritageList) + try: + tmp_builder = builder.get_builder_with_output("bin"); + resFile = tmp_builder.link(list_sub_file_needed_to_build, + package_name, + target, + self.sub_heritage_list, + name = self.name, + basic_folder = self.origin_folder) + except ValueError: + debug.error(" UN-SUPPORTED link format: '.bin'") # generate tree for this special binary target.clean_module_tree() self.build_tree(target, self.name) @@ -263,36 +281,54 @@ class Module: elif self.type=="PACKAGE": if target.name=="Android": # special case for android wrapper : - resFile = self.link_to_so(listSubFileNeededTobuild, packageName, target, self.subHeritageList, "libewol") + try: + tmp_builder = builder.get_builder_with_output("so"); + resFile = tmp_builder.link(list_sub_file_needed_to_build, + package_name, + target, + self.sub_heritage_list, + name = "libewol", + basic_folder = self.origin_folder) + except ValueError: + debug.error(" UN-SUPPORTED link format: '.so'") else: - resFile = self.link_to_bin(listSubFileNeededTobuild, packageName, target, self.subHeritageList) + try: + tmp_builder = builder.get_builder_with_output("bin"); + resFile = tmp_builder.link(list_sub_file_needed_to_build, + package_name, + target, + self.sub_heritage_list, + name = self.name, + basic_folder = self.origin_folder) + except ValueError: + debug.error(" UN-SUPPORTED link format: 'binary'") target.clean_module_tree() # generate tree for this special binary self.build_tree(target, self.name) target.copy_to_staging(self.name) if target.endGeneratePackage==True: # generate the package with his properties ... - target.make_package(self.name, self.packageProp, self.originFolder + "/..") + target.make_package(self.name, self.package_prop, self.origin_folder + "/..") else: debug.error("Dit not know the element type ... (impossible case) type=" + self.type) - self.subHeritageList.add_heritage(self.localHeritage) + self.sub_heritage_list.add_heritage(self.local_heritage) # return local dependency ... - return self.subHeritageList + return self.sub_heritage_list # call here to build the module - def build_tree(self, target, packageName): + def build_tree(self, target, package_name): # ckeck if not previously build if target.is_module_buildTree(self.name)==True: return debug.verbose("build tree of " + self.name) # add all the elements (first added only one keep ==> permit to everload sublib element) - self.image_to_staging(packageName, target) - self.files_to_staging(packageName, target) - self.folders_to_staging(packageName, target) + self.image_to_staging(package_name, target) + self.files_to_staging(package_name, target) + self.folders_to_staging(package_name, target) #build tree of all submodules for dep in self.depends: - inherit = target.build_tree(dep, packageName) + inherit = target.build_tree(dep, package_name) # call here to clean the module @@ -395,9 +431,9 @@ class Module: if same_as_api == True: api_version = version self.flags["local"]["c++-version"] = { "version":version, - "api-version":api_version, "gnu":gnu } + self.flags["export"]["c++-version"] = api_version if gnu == True and same_as_api == True: debug.warning("Can not propagate the gnu extention of the CPP vesion for API"); @@ -410,9 +446,9 @@ class Module: if same_as_api == True: api_version = version self.flags["local"]["c-version"] = { "version":version, - "api-version":api_version, "gnu":gnu } + self.flags["export"]["c-version"] = api_version if gnu == True and same_as_api == True: debug.warning("Can not propagate the gnu extention of the C vesion for API"); @@ -439,8 +475,8 @@ class Module: print(' package : "' + self.name + "'") print('-----------------------------------------------') print(' type:"' + str(self.type) + "'") - print(' file:"' + str(self.originFile) + "'") - print(' folder:"' + str(self.originFolder) + "'") + print(' file:"' + str(self.origin_file) + "'") + print(' folder:"' + str(self.origin_folder) + "'") self.print_list('depends',self.depends) self.print_list('depends_optionnal', self.depends_optionnal) @@ -470,18 +506,18 @@ class Module: if value not in ["com", "net", "org", "gov", "mil", "edu", "pri", "museum"]: debug.error("can not set the value for this Input : '" + variable + "' : '" + value + "'") else: - self.packageProp[variable] = value + self.package_prop[variable] = value elif "COMPAGNY_NAME" == variable: - self.packageProp[variable] = value + self.package_prop[variable] = value val2 = value.lower() val2 = val2.replace(' ', '') val2 = val2.replace('-', '') val2 = val2.replace('_', '') - self.packageProp["COMPAGNY_NAME2"] = val2 + self.package_prop["COMPAGNY_NAME2"] = val2 elif "ICON" == variable: - self.packageProp[variable] = value + self.package_prop[variable] = value elif "MAINTAINER" == variable: - self.packageProp[variable] = value + self.package_prop[variable] = value elif "SECTION" == variable: # project section : (must be separate by coma # refer to : http://packages.debian.org/sid/ @@ -493,39 +529,39 @@ class Module: # mail math misc net news ocaml oldlibs otherosfs # perl php python ruby science shells sound tex # text utils vcs video virtual web x11 xfce zope ... - self.packageProp[variable] = value + self.package_prop[variable] = value elif "PRIORITY" == variable: #list = ["required","important","standard","optional","extra"] #if isinstance(value, list): if value not in ["required", "important", "standard", "optional", "extra"]: debug.error("can not set the value for this Input : '" + variable + "' : '" + value + "'") else: - self.packageProp[variable] = value + self.package_prop[variable] = value elif "DESCRIPTION" == variable: - self.packageProp[variable] = value + self.package_prop[variable] = value elif "VERSION" == variable: - self.packageProp[variable] = value + self.package_prop[variable] = value elif "VERSION_CODE" == variable: - self.packageProp[variable] = value + self.package_prop[variable] = value elif "NAME" == variable: - self.packageProp[variable] = value + self.package_prop[variable] = value elif "ANDROID_MANIFEST" == variable: - self.packageProp[variable] = value + self.package_prop[variable] = value elif "ANDROID_JAVA_FILES" == variable: - self.packageProp[variable] = value + self.package_prop[variable] = value elif "RIGHT" == variable: - self.packageProp[variable] = value + self.package_prop[variable] = value elif "ANDROID_RESOURCES" == variable: - self.packageProp[variable] = value + self.package_prop[variable] = value elif "ANDROID_APPL_TYPE" == variable: - self.packageProp[variable] = value + self.package_prop[variable] = value elif "ADMOD_ID" == variable: - self.packageProp[variable] = value + self.package_prop[variable] = value elif "APPLE_APPLICATION_IOS_ID" == variable: - self.packageProp[variable] = value + self.package_prop[variable] = value elif "ADMOD_POSITION" == variable: if value in ["top", "bottom"]: - self.packageProp[variable] = value + self.package_prop[variable] = value else: debug.error("not know pkg element : '" + variable + "' with value : '" + value + "' must be [top|bottom]") else: @@ -533,20 +569,20 @@ class Module: def pkg_add(self, variable, value): # TODO : Check values... - self.packageProp[variable].append(value) + self.package_prop[variable].append(value) - def ext_project_add_module(self, target, projectMng, addedModule = []): - if self.name in addedModule: + def ext_project_add_module(self, target, projectMng, added_module = []): + if self.name in added_module: return - addedModule.append(self.name) + added_module.append(self.name) debug.verbose("add a module to the project generator :" + self.name) - debug.verbose("local path :" + self.originFolder) - projectMng.add_files(self.name, self.originFolder, self.src) - #projectMng.add_data_file(self.originFolder, self.files) - #projectMng.add_data_folder(self.originFolder, self.folders) + debug.verbose("local path :" + self.origin_folder) + projectMng.add_files(self.name, self.origin_folder, self.src) + #projectMng.add_data_file(self.origin_folder, self.files) + #projectMng.add_data_folder(self.origin_folder, self.folders) """ for depend in self.depends: - target.project_add_module(depend, projectMng, addedModule) + target.project_add_module(depend, projectMng, added_module) """ def create_project(self, target, projectMng):