From 860d7607affca2c1ce9bbc8c8802dceaa339e9d7 Mon Sep 17 00:00:00 2001 From: Edouard DUPIN Date: Fri, 19 Apr 2013 22:06:05 +0200 Subject: [PATCH] [DEV] build all clean and correct dependency check if availlable --- corePython/buildList.py | 4 +- corePython/buildTools.py | 7 ++ corePython/dependency.py | 104 ++++++++++++++++++++++++ corePython/environement.py | 46 +++++++++++ corePython/heritage.py | 76 ++++++++++++++++++ corePython/module.py | 135 +++++++++++++++++++------------ corePython/target_Linux.py | 32 +++++--- make.py | 158 +++++++++++++++++++++++++------------ 8 files changed, 444 insertions(+), 118 deletions(-) create mode 100644 corePython/dependency.py create mode 100644 corePython/environement.py create mode 100644 corePython/heritage.py diff --git a/corePython/buildList.py b/corePython/buildList.py index 16ee2d1..f090de9 100644 --- a/corePython/buildList.py +++ b/corePython/buildList.py @@ -23,7 +23,7 @@ def Build(name): for elem in availlable: if elem[1] == "Module": if elem[2] == "bin": - module.Build(elem[0], GetCurrentTarget()) + module.Build(elem[0], None, GetCurrentTarget()) else: debug.error("TODO ... Build package '" + elem[0] + "'") elif name == "clean": @@ -55,7 +55,7 @@ def Build(name): if elem[0] == name: if elem[1] == "Module": debug.info("Build module '" + name + "'") - module.Build(name, GetCurrentTarget()) + module.Build(name, None, GetCurrentTarget()) else: debug.info("Build package '" + name + "'") debug.error("TODO ... Build package '" + cleanName + "'") diff --git a/corePython/buildTools.py b/corePython/buildTools.py index af12aac..781a657 100644 --- a/corePython/buildTools.py +++ b/corePython/buildTools.py @@ -26,6 +26,13 @@ def CreateDirectoryOfFile(file): os.makedirs(folder) +def RemoveFolderAndSubFolder(path): + if os.path.isdir(path): + debug.verbose("remove folder : '" + path + "'") + shutil.rmtree(path) + + + def ListToStr(list): if type(list) == type(str()): return list + " " diff --git a/corePython/dependency.py b/corePython/dependency.py new file mode 100644 index 0000000..e80c433 --- /dev/null +++ b/corePython/dependency.py @@ -0,0 +1,104 @@ +#!/usr/bin/python +import os +import debug +import environement + + +def NeedReBuild(dst, src, dependFile): + debug.verbose("Resuest check of dependency of :") + debug.verbose(" dst='" + dst + "'") + debug.verbose(" str='" + src + "'") + debug.verbose(" dept='" + dependFile + "'") + # if force mode selected ==> just force rebuild ... + if environement.GetForceMode(): + debug.verbose(" ==> must rebuild (force mode)") + return True + + # check if the destination existed: + if False==os.path.exists(dst): + debug.verbose(" ==> must rebuild (dst does not exist)") + return True + # chek the basic date if the 2 files + if os.path.getmtime(src) > os.path.getmtime(dst): + debug.verbose(" ==> must rebuild (source time greater)") + return True + # now we need to parse the file to find all the dependency file + # file is done like + # file : \ + # dep1 \ + # dep2 + # + # dep2 : \ + # dep4 + # + + if False==os.path.exists(dependFile): + debug.verbose(" ==> must rebuild (no depending file)") + return True + + debug.verbose(" start parsing dependency file : '" + dependFile + "'") + file = open(dependFile, "r") + for curLine in file.readlines(): + # normal file : end with : ": \\n" + curLine = curLine[:len(curLine)-1] + testFile="" + if curLine[len(curLine)-3:] == ': \\' \ + or curLine[len(curLine)-2:] == ': ' \ + or curLine[len(curLine)-1:] == ':': + debug.verbose(" Line (no check (already done) : '" + curLine + "'"); + elif curLine[len(curLine)-2:] == ' \\': + testFile = curLine[1:len(curLine)-2] + debug.verbose(" Line (might check1) : '" + testFile + "'"); + elif len(curLine) == 0: + debug.verbose(" Line (Not parsed) : '" + curLine + "'"); + else: + testFile = curLine[1:] + debug.verbose(" Line (might check2) : '" + testFile + "'"); + # really check files: + if testFile!="": + debug.verbose(" ==> test"); + if False==os.path.exists(testFile): + debug.warning(" ==> must rebuild (a dependency file does not exist)") + return True + if os.path.getmtime(testFile) > os.path.getmtime(dst): + debug.warning(" ==> must rebuild (a dependency file time is newer)") + return True + + debug.verbose(" ==> Not rebuild (all dependency is OK)") + return False + + + +def NeedRePackage(dst, srcList, mustHaveSrc): + debug.verbose("Resuest check of dependency of :") + debug.verbose(" dst='" + dst + "'") + debug.verbose(" src()=") + for src in srcList: + debug.verbose(" '" + src + "'") + + if mustHaveSrc==False and len(srcList)==0: + return False + + # if force mode selected ==> just force rebuild ... + if environement.GetForceMode(): + debug.verbose(" ==> must re-package (force mode)") + return True + + # check if the destination existed: + if False==os.path.exists(dst): + debug.verbose(" ==> must re-package (dst does not exist)") + return True + # chek the basic date if the 2 files + if len(srcList)==0: + debug.verbose(" ==> must re-package (no source ???)") + return True + for src in srcList: + if os.path.getmtime(src) > os.path.getmtime(dst): + debug.verbose(" ==> must re-package (source time greater) : '" + src + "'") + return True + + debug.verbose(" ==> Not re-package (all dependency is OK)") + return False + + + diff --git a/corePython/environement.py b/corePython/environement.py new file mode 100644 index 0000000..bd1d997 --- /dev/null +++ b/corePython/environement.py @@ -0,0 +1,46 @@ +#!/usr/bin/python +import debug + +debugMode=0 + +def SetDebugMode(val): + global debugMode + if val==1: + debugMode = 1 + else: + debugMode = 0 + +def GetDebugMode(): + global debugMode + return debugMode + +CompileMode="gcc" + +def SetCompileMode(val): + global CompileMode + if val=="clang": + CompileMode = val + if val=="gcc": + CompileMode = val + else: + debug.error("not understand compiling tool mode : '" + val + "' can be [gcc/clang]") + CompileMode = "gcc" + +def GetClangMode(): + global CompileMode + return CompileMode + +forceMode=False + +def SetForceMode(val): + global forceMode + if val==1: + forceMode = 1 + else: + forceMode = 0 + +def GetForceMode(): + global forceMode + return forceMode + + diff --git a/corePython/heritage.py b/corePython/heritage.py new file mode 100644 index 0000000..28754eb --- /dev/null +++ b/corePython/heritage.py @@ -0,0 +1,76 @@ +#!/usr/bin/python +import sys +import buildTools +import debug + + + +class heritage: + def __init__(self, module): + ## 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_m=[] + self.flags_mm=[] + # sources list: + self.src=[] + self.path=[] + # update is set at true when data are newly created ==> force upper element to update + self.hasBeenUpdated=False + + if type(module) != type(None): + # all the parameter that the upper classe need when build + 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 + + def AppendToInternalList(self, listout, list): + if type(list) == type(str()): + listout.append(list) + else: + # mulyiple imput in the list ... + for elem in list: + listout.append(elem) + + def AddFlag_LD(self, list): + self.AppendToInternalList(self.flags_ld, list) + + def AddFlag_CC(self, list): + self.AppendToInternalList(self.flags_cc, list) + + def AddFlag_XX(self, list): + self.AppendToInternalList(self.flags_xx, list) + + def AddFlag_M(self, list): + self.AppendToInternalList(self.flags_m, list) + + def AddFlag_MM(self, list): + self.AppendToInternalList(self.flags_mm, list) + + def AddImportPath(self, list): + self.AppendToInternalList(self.path, list) + + def AddSources(self, list): + self.AppendToInternalList(self.src, list) + + def NeedUpdate(self, list): + self.hasBeenUpdated=True + + def AddSub(self, other): + if type(other) == type(None): + debug.verbose("input of the heriatege class is None !!!") + return + if other.hasBeenUpdated==True: + self.hasBeenUpdated = True + self.AddFlag_LD(other.flags_ld) + self.AddFlag_CC(other.flags_cc) + self.AddFlag_XX(other.flags_xx) + self.AddFlag_M(other.flags_m) + self.AddFlag_MM(other.flags_mm) + self.AddImportPath(other.path) + self.AddSources(other.src) diff --git a/corePython/module.py b/corePython/module.py index b313168..cfc550e 100755 --- a/corePython/module.py +++ b/corePython/module.py @@ -9,10 +9,12 @@ import buildTools import debug import buildList import heritage +import dependency def RunCommand(cmdLine): debug.debug(cmdLine) ret = os.system(cmdLine) + # TODO : Use "subprocess" instead ==> permit to pipline the renderings ... if ret != 0: #print "result val = " + str(ret) debug.error("can not compile file ... ") @@ -64,7 +66,8 @@ class module: ## end of basic INIT ... if moduleType == 'BINARY' \ or moduleType == 'LIBRARY' \ - or moduleType == 'PACKAGE': + or moduleType == 'PACKAGE' \ + or moduleType == 'PREBUILD': self.type=moduleType else : debug.error('for module "%s"' %moduleName) @@ -78,7 +81,7 @@ class module: ############################################################################### ## Commands for running gcc to compile a m++ file. ############################################################################### - def Compile_mm_to_o(self, file, target, depancy): + def Compile_mm_to_o(self, file, binary, target, depancy): # TODO : Check depedency ... buildTools.CreateDirectoryOfFile(dst) debug.printElement("m++", self.name, "<==", file) @@ -99,7 +102,7 @@ class module: ############################################################################### ## Commands for running gcc to compile a m file. ############################################################################### - def Compile_m_to_o(self, file, target, depancy): + def Compile_m_to_o(self, file, binary, target, depancy): # TODO : Check depedency ... buildTools.CreateDirectoryOfFile(dst) debug.printElement("m", self.name, "<==", file) @@ -121,12 +124,11 @@ class module: ############################################################################### ## Commands for running gcc to compile a C++ file. ############################################################################### - def Compile_xx_to_o(self, file, target, depancy): - tmpList = target.GenerateFile(self.name,self.originFolder,file,"obj") - # TODO : Check depedency ... - if os.path.exists(tmpList[1]): - if os.path.getmtime(tmpList[1]) > os.path.getmtime(tmpList[0]): - return tmpList[1] + def Compile_xx_to_o(self, file, binary, target, depancy): + tmpList = target.GenerateFile(binary, self.name,self.originFolder,file,"obj") + # check the dependency for this file : + if False==dependency.NeedReBuild(tmpList[1], tmpList[0], tmpList[2]): + return tmpList[1] buildTools.CreateDirectoryOfFile(tmpList[1]) debug.printElement("c++", self.name, "<==", file) cmdLine=buildTools.ListToStr([ @@ -160,13 +162,11 @@ class module: ############################################################################### ## Commands for running gcc to compile a C file. ############################################################################### - - def Compile_cc_to_o(self, file, target, depancy): - tmpList = target.GenerateFile(self.name,self.originFolder,file,"obj") - # TODO : Check depedency ... - if os.path.exists(tmpList[1]): - if os.path.getmtime(tmpList[1]) > os.path.getmtime(tmpList[0]): - return tmpList[1] + def Compile_cc_to_o(self, file, binary, target, depancy): + tmpList = target.GenerateFile(binary,self.name,self.originFolder,file,"obj") + # check the dependency for this file : + if False==dependency.NeedReBuild(tmpList[1], tmpList[0], tmpList[2]): + return tmpList[1] buildTools.CreateDirectoryOfFile(tmpList[1]) debug.printElement("c", self.name, "<==", file) cmdLine=buildTools.ListToStr([ @@ -199,10 +199,12 @@ class module: ############################################################################### ## Commands for running ar. ############################################################################### - - def Link_to_a(self, file, target, depancy): - tmpList = target.GenerateFile(self.name,self.originFolder,file,"lib-static") - # TODO : Check depedency ... + def Link_to_a(self, file, binary, target, depancy): + tmpList = target.GenerateFile(binary, self.name,self.originFolder,file,"lib-static") + # check the dependency for this file : + if False==dependency.NeedRePackage(tmpList[1], tmpList[0], True) \ + and False==dependency.NeedRePackage(tmpList[1], depancy.src, False): + return tmpList[1] buildTools.CreateDirectoryOfFile(tmpList[1]) debug.printElement("StaticLib", self.name, "==>", tmpList[1]) # explicitly remove the destination to prevent error ... @@ -228,10 +230,12 @@ class module: ############################################################################### ## Commands for running gcc to link a shared library. ############################################################################### - - def Link_to_so(self, file, target, depancy): - tmpList = target.GenerateFile(self.name,self.originFolder,file,"lib-shared") - # TODO : Check depedency ... + def Link_to_so(self, file, binary, target, depancy): + tmpList = target.GenerateFile(binary, self.name,self.originFolder,file,"lib-shared") + # check the dependency for this file : + if False==dependency.NeedRePackage(tmpList[1], tmpList[0], True) \ + and False==dependency.NeedRePackage(tmpList[1], depancy.src, False): + return tmpList[1] buildTools.CreateDirectoryOfFile(tmpList[1]) debug.error("SharedLib")# + self.name + " ==> " + dst) #debug.printElement("SharedLib", self.name, "==>", tmpList[1]) @@ -258,9 +262,12 @@ class module: ############################################################################### ## Commands for running gcc to link an executable. ############################################################################### - def Link_to_bin(self, file, target, depancy): - tmpList = target.GenerateFile(self.name,self.originFolder,file,"bin") - # TODO : Check depedency ... + def Link_to_bin(self, file, binary, target, depancy): + tmpList = target.GenerateFile(binary, self.name,self.originFolder,file,"bin") + # check the dependency for this file : + if False==dependency.NeedRePackage(tmpList[1], tmpList[0], True) \ + and False==dependency.NeedRePackage(tmpList[1], depancy.src, False): + return tmpList[1] buildTools.CreateDirectoryOfFile(tmpList[1]) debug.printElement("Executable", self.name, "==>", tmpList[1]) #$(Q)$(TARGET_AR) $(TARGET_GLOBAL_ARFLAGS) $(PRIVATE_ARFLAGS) $@ $(PRIVATE_ALL_OBJECTS) @@ -296,8 +303,8 @@ class module: ############################################################################### ## Commands for copying files ############################################################################### - def files_to_staging(self, target, binaryName): - baseFolder = target.GetStagingFolder(binaryName) + def files_to_staging(self, binaryName, target): + baseFolder = target.GetStagingFolderData(binaryName) for element in self.files: debug.verbose("Might copy file : " + element[0] + " ==> " + element[1]) buildTools.CopyFile(self.originFolder+"/"+element[0], baseFolder+"/"+element[1]) @@ -305,22 +312,31 @@ class module: ############################################################################### ## Commands for copying files ############################################################################### - def folders_to_staging(self, target, binaryName): - baseFolder = target.GetStagingFolder(binaryName) + def folders_to_staging(self, binaryName, target): + baseFolder = target.GetStagingFolderData(binaryName) for element in self.folders: debug.verbose("Might copy folder : " + element[0] + "==>" + element[1]) buildTools.CopyAnything(self.originFolder+"/"+element[0], baseFolder+"/"+element[1]) # call here to build the module - def Build(self, target): + def Build(self, binaryName, target): # ckeck if not previously build if target.IsModuleBuild(self.name)==True: return self.localHeritage + + if binaryName==None \ + and self.type=='BINARY': + # this is the endpoint binary ... + binaryName = self.name + else : + # TODO : Set it better ... + None + # build dependency befor listSubFileNeededToBuild = [] subHeritage = heritage.heritage(None) for dep in self.depends: - inherit = Build(dep, target) + inherit = Build(dep, binaryName, target) # add at the heritage list : subHeritage.AddSub(inherit) @@ -329,22 +345,27 @@ class module: #debug.info(" " + self.name + " <== " + file); fileExt = file.split(".")[-1] if fileExt == "c" or fileExt == "C": - resFile = self.Compile_cc_to_o(file, target, subHeritage) + resFile = self.Compile_cc_to_o(file, binaryName, target, subHeritage) listSubFileNeededToBuild.append(resFile) elif fileExt == "cpp" or fileExt == "CPP" or fileExt == "cxx" or fileExt == "CXX" or fileExt == "xx" or fileExt == "XX": - resFile = self.Compile_xx_to_o(file, target, subHeritage) + resFile = self.Compile_xx_to_o(file, binaryName, target, subHeritage) listSubFileNeededToBuild.append(resFile) else: debug.verbose(" TODO : gcc " + self.originFolder + "/" + file) # generate end point: - if self.type=='LIBRARY': - resFile = self.Link_to_a(listSubFileNeededToBuild, target, subHeritage) + if self.type=='PREBUILD': + # nothing to add ==> just dependence + None + elif self.type=='LIBRARY': + resFile = self.Link_to_a(listSubFileNeededToBuild, binaryName, target, subHeritage) self.localHeritage.AddSources(resFile) - else: - resFile = self.Link_to_bin(listSubFileNeededToBuild, target, subHeritage) + elif self.type=='BINARY': + resFile = self.Link_to_bin(listSubFileNeededToBuild, binaryName, target, subHeritage) # generate tree for this special binary self.BuildTree(target, self.name) - + else: + debug.error("Dit not know the element type ... (impossible case) type=" + self.type) + self.localHeritage.AddSub(subHeritage) # return local dependency ... return self.localHeritage @@ -358,19 +379,30 @@ class module: for dep in self.depends: inherit = BuildTree(dep, target, binaryName) # add all the elements - self.files_to_staging(target, binaryName) - self.folders_to_staging(target, binaryName) + self.files_to_staging(binaryName, target) + self.folders_to_staging(binaryName, target) # call here to Clean the module def Clean(self, target): - for file in self.src: - debug.error("TODO " + self.name + " <- (X) " + file); - - def CleanTree(self, target, binaryName): - for file in self.src: - debug.error("TODO " + self.name + " <- (X) " + file); - + if self.type=='PREBUILD': + # nothing to add ==> just dependence + None + elif self.type=='LIBRARY': + # remove folder of the lib ... for this targer + folderBuild = target.GetBuildFolder(self.name) + debug.info("remove folder : '" + folderBuild + "'") + buildTools.RemoveFolderAndSubFolder(folderBuild) + elif self.type=='BINARY': + # remove folder of the lib ... for this targer + folderBuild = target.GetBuildFolder(self.name) + debug.info("remove folder : '" + folderBuild + "'") + buildTools.RemoveFolderAndSubFolder(folderBuild) + folderStaging = target.GetStagingFolder(self.name) + debug.info("remove folder : '" + folderStaging + "'") + buildTools.RemoveFolderAndSubFolder(folderStaging) + else: + debug.error("Dit not know the element type ... (impossible case) type=" + self.type) def AppendToInternalList(self, listout, list): if type(list) == type(str()): @@ -494,10 +526,10 @@ def Dump(): # return inherit packages ... -def Build(name,target): +def Build(name, binName, target): for module in moduleList: if module.name == name: - return module.Build(target) + return module.Build(binName, target) debug.error("request to build an un-existant module name : '" + name + "'") def BuildTree(name,target,binName): @@ -512,6 +544,7 @@ def Clean(name,target): for module in moduleList: if module.name == name: module.Clean(target) + return debug.error("request to clean an un-existant module name : '" + name + "'") diff --git a/corePython/target_Linux.py b/corePython/target_Linux.py index d1b7a5d..78b13f5 100755 --- a/corePython/target_Linux.py +++ b/corePython/target_Linux.py @@ -8,7 +8,7 @@ class Target: def __init__(self): self.name='Linux' debug.info("create board target : "+self.name); - if 1==environement.GetClangMode(): + if "clang"==environement.GetClangMode(): self.cc='clang' self.xx='clang++' else: @@ -34,7 +34,7 @@ class Target: self.global_libs_ld='' self.global_libs_ld_shared='' - self.suffix_dependence='.o' + self.suffix_dependence='.d' self.suffix_obj='.o' self.suffix_lib_static='.a' self.suffix_lib_dynamic='.so' @@ -64,30 +64,36 @@ class Target: 1 : destination file 2 : dependence files module (*.d) """ - def GenerateFile(self,moduleName,basePath,file,type): + def GenerateFile(self,binaryName,moduleName,basePath,file,type): list=[] if (type=="bin"): list.append(file) - list.append(buildTools.GetRunFolder() + self.folder_out + self.folder_staging + self.folder_bin + "/" + moduleName + self.suffix_binary) - list.append(buildTools.GetRunFolder() + self.folder_out + self.folder_build + "/" + moduleName + "/" + moduleName + self.suffix_dependence) + list.append(self.GetStagingFolder(binaryName) + self.folder_bin + "/" + moduleName + self.suffix_binary) + list.append(self.GetBuildFolder(moduleName) + moduleName + self.suffix_dependence) elif (type=="obj"): list.append(basePath + "/" + file) - list.append(buildTools.GetRunFolder() + self.folder_out + self.folder_build + "/" + moduleName + "/" + file + self.suffix_obj) - list.append(buildTools.GetRunFolder() + self.folder_out + self.folder_build + "/" + moduleName + "/" + file + self.suffix_dependence) + list.append(self.GetBuildFolder(moduleName) + file + self.suffix_obj) + list.append(self.GetBuildFolder(moduleName) + file + self.suffix_dependence) elif (type=="lib-shared"): list.append(file) - list.append(buildTools.GetRunFolder() + self.folder_out + self.folder_staging + self.folder_lib + "/" + moduleName + self.suffix_lib_dynamic) - list.append(buildTools.GetRunFolder() + self.folder_out + self.folder_build + "/" + moduleName + "/" + moduleName + self.suffix_dependence) + list.append(self.GetStagingFolder(binaryName) + self.folder_lib + "/" + moduleName + self.suffix_lib_dynamic) + list.append(self.GetBuildFolder(moduleName) + moduleName + self.suffix_dependence) elif (type=="lib-static"): list.append(file) - list.append(buildTools.GetRunFolder() + self.folder_out + self.folder_build + "/" + moduleName + "/" + moduleName + self.suffix_lib_static) - list.append(buildTools.GetRunFolder() + self.folder_out + self.folder_build + "/" + moduleName + "/" + moduleName + self.suffix_dependence) + list.append(self.GetBuildFolder(moduleName) + moduleName + self.suffix_lib_static) + list.append(self.GetBuildFolder(moduleName) + moduleName + self.suffix_dependence) else: debug.error("unknow type : " + type) return list - def GetStagingFolder(self, moduleName): - return buildTools.GetRunFolder() + self.folder_out + self.folder_staging + self.folder_data + "/" + moduleName + def GetStagingFolder(self, binaryName): + return buildTools.GetRunFolder() + self.folder_out + self.folder_staging + "/" + binaryName + "/" + + def GetStagingFolderData(self, binaryName): + return self.GetStagingFolder(binaryName) + self.folder_data + "/" + + def GetBuildFolder(self, moduleName): + return buildTools.GetRunFolder() + self.folder_out + self.folder_build + "/" + moduleName + "/" def IsModuleBuild(self,module): for mod in self.buildDone: diff --git a/make.py b/make.py index 4886f91..0a749b0 100755 --- a/make.py +++ b/make.py @@ -4,20 +4,77 @@ import sys import os import inspect import fnmatch -sys.path.append(os.path.dirname(__file__) + "/corePython/" ) +if __name__ == "__main__": + sys.path.append(os.path.dirname(__file__) + "/corePython/" ) + import debug +import environement + + +""" + Display the help of this makefile +""" +def usage(): + print "usage:" + print " " + sys.argv[0] + " [options] [cible/properties] ..." + print " [help] display this help" + print " [option] : keep the last set" + print " [-h/--help] Display this help and break" + print " [-v?/--verbose=?] Display makefile debug level (verbose) default =2" + print " [-c/--color] Display makefile output in color" + print " [-f/--force] Force the rebuild without checking the dependency" + print " [properties] : keep in the sequency of the cible" + print " [-p=.../--platform=...] (Android/Linux/MacOs/Windows) Select a platform (by default the platform is the computer that compile this" + print " [-t/--tool] (clang/gcc) Compile with clang or Gcc mode (by default gcc will be used)" + print " [-m=.../--mode=...] (debug/release) Compile in release or debug mode (default release)" + print " [cible] : generate in order set" + print " [dump] Dump all the module dependency and properties" + print " [all] Build all (only for the current selected board) (bynary and packages)" + print " [clean] Clean all (same as previous)" + print " ... You can add 'module name' with at end : -clean to clean only this element" + print " ex: " + sys.argv[0] + " all board=Android all board=Windows all help" + exit(0) -countArgToPreventVerboseError = len(sys.argv) # preparse the argument to get the erbose element for debug mode -for argument in sys.argv: - if argument == "verbose": - debug.SetLevel(5) - countArgToPreventVerboseError -= 1 - elif argument == "color": - debug.EnableColor() - countArgToPreventVerboseError -= 1 +def parseGenericArg(argument,active): + if argument == "-h" or argument == "--help": + #display help + usage() + return True + elif argument[:2] == "-v": + if active==True: + if len(argument)==2: + debug.SetLevel(5) + else: + debug.SetLevel(int(argument[2:])) + return True + elif argument[:9] == "--verbose": + if active==True: + if len(argument)==9: + debug.SetLevel(5) + else: + if argument[:10] == "--verbose=": + debug.SetLevel(int(argument[10:])) + else: + debug.SetLevel(int(argument[9:])) + return True + elif argument == "-c" or argument == "--color": + if active==True: + debug.EnableColor() + return True + elif argument == "-f" or argument == "--force": + if active==True: + environement.SetForceMode(True) + return True + return False -# now import other standard module +# parse default unique argument: +if __name__ == "__main__": + sys.path.append(os.path.dirname(__file__) + "/corePython/" ) + for argument in sys.argv: + parseGenericArg(argument, True) + +# now import other standard module (must be done here and not before ... import module import host import buildTools @@ -25,55 +82,52 @@ import host import buildList -""" - Display the help of this makefile -""" -def HelpDisplay(): - print "usage:" - print " " + sys.argv[0] + " [help] [dump] [all] [clean] [board=...] [clang/gcc] [debug/release] [check] [verbose] [color]" - print " [help] display this help" - print " [dump] dump all the module dependency" - print " [all] build all (only for the current selected board)" - print " [clean] clean all (same as previous)" - print " [board=...] select a board (by default the board is the computer that compile this" - print " [clang/gcc] Compile with clang or Gcc mode (by default gcc will be used)" - print " [debug/release] compile in release or debug mode (default release)" - print " [check] Check if all dependency are resolved" - print " [verbose] display makefile debug" - print " [color] display makefile output in color" - print " you can add 'module name' with at end : -clean to clean only this element" - print " ex: " + sys.argv[0] + " all board=Android all board=Windows all help" - exit(0) - - """ Run everything that is needed in the system """ def Start(): + actionDone=False # parse all argument - if countArgToPreventVerboseError==1: - #by default we build all binary for the current board - buildList.Build("all") - else: - for argument in sys.argv[1:]: - if argument == "help": - #display help - HelpDisplay() - elif argument == "all": - #build all the board - buildList.Build("all") - elif argument == "dump": - module.Dump() - elif argument == "verbose": - # nothing to do ... - None - elif argument == "color": - # nothing to do ... - None + for argument in sys.argv[1:]: + if True==parseGenericArg(argument, False): + None # nothing to do ... + elif argument == "dump": + module.Dump() + actionDone=True + elif argument[:11] == "--platform=" or argument[:3] == "-p=": + tmpArg="" + if argument[:3] == "-p=": + tmpArg=argument[3:] else: - buildList.Build(argument) - + tmpArg=argument[11:] + # TODO ... + elif argument[:7] == "--mode=" or argument[:3] == "-m=": + tmpArg="" + if argument[:3] == "-m=": + tmpArg=argument[3:] + else: + tmpArg=argument[11:] + if "debug"==tmpArg: + environement.SetDebugMode(1) + elif "release"==tmpArg: + environement.SetDebugMode(0) + else: + debug.error("not understand build mode : '" + val + "' can be [debug/release]") + environement.SetDebugMode(0) + elif argument[:7] == "--tool=" or argument[:3] == "-t=": + tmpArg="" + if argument[:3] == "-t=": + tmpArg=argument[3:] + else: + tmpArg=argument[11:] + environement.SetCompileMode(tmpArg) + else: + buildList.Build(argument) + actionDone=True + # if no action done : we do "all" ... + if actionDone==False: + buildList.Build("all") """ When the user use with make.py we initialise ourself