460 lines
15 KiB
Python
460 lines
15 KiB
Python
#!/usr/bin/python
|
|
##
|
|
## @author Edouard DUPIN
|
|
##
|
|
## @copyright 2012, Edouard DUPIN, all right reserved
|
|
##
|
|
## @license APACHE v2.0 (see license file)
|
|
##
|
|
|
|
import sys
|
|
import os
|
|
import inspect
|
|
import fnmatch
|
|
import lutinDebug as debug
|
|
import lutinHeritage as heritage
|
|
import datetime
|
|
import lutinTools
|
|
import lutinModule
|
|
import lutinSystem
|
|
import lutinImage
|
|
import lutinHost
|
|
import lutinMultiprocess as multiprocess
|
|
|
|
class Target:
|
|
def __init__(self, name, config, arch):
|
|
self.config = config
|
|
|
|
#processor type selection (auto/arm/ppc/x86)
|
|
self.selectArch = config["arch"]; # TODO : Remove THIS ...
|
|
#bus size selection (auto/32/64)
|
|
self.selectBus = config["bus-size"]; # TODO : Remove THIS ...
|
|
|
|
if config["bus-size"] == "auto":
|
|
debug.error("system error ==> must generate the default 'bus-size' config")
|
|
if config["arch"] == "auto":
|
|
debug.error("system error ==> must generate the default 'bus-size' config")
|
|
|
|
debug.debug("config=" + str(config))
|
|
if arch != "":
|
|
self.arch = "-arch " + arch
|
|
else:
|
|
self.arch = ""
|
|
|
|
# todo : remove this :
|
|
self.sumulator = config["simulation"]
|
|
self.name=name
|
|
self.endGeneratePackage = config["generate-package"]
|
|
debug.info("=================================");
|
|
debug.info("== Target='" + self.name + "' " + config["bus-size"] + " bits for arch '" + config["arch"] + "'");
|
|
debug.info("=================================");
|
|
|
|
self.set_cross_base()
|
|
|
|
###############################################################################
|
|
# Target global variables.
|
|
###############################################################################
|
|
self.global_include_cc=[]
|
|
self.global_flags_cc=['-D__TARGET_OS__'+self.name,
|
|
'-D__TARGET_ARCH__'+self.selectArch,
|
|
'-D__TARGET_ADDR__'+self.selectBus + 'BITS',
|
|
'-D_REENTRANT']
|
|
|
|
self.global_flags_xx=[]
|
|
self.global_flags_mm=[]
|
|
if self.name == "Windows":
|
|
self.global_flags_xx=['-static-libgcc', '-static-libstdc++']
|
|
self.global_flags_mm=[]
|
|
self.global_flags_m=[]
|
|
self.global_flags_ar=['rcs']
|
|
self.global_flags_ld=[]
|
|
self.global_flags_ld_shared=[]
|
|
self.global_libs_ld=[]
|
|
self.global_libs_ld_shared=[]
|
|
|
|
self.global_sysroot=""
|
|
|
|
self.suffix_cmdLine='.cmd'
|
|
self.suffix_dependence='.d'
|
|
self.suffix_obj='.o'
|
|
self.suffix_lib_static='.a'
|
|
self.suffix_lib_dynamic='.so'
|
|
self.suffix_binary=''
|
|
self.suffix_package='.deb'
|
|
|
|
self.folder_arch="/" + self.name
|
|
|
|
if "debug" == self.config["mode"]:
|
|
self.global_flags_cc.append("-g")
|
|
self.global_flags_cc.append("-DDEBUG")
|
|
self.global_flags_cc.append("-O0")
|
|
else:
|
|
self.global_flags_cc.append("-DNDEBUG")
|
|
self.global_flags_cc.append("-O3")
|
|
|
|
## To add code coverate on build result system
|
|
if self.config["gcov"] == True:
|
|
self.global_flags_cc.append("-fprofile-arcs")
|
|
self.global_flags_cc.append("-ftest-coverage")
|
|
self.global_flags_ld.append("-fprofile-arcs")
|
|
self.global_flags_ld.append("-ftest-coverage")
|
|
|
|
self.update_folder_tree()
|
|
self.folder_bin="/usr/bin"
|
|
self.folder_lib="/usr/lib"
|
|
self.folder_data="/usr/share"
|
|
self.folder_doc="/usr/share/doc"
|
|
self.buildDone=[]
|
|
self.buildTreeDone=[]
|
|
self.moduleList=[]
|
|
# output staging files list :
|
|
self.listFinalFile=[]
|
|
|
|
self.sysroot=""
|
|
|
|
def update_folder_tree(self):
|
|
self.folder_out="/out/" + self.name + "_" + self.config["arch"] + "_" + self.config["bus-size"] + "/" + self.config["mode"]
|
|
self.folder_final="/final/" + self.config["compilator"]
|
|
self.folder_staging="/staging/" + self.config["compilator"]
|
|
self.folder_build="/build/" + self.config["compilator"]
|
|
|
|
def create_number_from_version_string(self, data):
|
|
list = data.split(".")
|
|
if len(list) == 1:
|
|
list.append("0")
|
|
if len(list) == 2:
|
|
list.append("0")
|
|
if len(list) > 3:
|
|
list = list[:3]
|
|
out = 0;
|
|
offset = 1000**(len(list)-1)
|
|
for elem in list:
|
|
out += offset*int(elem)
|
|
debug.verbose("get : " + str(int(elem)) + " tmp" + str(out))
|
|
offset /= 1000
|
|
return out
|
|
|
|
def set_cross_base(self, cross=""):
|
|
self.cross = cross
|
|
debug.debug("== Target='" + self.cross + "'");
|
|
self.ar = self.cross + "ar"
|
|
self.ranlib = self.cross + "ranlib"
|
|
if self.config["compilator"] == "clang":
|
|
self.cc = self.cross + "clang"
|
|
self.xx = self.cross + "clang++"
|
|
#self.ar=self.cross + "llvm-ar"
|
|
#self.ranlib="ls"
|
|
else:
|
|
self.cc = self.cross + "gcc"
|
|
self.xx = self.cross + "g++"
|
|
#self.ar=self.cross + "ar"
|
|
#self.ranlib=self.cross + "ranlib"
|
|
|
|
#get g++ compilation version :
|
|
ret = multiprocess.run_command_direct(self.xx + " -dumpversion");
|
|
if ret == False:
|
|
debug.error("Can not get the g++/clang++ version ...")
|
|
self.xx_version = self.create_number_from_version_string(ret)
|
|
debug.verbose(self.config["compilator"] + "++ version=" + str(ret) + " number=" + str(self.xx_version))
|
|
|
|
self.ld = self.cross + "ld"
|
|
self.nm = self.cross + "nm"
|
|
self.strip = self.cross + "strip"
|
|
self.dlltool = self.cross + "dlltool"
|
|
self.update_folder_tree()
|
|
|
|
def get_build_mode(self):
|
|
return self.config["mode"]
|
|
|
|
def add_image_staging(self, inputFile, outputFile, sizeX, sizeY, cmdFile=None):
|
|
for source, dst, x, y, cmdFile2 in self.listFinalFile:
|
|
if dst == outputFile :
|
|
debug.verbose("already added : " + outputFile)
|
|
return
|
|
debug.verbose("add file : '" + inputFile + "' ==> '" + outputFile + "'")
|
|
self.listFinalFile.append([inputFile,outputFile, sizeX, sizeY, cmdFile])
|
|
|
|
def add_file_staging(self, inputFile, outputFile, cmdFile=None):
|
|
for source, dst, x, y, cmdFile2 in self.listFinalFile:
|
|
if dst == outputFile :
|
|
debug.verbose("already added : " + outputFile)
|
|
return
|
|
debug.verbose("add file : '" + inputFile + "' ==> '" + outputFile + "'");
|
|
self.listFinalFile.append([inputFile, outputFile, -1, -1, cmdFile])
|
|
|
|
def copy_to_staging(self, binaryName):
|
|
baseFolder = self.get_staging_folder_data(binaryName)
|
|
for source, dst, x, y, cmdFile in self.listFinalFile:
|
|
if cmdFile != None \
|
|
and cmdFile != "":
|
|
debug.verbose("cmd file " + cmdFile)
|
|
if x == -1:
|
|
debug.verbose("must copy file : '" + source + "' ==> '" + dst + "'");
|
|
lutinTools.copy_file(source, baseFolder+"/"+dst, cmdFile)
|
|
else:
|
|
debug.verbose("resize image : '" + source + "' ==> '" + dst + "' size=(" + str(x) + "," + str(y) + ")");
|
|
lutinImage.resize(source, baseFolder+"/"+dst, x, y, cmdFile)
|
|
|
|
|
|
def clean_module_tree(self):
|
|
self.buildTreeDone = []
|
|
self.listFinalFile = []
|
|
|
|
|
|
# TODO : Remove this hack ... ==> really bad ... but usefull
|
|
def set_ewol_folder(self, folder):
|
|
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
|
|
"""
|
|
return a list of 3 elements :
|
|
0 : sources files (can be a list)
|
|
1 : destination file
|
|
2 : dependence files module (*.d)
|
|
"""
|
|
def generate_file(self,binaryName,moduleName,basePath,file,type):
|
|
list=[]
|
|
if (type=="bin"):
|
|
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)
|
|
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)
|
|
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)
|
|
elif (type=="image"):
|
|
list.append(self.get_build_folder(binaryName) + "/data/" + file + self.suffix_cmdLine)
|
|
else:
|
|
debug.error("unknow type : " + type)
|
|
return list
|
|
|
|
def get_final_folder(self):
|
|
return lutinTools.get_run_folder() + self.folder_out + self.folder_final
|
|
|
|
def get_staging_folder(self, binaryName):
|
|
return lutinTools.get_run_folder() + self.folder_out + self.folder_staging + "/" + binaryName
|
|
|
|
def get_staging_folder_data(self, binaryName):
|
|
return self.get_staging_folder(binaryName) + self.folder_data + "/" + binaryName
|
|
|
|
def get_build_folder(self, moduleName):
|
|
return lutinTools.get_run_folder() + self.folder_out + self.folder_build + "/" + moduleName
|
|
|
|
def get_doc_folder(self, moduleName):
|
|
return lutinTools.get_run_folder() + self.folder_out + self.folder_doc + "/" + moduleName
|
|
|
|
def is_module_build(self, module):
|
|
for mod in self.buildDone:
|
|
if mod == module:
|
|
return True
|
|
self.buildDone.append(module)
|
|
return False
|
|
|
|
def is_module_buildTree(self, module):
|
|
for mod in self.buildTreeDone:
|
|
if mod == module:
|
|
return True
|
|
self.buildTreeDone.append(module)
|
|
return False
|
|
|
|
def add_module(self, newModule):
|
|
debug.debug("Add nodule for Taget : " + newModule.name)
|
|
self.moduleList.append(newModule)
|
|
|
|
|
|
# return inherit packages ...
|
|
"""
|
|
def build(self, name, packagesName):
|
|
for module in self.moduleList:
|
|
if module.name == name:
|
|
return module.build(self, packagesName)
|
|
debug.error("request to build an un-existant module name : '" + name + "'")
|
|
"""
|
|
|
|
def build_tree(self, name, packagesName):
|
|
for module in self.moduleList:
|
|
if module.name == name:
|
|
module.build_tree(self, packagesName)
|
|
return
|
|
debug.error("request to build tree on un-existant module name : '" + name + "'")
|
|
|
|
def clean(self, name):
|
|
for module in self.moduleList:
|
|
if module.name == name:
|
|
module.clean(self)
|
|
return
|
|
debug.error("request to clean an un-existant module name : '" + name + "'")
|
|
|
|
def load_if_needed(self, name, optionnal=False):
|
|
for elem in self.moduleList:
|
|
if elem.name == name:
|
|
return True
|
|
if optionnal == False:
|
|
lutinModule.load_module(self, name)
|
|
return True
|
|
else:
|
|
# TODO : Check internal module and system module ...
|
|
# need to import the module (or the system module ...)
|
|
exist = lutinSystem.exist(name, self.name)
|
|
if exist == True:
|
|
lutinSystem.load(self, name, self.name)
|
|
return True;
|
|
# try to find in the local Modules:
|
|
exist = lutinModule.exist(self, name)
|
|
if exist == True:
|
|
lutinModule.load_module(self, name)
|
|
return True;
|
|
else:
|
|
return False;
|
|
|
|
def load_all(self):
|
|
listOfAllTheModule = lutinModule.list_all_module()
|
|
for modName in listOfAllTheModule:
|
|
self.load_if_needed(modName)
|
|
|
|
def project_add_module(self, name, projectMng, addedModule):
|
|
for module in self.moduleList:
|
|
if module.name == name:
|
|
module.ext_project_add_module(self, projectMng, addedModule)
|
|
return
|
|
|
|
def build_optionnal(self, moduleName, packagesName=None):
|
|
present = self.load_if_needed(moduleName, optionnal=True)
|
|
if present == False:
|
|
return [heritage.HeritageList(), False]
|
|
# clean requested
|
|
for mod in self.moduleList:
|
|
if mod.name == moduleName:
|
|
debug.debug("build module '" + moduleName + "'")
|
|
return [mod.build(self, None), True]
|
|
debug.warning("not know module name : '" + moduleName + "' to '" + "build" + "' it")
|
|
return [heritage.HeritageList(), False]
|
|
|
|
def build(self, name, packagesName=None):
|
|
if name == "dump":
|
|
debug.info("dump all")
|
|
self.load_all()
|
|
for mod in self.moduleList:
|
|
mod.display(self)
|
|
return
|
|
if name == "all":
|
|
debug.info("build all")
|
|
self.load_all()
|
|
for mod in self.moduleList:
|
|
if self.name=="Android":
|
|
if mod.type == "PACKAGE":
|
|
mod.build(self, None)
|
|
else:
|
|
if mod.type == "BINARY" \
|
|
or mod.type == "PACKAGE":
|
|
mod.build(self, None)
|
|
elif name == "clean":
|
|
debug.info("clean all")
|
|
self.load_all()
|
|
for mod in self.moduleList:
|
|
mod.clean(self)
|
|
else:
|
|
# get the action an the module ....
|
|
gettedElement = name.split("?")
|
|
moduleName = gettedElement[0]
|
|
if len(gettedElement)>=2:
|
|
actionName = gettedElement[1]
|
|
else :
|
|
actionName = "build"
|
|
debug.verbose("requested : " + moduleName + "-" + actionName)
|
|
if actionName == "install":
|
|
self.build(moduleName + "?build")
|
|
self.install_package(moduleName)
|
|
elif actionName == "uninstall":
|
|
self.un_install_package(moduleName)
|
|
elif actionName == "log":
|
|
self.Log(moduleName)
|
|
else:
|
|
self.load_if_needed(moduleName)
|
|
# clean requested
|
|
for mod in self.moduleList:
|
|
if mod.name == moduleName:
|
|
if actionName == "dump":
|
|
debug.info("dump module '" + moduleName + "'")
|
|
return mod.display(self)
|
|
elif actionName == "clean":
|
|
debug.info("clean module '" + moduleName + "'")
|
|
return mod.clean(self)
|
|
elif actionName == "build":
|
|
debug.debug("build module '" + moduleName + "'")
|
|
return mod.build(self, None)
|
|
debug.error("not know module name : '" + moduleName + "' to '" + actionName + "' it")
|
|
|
|
|
|
targetList=[]
|
|
__startTargetName="lutinTarget_"
|
|
|
|
|
|
def import_path(path):
|
|
global targetList
|
|
matches = []
|
|
debug.debug('TARGET: Start find sub File : "%s"' %path)
|
|
for root, dirnames, filenames in os.walk(path):
|
|
tmpList = fnmatch.filter(filenames, __startTargetName + "*.py")
|
|
# Import the module :
|
|
for filename in tmpList:
|
|
debug.debug('TARGET: Find a file : "%s"' %os.path.join(root, filename))
|
|
#matches.append(os.path.join(root, filename))
|
|
sys.path.append(os.path.dirname(os.path.join(root, filename)) )
|
|
targetName = filename.replace('.py', '')
|
|
targetName = targetName.replace(__startTargetName, '')
|
|
debug.debug("TARGET: integrate module: '" + targetName + "' from '" + os.path.join(root, filename) + "'")
|
|
targetList.append([targetName,os.path.join(root, filename)])
|
|
|
|
|
|
def load_target(name, config):
|
|
global targetList
|
|
debug.debug("load target: " + name)
|
|
if len(targetList) == 0:
|
|
debug.error("No target to compile !!!")
|
|
debug.debug("list target: " + str(targetList))
|
|
for mod in targetList:
|
|
if mod[0] == name:
|
|
debug.verbose("add to path: '" + os.path.dirname(mod[1]) + "'")
|
|
sys.path.append(os.path.dirname(mod[1]))
|
|
debug.verbose("import target : '" + __startTargetName + name + "'")
|
|
theTarget = __import__(__startTargetName + name)
|
|
#create the target
|
|
tmpTarget = theTarget.Target(config)
|
|
return tmpTarget
|
|
|
|
def list_all_target():
|
|
global targetList
|
|
tmpListName = []
|
|
for mod in targetList:
|
|
tmpListName.append(mod[0])
|
|
return tmpListName
|
|
|
|
def list_all_target_with_desc():
|
|
global targetList
|
|
tmpList = []
|
|
for mod in targetList:
|
|
sys.path.append(os.path.dirname(mod[1]))
|
|
theTarget = __import__(__startTargetName + mod[0])
|
|
try:
|
|
tmpdesc = theTarget.get_desc()
|
|
tmpList.append([mod[0], tmpdesc])
|
|
except:
|
|
debug.warning("has no name : " + mod[0])
|
|
tmpList.append([mod[0], ""])
|
|
return tmpList
|