[DEV] work again with separate elements
This commit is contained in:
parent
63e46b8487
commit
78336f359e
@ -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])
|
||||
|
||||
@ -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"]
|
||||
|
||||
##
|
||||
|
||||
@ -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"]
|
||||
|
||||
##
|
||||
|
||||
@ -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"]
|
||||
@ -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])
|
||||
|
||||
@ -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)
|
||||
|
||||
@ -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"]
|
||||
|
||||
##
|
||||
|
||||
@ -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"]
|
||||
|
||||
##
|
||||
|
||||
@ -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"]
|
||||
|
||||
@ -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))
|
||||
@ -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
|
||||
|
||||
|
||||
|
||||
242
lutinModule.py
242
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):
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user