[RELEASE] new version 1.2.3

bin/lutin

@@ -11,6 +11,7 @@
 # for path inspection:
 import sys
 import os
+import copy
 import lutin
 import lutin.debug as debug
 import lutin.arg as arguments
@@ -34,6 +35,7 @@ myArgs.add(arguments.ArgDefine("P", "pretty", desc="Print the debug has pretty d
 myArgs.add(arguments.ArgDefine("j", "jobs", haveParam=True, desc="Specifies the number of jobs (commands) to run simultaneously"))
 myArgs.add(arguments.ArgDefine("d", "depth", haveParam=True, desc="Depth of the search of sub element lutin_*.py (default=" + str(env.get_parse_depth()) + ")"))
 myArgs.add(arguments.ArgDefine("s", "force-strip", desc="Force the stripping of the compile elements"))
+myArgs.add(arguments.ArgDefine("o", "force-optimisation", desc="Force optimisation of the build"))
 myArgs.add(arguments.ArgDefine("w", "warning", desc="Store warning in a file build file"))
 
 myArgs.add_section("properties", "keep in the sequency of the cible")
@@ -153,6 +155,15 @@ def usage(full=False):
 	print("	ex: " + sys.argv[0] + " all --target=Android all -t Windows -m debug all")
 	exit(0)
 
+def check_boolean(value):
+	if    value == "" \
+	   or value == "1" \
+	   or value == "true" \
+	   or value == "True" \
+	   or value == True:
+		return True
+	return False
+
 # preparse the argument to get the verbose element for debug mode
 def parseGenericArg(argument, active):
 	debug.extreme_verbose("parse arg : " + argument.get_option_name() + " " + argument.get_arg() + " active=" + str(active))
@@ -200,48 +211,42 @@ def parseGenericArg(argument, active):
 		return True
 	elif argument.get_option_name() == "color":
 		if active==True:
-			if    argument.get_arg() == "" \
-			   or argument.get_arg() == "1" \
-			   or argument.get_arg() == "true" \
-			   or argument.get_arg() == "True" \
-			   or argument.get_arg() == True:
+			if check_boolean(argument.get_arg()) == True:
 				debug.enable_color()
 			else:
 				debug.disable_color()
 		return True
 	elif argument.get_option_name() == "force-build":
 		if active==True:
-			env.set_force_mode(True)
+			if check_boolean(argument.get_arg()) == True:
+				env.set_force_mode(True)
+			else:
+				env.set_force_mode(False)
 		return True
 	elif argument.get_option_name() == "pretty":
 		if active==True:
-			if    argument.get_arg() == "" \
-			   or argument.get_arg() == "1" \
-			   or argument.get_arg() == "true" \
-			   or argument.get_arg() == "True" \
-			   or argument.get_arg() == True:
+			if check_boolean(argument.get_arg()) == True:
 				env.set_print_pretty_mode(True)
 			else:
 				env.set_print_pretty_mode(False)
 		return True
+	elif argument.get_option_name() == "force-optimisation":
+		if active==True:
+			if check_boolean(argument.get_arg()) == True:
+				env.set_force_optimisation(True)
+			else:
+				env.set_force_optimisation(False)
+		return True
 	elif argument.get_option_name() == "force-strip":
 		if active==True:
-			if    argument.get_arg() == "" \
-			   or argument.get_arg() == "1" \
-			   or argument.get_arg() == "true" \
-			   or argument.get_arg() == "True" \
-			   or argument.get_arg() == True:
+			if check_boolean(argument.get_arg()) == True:
 				env.set_force_strip_mode(True)
 			else:
 				env.set_force_strip_mode(False)
 		return True
 	elif argument.get_option_name() == "warning":
 		if active==True:
-			if    argument.get_arg() == "" \
-			   or argument.get_arg() == "1" \
-			   or argument.get_arg() == "true" \
-			   or argument.get_arg() == "True" \
-			   or argument.get_arg() == True:
+			if check_boolean(argument.get_arg()) == True:
 				env.set_warning_mode(True)
 			else:
 				env.set_warning_mode(False)
@@ -357,14 +362,34 @@ for argument in localArgument:
 			#remove previous target
 			my_target = None
 	else:
+		argument_value = argument.get_arg()
+		debug.debug("something request : '" + argument_value + "'")
 		if argument.get_option_name() != "":
 			debug.warning("Can not understand argument : '" + argument.get_option_name() + "'")
 			usage()
+			break;
+		name2 = argument_value.replace("@", "?")
+		gettedElement = name2.split("?")
+		module_name = gettedElement[0]
+		action_list = gettedElement[1:]
+		if len(action_list) == 0:
+			action_list = "build"
+		debug.debug("requested: '" + module_name + "' ? actions:'" + str(action_list) + "'")
+		multiple_module_list = []
+		if module_name[-1] == "*":
+			base_name = module_name[:-1]
+			for mod in module.list_all_module():
+				if mod[:len(base_name)] == base_name:
+					debug.verbose("need do it for: " + mod);
+					multiple_module_list.append(mod)
 		else:
+			multiple_module_list.append(module_name)
+		debug.debug("Will do: '" + str(multiple_module_list) + "' ? actions:'" + str(action_list) + "'")
+		for module_name in multiple_module_list:
 			#load the target if needed :
 			if my_target == None:
-				my_target = target.load_target(targetName, config)
-			my_target.build(argument.get_arg())
+				my_target = target.load_target(targetName, copy.deepcopy(config))
+			my_target.build(module_name, actions=action_list)
 			actionDone=True
 
 # if no action done : we do "all" ...

lutin/__init__.py

@@ -71,8 +71,26 @@ def import_path_local(path, limit_sub_folder, exclude_path = [], base_name = "")
 	# check if the file "lutin_parse_sub.py" is present ==> parse SubFolder (force and add +1 in the resursing
 	if base_name + "ParseSubFolders.txt" in list_files:
 		debug.debug("find SubParser ... " + str(base_name + "ParseSubFolders.txt") + " " + path)
-		need_parse_sub_folder = True
-		rm_value = 0
+		data_file_sub = tools.file_read_data(os.path.join(path, base_name + "ParseSubFolders.txt"))
+		if data_file_sub == "":
+			debug.debug("    Empty file Load all subfolder in the worktree in '" + str(path) + "'")
+			need_parse_sub_folder = True
+			rm_value = 0
+		else:
+			list_sub = data_file_sub.split("\n")
+			debug.debug("    Parse selected folders " + str(list_sub) + " no parse local folder directory")
+			need_parse_sub_folder = False
+			for folder in list_sub:
+				if    folder == "" \
+				   or folder == "/":
+					continue;
+				tmp_out = import_path_local(os.path.join(path, folder),
+				                            1,
+				                            exclude_path,
+				                            base_name)
+				# add all the elements:
+				for elem in tmp_out:
+					out.append(elem)
 	if need_parse_sub_folder == True:
 		list_folders = filter_path(path, list_files)
 		for folder in list_folders:

lutin/env.py

@@ -26,6 +26,19 @@ def get_force_mode():
 	global force_mode
 	return force_mode
 
+force_optimisation=False
+
+def set_force_optimisation(val):
+	global force_optimisation
+	if val==1:
+		force_optimisation = 1
+	else:
+		force_optimisation = 0
+
+def get_force_optimisation():
+	global force_optimisation
+	return force_optimisation
+
 parse_depth = 9999999
 
 def set_parse_depth(val):
@@ -116,6 +129,19 @@ def print_pretty(my_string, force=False):
 			    "-classpath",
 			    "-sourcepath"
 			    ]
+		elif end_with(cmdApplication, ["java"]) == True:
+			baseElementList = [
+			    "-z",
+			    "-f",
+			    "-rf"
+			    ]
+		elif end_with(cmdApplication, ["jarsigner"]) == True:
+			baseElementList = [
+			    "-sigalg",
+			    "-digestalg",
+			    "-storepass",
+			    "-keypass"
+			    ]
 		elif end_with(cmdApplication, ["jar"]) == True:
 			baseElementList = [
 			    "cf",

lutin/module.py

@@ -10,6 +10,7 @@
 
 import sys
 import os
+import copy
 import inspect
 import fnmatch
 # Local import
@@ -104,7 +105,8 @@ class Module:
 		                      "ANDROID_WALLPAPER_PROPERTIES" : [], # To create properties of the wallpaper (no use of EWOL display)
 		                      "RIGHT" : [],
 		                      "LICENSE" : "", # by default: no license
-		                      "ADMOD_POSITION" : "top"
+		                      "ADMOD_POSITION" : "top",
+		                      "ANDROID_SIGN" : "no_file.jks"
 		                     }
 		self.package_prop_default = { "COMPAGNY_TYPE" : True,
 		                              "COMPAGNY_NAME" : True,
@@ -123,7 +125,8 @@ class Module:
 		                              "ANDROID_WALLPAPER_PROPERTIES" : True,
 		                              "RIGHT" : True,
 		                              "LICENSE" : True,
-		                              "ADMOD_POSITION" : True
+		                              "ADMOD_POSITION" : True,
+		                              "ANDROID_SIGN" : True
 		                            }
 		self.sub_heritage_list = None
 	
@@ -315,7 +318,8 @@ class Module:
 					debug.verbose("    REMOVE: '" + str(elem[6:len(self.origin_path)+1]) + "' not in " + str(gcov_path_file))
 					continue
 				continue
-			if elem[:7] == "Aucune ":
+			if    elem[:7] == "Aucune " \
+			   or elem[:19] == "No executable lines":
 				debug.verbose("    Nothing to execute");
 				continue
 			start_with = ["Lines executed:", "Lignes exécutées:"]
@@ -323,8 +327,9 @@ class Module:
 			for line_base in start_with:
 				if elem[:len(line_base)] == line_base:
 					find = True
-					elem = elem[len(line_base)+1:]
+					elem = elem[len(line_base):]
 					break;
+			debug.verbose(" temp Value: " + str(elem))
 			if find == False:
 				debug.warning("    gcov ret : " + str(elem));
 				debug.warning("         ==> does not start with : " + str(start_with));
@@ -371,6 +376,7 @@ class Module:
 				debug.info("   %  " + str(elem[1]) + "\r\t\t" + str(elem[0]));
 			else:
 				debug.info("   % " + str(elem[1]) + "\r\t\t" + str(elem[0]));
+			debug.verbose("       " + str(elem[2]) + " / " + str(elem[3]));
 		try:
 			pourcent = 100.0*float(executed_lines)/float(executable_lines)
 		except ZeroDivisionError:
@@ -410,7 +416,8 @@ class Module:
 		if target.is_module_build(self.name) == True:
 			if self.sub_heritage_list == None:
 				self.local_heritage = heritage.heritage(self, target)
-			return self.sub_heritage_list
+				debug.warning("plop " + str(self.local_heritage));
+			return copy.deepcopy(self.sub_heritage_list)
 		# create the package heritage
 		self.local_heritage = heritage.heritage(self, target)
 		
@@ -545,6 +552,7 @@ class Module:
 					debug.warning(" UN-SUPPORTED file format:  '" + self.origin_path + "/" + file + "'")
 			# when multiprocess availlable, we need to synchronize here ...
 			multiprocess.pool_synchrosize()
+		
 		# ----------------------------------------------------
 		# -- Generation point                               --
 		# ----------------------------------------------------
@@ -758,13 +766,14 @@ class Module:
 					target.make_package(self.name, self.package_prop, os.path.join(self.origin_path, ".."), self.sub_heritage_list)
 		
 		# return local dependency ...
-		return self.sub_heritage_list
+		return copy.deepcopy(self.sub_heritage_list)
 	
 	# call here to clean the module
 	def clean(self, target):
 		if self.type=='PREBUILD':
 			# nothing to add ==> just dependence
 			None
+			return True
 		elif    self.type=='LIBRARY' \
 		     or self.type=='LIBRARY_DYNAMIC' \
 		     or self.type=='LIBRARY_STATIC':
@@ -772,6 +781,7 @@ class Module:
 			pathbuild = target.get_build_path(self.name)
 			debug.info("remove path : '" + pathbuild + "'")
 			tools.remove_path_and_sub_path(pathbuild)
+			return True
 		elif    self.type=='BINARY' \
 		     or self.type=='PACKAGE':
 			# remove path of the lib ... for this targer
@@ -781,6 +791,7 @@ class Module:
 			pathStaging = target.get_staging_path(self.name)
 			debug.info("remove path : '" + pathStaging + "'")
 			tools.remove_path_and_sub_path(pathStaging)
+			return True
 		else:
 			debug.error("Dit not know the element type ... (impossible case) type=" + self.type)
 	
@@ -881,7 +892,7 @@ class Module:
 			print('        ' + str(description))
 			print('            ' + str(input_list))
 	
-	def display(self, target):
+	def display(self):
 		print('-----------------------------------------------')
 		print(' package : "' + self.name + "'")
 		print('-----------------------------------------------')
@@ -905,12 +916,13 @@ class Module:
 		self.print_list('paths',self.paths)
 		for element in self.path["local"]:
 			value = self.path["local"][element]
-			self.print_list('local path ' + str(element), value)
+			self.print_list('local path "' + str(element) + '" ' + str(len(value)), value)
 		
 		for element in self.path["export"]:
 			value = self.path["export"][element]
-			self.print_list('export path ' + str(element), value)
+			self.print_list('export path "' + str(element) + '" ' + str(len(value)), value)
 		
+		return True
 	
 	def pkg_set(self, variable, value):
 		if "COMPAGNY_TYPE" == variable:
@@ -974,7 +986,8 @@ class Module:
 		                  "ANDROID_APPL_TYPE",
 		                  "ADMOD_ID",
 		                  "APPLE_APPLICATION_IOS_ID",
-		                  "LICENSE"]:
+		                  "LICENSE",
+		                  "ANDROID_SIGN"]:
 			self.package_prop[variable] = value
 			self.package_prop_default[variable] = False
 		elif "ADMOD_POSITION" == variable:

lutin/target.py

@@ -45,6 +45,7 @@ class Target:
 		# todo : remove this :
 		self.sumulator = config["simulation"]
 		self.name = name
+		self.config_based_on = name
 		self.end_generate_package = config["generate-package"]
 		debug.info("=================================");
 		debug.info("== Target='" + self.name + "' " + config["bus-size"] + " bits for arch '" + config["arch"] + "'");
@@ -106,9 +107,12 @@ class Target:
 		if "debug" == self.config["mode"]:
 			self.add_flag("c", [
 			    "-g",
-			    "-DDEBUG",
-			    "-O0"
+			    "-DDEBUG"
 			    ])
+			if env.get_force_optimisation() == False:
+				self.add_flag("c", "-O0")
+			else:
+				self.add_flag("c", "-O3")
 		else:
 			self.add_flag("c", [
 			    "-DNDEBUG",
@@ -117,14 +121,22 @@ class Target:
 		
 		## To add code coverate on build result system
 		if self.config["gcov"] == True:
-			self.add_flag("c", [
-			    "-fprofile-arcs",
-			    "-ftest-coverage"
-			    ])
-			self.add_flag("link", [
-			    "-lgcov",
-			    "--coverage"
-			    ])
+			if self.config["compilator"] == "clang":
+				self.add_flag("c", [
+				    "--coverage"
+				    ])
+				self.add_flag("link", [
+				    "--coverage"
+				    ])
+			else:
+				self.add_flag("c", [
+				    "-fprofile-arcs",
+				    "-ftest-coverage"
+				    ])
+				self.add_flag("link", [
+				    "-lgcov",
+				    "--coverage"
+				    ])
 		
 		self.update_path_tree()
 		self.path_bin="bin"
@@ -461,7 +473,17 @@ class Target:
 				mod.ext_project_add_module(self, projectMng, addedModule)
 				return
 	
-	def build(self, name, packagesName=None, optionnal=False):
+	
+	def build(self, name, packagesName=None, optionnal=False, actions=[]):
+		if    len(name.split("?")) != 1\
+		   or len(name.split("@")) != 1:
+			debug.error("need update")
+		if actions == "":
+			actions = ["build"]
+		if actions == []:
+			actions = ["build"]
+		if type(actions) == str:
+			actions = [actions]
 		if name == "gcov":
 			debug.info("gcov all")
 			debug.error("must set the gcov parsing on a specific library or binary ==> not supported now for all")
@@ -469,7 +491,7 @@ class Target:
 			debug.info("dump all")
 			self.load_all()
 			for mod in self.module_list:
-				mod.display(self)
+				mod.display()
 			return
 		if name == "all":
 			debug.info("build all")
@@ -488,14 +510,8 @@ class Target:
 			for mod in self.module_list:
 				mod.clean(self)
 		else:
-			# get the action an the module ....
-			name2 = name.replace("@", "?")
-			gettedElement = name2.split("?")
-			module_name = gettedElement[0]
-			action_list = gettedElement[1:]
-			if len(action_list) == 0:
-				action_list = ["build"]
-			debug.verbose("requested : " + module_name + " ? actions:" + str(action_list))
+			module_name = name
+			action_list = actions
 			for action_name in action_list:
 				debug.verbose("requested : " + module_name + "?" + action_name + " [START]")
 				ret = None;
@@ -539,14 +555,13 @@ class Target:
 					   and optionnal == True:
 						ret = [heritage.HeritageList(), False]
 					else:
-						# clean requested
 						for mod in self.module_list:
 							if mod.name == module_name:
 								if action_name[:4] == "dump":
 									debug.info("dump module '" + module_name + "'")
 									if len(action_name) > 4:
 										debug.warning("action 'dump' does not support options ... : '" + action_name + "'")
-									ret = mod.display(self)
+									ret = mod.display()
 									break
 								elif action_name[:5] == "clean":
 									debug.info("clean module '" + module_name + "'")
@@ -635,6 +650,8 @@ class Target:
 	## @param[in] pkg_name Package Name (generic name)
 	## @param[in] heritage_list List of dependency of the package
 	## @param[in] static The package is build in static mode
+	## @return True Something has been copied
+	## @return False Nothing has been copied
 	##
 	def make_package_binary_data(self, path_package, pkg_name, base_pkg_path, heritage_list, static):
 		target_shared_path = os.path.join(path_package, self.pkg_path_data)
@@ -668,9 +685,10 @@ class Target:
 					                    force_identical=True,
 					                    in_list=copy_list)
 		#real copy files
-		tools.copy_list(copy_list)
+		ret_copy = tools.copy_list(copy_list)
 		# remove unneded files (NOT folder ...)
-		tools.clean_directory(target_shared_path, copy_list)
+		ret_remove = tools.clean_directory(target_shared_path, copy_list)
+		return ret_copy or ret_remove
 	
 	##
 	## @brief Create a generic tree of the binary folder
@@ -678,6 +696,8 @@ class Target:
 	## @param[in] pkg_name Package Name (generic name)
 	## @param[in] heritage_list List of dependency of the package
 	## @param[in] static The package is build in static mode
+	## @return True Something has been copied
+	## @return False Nothing has been copied
 	##
 	def make_package_binary_bin(self, path_package, pkg_name, base_pkg_path, heritage_list, static):
 		copy_list={}
@@ -690,10 +710,12 @@ class Target:
 		                path_dst,
 		                in_list=copy_list)
 		#real copy files
-		tools.copy_list(copy_list)
+		ret_copy = tools.copy_list(copy_list)
+		ret_remove = False
 		if self.pkg_path_bin != "":
 			# remove unneded files (NOT folder ...)
-			tools.clean_directory(path_package_bin, copy_list)
+			ret_remove = tools.clean_directory(path_package_bin, copy_list)
+		return ret_copy or ret_remove
 	
 	##
 	## @brief Create a generic tree of the library folder
@@ -701,6 +723,8 @@ class Target:
 	## @param[in] pkg_name Package Name (generic name)
 	## @param[in] heritage_list List of dependency of the package
 	## @param[in] static The package is build in static mode
+	## @return True Something has been copied
+	## @return False Nothing has been copied
 	##
 	def make_package_binary_lib(self, path_package, pkg_name, base_pkg_path, heritage_list, static):
 		copy_list={}
@@ -721,46 +745,49 @@ class Target:
 					                os.path.join(path_package_lib, os.path.basename(file_src)),
 					                in_list=copy_list)
 		#real copy files
-		tools.copy_list(copy_list)
+		ret_copy = tools.copy_list(copy_list)
+		ret_remove = False
 		if self.pkg_path_lib != "":
 			# remove unneded files (NOT folder ...)
-			tools.clean_directory(path_package_lib, copy_list)
+			ret_remove = tools.clean_directory(path_package_lib, copy_list)
+		return ret_copy or ret_remove
 	
 	
 	def make_package_generic_files(self, path_package, pkg_properties, pkg_name, base_pkg_path, heritage_list, static):
 		## Create version file:
-		tools.file_write_data(os.path.join(path_package, self.pkg_path_version_file),
-		                      tools.version_to_string(pkg_properties["VERSION"]),
-		                      only_if_new=True)
+		ret_version = tools.file_write_data(os.path.join(path_package, self.pkg_path_version_file),
+		                                    tools.version_to_string(pkg_properties["VERSION"]),
+		                                    only_if_new=True)
 		
 		## Create maintainer file:
-		tools.file_write_data(os.path.join(path_package, self.pkg_path_maintainer_file),
-		                      self.generate_list_separate_coma(pkg_properties["MAINTAINER"]),
-		                      only_if_new=True)
+		ret_maintainer = tools.file_write_data(os.path.join(path_package, self.pkg_path_maintainer_file),
+		                                       self.generate_list_separate_coma(pkg_properties["MAINTAINER"]),
+		                                       only_if_new=True)
 		
 		## Create appl_name file:
-		tools.file_write_data(os.path.join(path_package, self.pkg_path_application_name_file),
-		                      "en_EN:" + pkg_properties["NAME"],
-		                      only_if_new=True)
+		ret_appl_name = tools.file_write_data(os.path.join(path_package, self.pkg_path_application_name_file),
+		                                      "en_EN:" + pkg_properties["NAME"],
+		                                      only_if_new=True)
 		
 		## Create appl_description file:
-		tools.file_write_data(os.path.join(path_package, self.pkg_path_application_description_file),
-		                      "en_EN:" + pkg_properties["DESCRIPTION"],
-		                      only_if_new=True)
+		ret_appl_desc = tools.file_write_data(os.path.join(path_package, self.pkg_path_application_description_file),
+		                                      "en_EN:" + pkg_properties["DESCRIPTION"],
+		                                      only_if_new=True)
 		
 		## Create Readme file:
 		readme_file_dest = os.path.join(path_package, self.pkg_path_readme_file)
+		ret_readme = False
 		if os.path.exists(os.path.join(base_pkg_path, "os-Linux/README"))==True:
-			tools.copy_file(os.path.join(base_pkg_path, "os-Linux/README"), readme_file_dest)
+			ret_readme = tools.copy_file(os.path.join(base_pkg_path, "os-Linux/README"), readme_file_dest)
 		elif os.path.exists(os.path.join(base_pkg_path, "README"))==True:
-			tools.copy_file(os.path.join(base_pkg_path, "README"), readme_file_dest)
+			ret_readme = tools.copy_file(os.path.join(base_pkg_path, "README"), readme_file_dest)
 		elif os.path.exists(os.path.join(base_pkg_path, "README.md"))==True:
-			tools.copy_file(os.path.join(base_pkg_path, "README.md"), readme_file_dest)
+			ret_readme = tools.copy_file(os.path.join(base_pkg_path, "README.md"), readme_file_dest)
 		else:
 			debug.debug("no file 'README', 'README.md' or 'os-Linux/README' ==> generate an empty one")
-			tools.file_write_data(readme_file_dest,
-			                      "No documentation for " + pkg_name + "\n",
-			                      only_if_new=True)
+			ret_readme = tools.file_write_data(readme_file_dest,
+			                                   "No documentation for " + pkg_name + "\n",
+			                                   only_if_new=True)
 		
 		## Create licence file:
 		"""
@@ -779,13 +806,20 @@ class Target:
 		
 		## Create changeLog file:
 		change_log_file_dest = os.path.join(path_package, self.pkg_path_change_log_file)
+		ret_changelog = False
 		if os.path.exists(os.path.join(base_pkg_path, "changelog")) == True:
-			tools.copy_file(os.path.join(base_pkg_path, "changelog"), change_log_file_dest)
+			ret_changelog = tools.copy_file(os.path.join(base_pkg_path, "changelog"), change_log_file_dest)
 		else:
 			debug.debug("no file 'changelog' ==> generate an empty one")
-			tools.file_write_data(change_log_file_dest,
-			                      "No changelog data " + pkg_name + "\n",
-			                      only_if_new=True)
+			ret_changelog = tools.file_write_data(change_log_file_dest,
+			                                      "No changelog data " + pkg_name + "\n",
+			                                      only_if_new=True)
+		return    ret_version \
+		       or ret_maintainer \
+		       or ret_appl_name \
+		       or ret_appl_desc \
+		       or ret_readme \
+		       or ret_changelog
 	
 	##
 	## @brief convert a s list of string in a string separated by a ","

lutin/tools.py

@@ -87,17 +87,20 @@ def version_to_string(version):
 ## @param[in] path Path of the data might be written.
 ## @param[in] data Data To write in the file.
 ## @param[in] only_if_new (default: False) Write data only if data is different.
+## @return True Something has been copied
+## @return False Nothing has been copied
 ##
 def file_write_data(path, data, only_if_new=False):
 	if only_if_new == True:
 		old_data = file_read_data(path)
 		if old_data == data:
-			return
+			return False
 	#real write of data:
 	create_directory_of_file(path)
 	file = open(path, "w")
 	file.write(data)
 	file.close()
+	return True
 
 def list_to_str(list):
 	if type(list) == type(str()):
@@ -131,6 +134,8 @@ def add_prefix(prefix,list):
 ## @param[in] force (default False) Force copy of the file
 ## @param[in] force_identical (default False) Force file to be identical (read it in binary)
 ## @param[in,out] in_list (default None) Not real copy: set the request copy in the input list
+## @return True Something has/must been copied
+## @return False Nothing has/myst been copied
 ##
 def copy_file(src, dst, cmd_file=None, force=False, force_identical=False, in_list=None):
 	if os.path.exists(src) == False:
@@ -138,7 +143,7 @@ def copy_file(src, dst, cmd_file=None, force=False, force_identical=False, in_li
 	cmd_line = "copy \"" + src + "\" \"" + dst + "\""
 	if     force == False \
 	   and depend.need_re_build(dst, src, file_cmd=cmd_file , cmd_line=cmd_line, force_identical=force_identical) == False:
-		debug.verbose ("no need to copy ...")
+		debug.verbose("no need to copy ...")
 		if in_list != None:
 			if dst in in_list:
 				debug.verbose("replace copy file " + os.path.relpath(src) + " ==> " + os.path.relpath(dst))
@@ -148,7 +153,7 @@ def copy_file(src, dst, cmd_file=None, force=False, force_identical=False, in_li
 			in_list[dst] = {"src":src,
 			                "cmd_file":cmd_file,
 			                "need_copy":False}
-		return
+		return False
 	if in_list == None:
 		debug.print_element("copy file ", os.path.relpath(src), "==>", os.path.relpath(dst))
 		create_directory_of_file(dst)
@@ -163,6 +168,7 @@ def copy_file(src, dst, cmd_file=None, force=False, force_identical=False, in_li
 		in_list[dst] = {"src":src,
 		                "cmd_file":cmd_file,
 		                "need_copy":True}
+	return True
 
 ##
 ## @brief Copy a compleate directory in a specific folder
@@ -210,20 +216,28 @@ def copy_anything(src, dst, recursive = False, force_identical=False, in_list=No
 ##
 ## @brief real copy of files in a specific dictionnary list
 ## @param[in] in_list Dictionnary of file to copy
+## @return True Something has been copied
+## @return False Nothing has been copied
 ##
 def copy_list(in_list):
+	has_file_copied = False
 	for dst in in_list:
 		if in_list[dst]["need_copy"] == False:
 			continue
 		# note we force the copy to disable the check of needed of copy (already done)
 		copy_file(in_list[dst]["src"], dst, cmd_file=in_list[dst]["cmd_file"], force=True)
+		has_file_copied = True
+	return has_file_copied
 
 ##
 ## @brief Clean a path from all un-needed element in a directory
 ## @param[in] path Path to clean
 ## @param[in] normal_list List of all files/path in the path
+## @return True Something has been removed
+## @return False Nothing has been removed
 ##
 def clean_directory(path, normal_list):
+	has_file_removed = False
 	# get a list of all element in the path:
 	for root, dirnames, filenames in os.walk(path):
 		for file in filenames:
@@ -231,6 +245,8 @@ def clean_directory(path, normal_list):
 			if file_name not in normal_list:
 				debug.print_element("remove file ", os.path.relpath(file_name), "==>", "---")
 				os.remove(file_name)
+				has_file_removed = True
+	return has_file_removed
 
 def filter_extention(list_files, extentions, invert=False):
 	out = []

lutin/z_builder/lutinBuilder_libraryDynamic.py

@@ -99,6 +99,10 @@ def link(file, binary, target, depancy, flags, name, basic_path, static=False):
 		cmd.append(file_src)
 	except:
 		pass
+	try:
+		cmd.append(list_static)
+	except:
+		pass
 	for view in ["local", "export"]:
 		if view not in flags:
 			continue
@@ -113,10 +117,6 @@ def link(file, binary, target, depancy, flags, name, basic_path, static=False):
 			cmd.append(target.global_flags[type])
 	if 'src' in depancy.src:
 		cmd.append(tools.filter_extention(depancy.src['src'], get_input_type()))
-	try:
-		cmd.append(list_static)
-	except:
-		pass
 	try:
 		for elem in list_dynamic:
 			lib_path = os.path.dirname(elem)

lutin/z_system/lutinSystem_Android_cxx.py

@@ -48,6 +48,7 @@ class System(system.System):
 		else:
 			self.add_export_flag("c++", "-D__STDCPP_GNU__")
 			self.add_export_flag("c++-remove","-nostdlib")
+			self.add_export_flag("need-libstdc++", True)
 			# GPL v3 (+ exception link for gcc compilator)
 			self.add_export_path(os.path.join(target.path_ndk, "sources", "cxx-stl", "gnu-libstdc++", target.compilator_version, "include"))
 			if target.type_arch == "armv5":

lutin/z_system/lutinSystem_Android_z.py

@@ -0,0 +1,28 @@
+#!/usr/bin/python
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+
+from lutin import debug
+from lutin import system
+from lutin import tools
+import os
+
+class System(system.System):
+	def __init__(self, target):
+		system.System.__init__(self)
+		# create some HELP:
+		self.help="Z : z library \n Can be install with the package:\n    - zlib1g-dev"
+		# check if the library exist:
+		if not os.path.isfile("/usr/include/zlib.h"):
+			# we did not find the library reqiested (just return) (automaticly set at false)
+			return;
+		self.valid = True
+		# todo : create a searcher of the presence of the library:
+		self.add_export_flag("link-lib", "z")
+
+

lutin/z_target/lutinTarget_Android.py

@@ -467,7 +467,7 @@ class Target(target.Target):
 			print("On release mode we need the file :  and key an pasword to sign the application ...")
 			debug.print_element("pkg", ".apk(signed debug)", "<==", ".apk (not signed)")
 			cmdLine = "jarsigner " \
-			    + " -keystore " + base_pkg_path + "/AndroidKey.jks " \
+			    + " -keystore " + pkg_properties["ANDROID_SIGN"] + " " \
 			    + " -sigalg SHA1withRSA -digestalg SHA1 " \
 			    + target_outpath + "/build/" + pkg_name_application_name + "-unalligned.apk " \
 			    + " " + pkg_name_application_name

lutin/z_target/lutinTarget_Linux.py

@@ -74,30 +74,34 @@ class Target(target.Target):
 	"""
 	def make_package_binary(self, pkg_name, pkg_properties, base_pkg_path, heritage_list, static):
 		debug.debug("------------------------------------------------------------------------")
-		debug.info("-- Generate generic '" + pkg_name + "' v" + tools.version_to_string(pkg_properties["VERSION"]))
+		debug.debug("-- Generate generic '" + pkg_name + "' v" + tools.version_to_string(pkg_properties["VERSION"]))
 		debug.debug("------------------------------------------------------------------------")
 		#output path
 		target_outpath = os.path.join(self.get_staging_path(pkg_name), pkg_name + ".app")
 		tools.create_directory_of_file(target_outpath)
 		
 		## Create share datas:
-		self.make_package_binary_data(target_outpath, pkg_name, base_pkg_path, heritage_list, static)
+		ret_share = self.make_package_binary_data(target_outpath, pkg_name, base_pkg_path, heritage_list, static)
 		
 		## copy binary files:
-		self.make_package_binary_bin(target_outpath, pkg_name, base_pkg_path, heritage_list, static)
+		ret_bin = self.make_package_binary_bin(target_outpath, pkg_name, base_pkg_path, heritage_list, static)
 		
 		## Create libraries:
-		self.make_package_binary_lib(target_outpath, pkg_name, base_pkg_path, heritage_list, static)
+		ret_lib = self.make_package_binary_lib(target_outpath, pkg_name, base_pkg_path, heritage_list, static)
 		
 		## Create generic files:
-		self.make_package_generic_files(target_outpath, pkg_properties, pkg_name, base_pkg_path, heritage_list, static)
+		ret_file = self.make_package_generic_files(target_outpath, pkg_properties, pkg_name, base_pkg_path, heritage_list, static)
 		
 		## create the package:
-		debug.debug("package : " + os.path.join(self.get_staging_path(pkg_name), pkg_name + ".app.pkg"))
-		os.system("cd " + self.get_staging_path(pkg_name) + " ; tar -czf " + pkg_name + ".app.tar.gz " + pkg_name + ".app")
-		#multiprocess.run_command("cd " + self.get_staging_path(pkg_name) + " ; tar -czf " + pkg_name + ".app.tar.gz " + pkg_name + ".app")
-		tools.create_directory_of_file(self.get_final_path())
-		tools.copy_file(os.path.join(self.get_staging_path(pkg_name), pkg_name + ".app.tar.gz"), os.path.join(self.get_final_path(), pkg_name + ".app.gpkg"))
+		if    ret_share \
+		   or ret_bin \
+		   or ret_lib \
+		   or ret_file:
+			debug.debug("package : " + os.path.join(self.get_staging_path(pkg_name), pkg_name + ".app.pkg"))
+			os.system("cd " + self.get_staging_path(pkg_name) + " ; tar -czf " + pkg_name + ".app.tar.gz " + pkg_name + ".app")
+			#multiprocess.run_command("cd " + self.get_staging_path(pkg_name) + " ; tar -czf " + pkg_name + ".app.tar.gz " + pkg_name + ".app")
+			tools.create_directory_of_file(self.get_final_path())
+			tools.copy_file(os.path.join(self.get_staging_path(pkg_name), pkg_name + ".app.tar.gz"), os.path.join(self.get_final_path(), pkg_name + ".app.gpkg"))
 	
 	def install_package(self, pkg_name):
 		debug.debug("------------------------------------------------------------------------")

lutin/z_target/lutinTarget_Windows.py

@@ -63,24 +63,30 @@ class Target(target.Target):
 	
 	def make_package_binary(self, pkg_name, pkg_properties, base_pkg_path, heritage_list, static):
 		debug.debug("------------------------------------------------------------------------")
-		debug.info("Generate package '" + pkg_name + "' v" + tools.version_to_string(pkg_properties["VERSION"]))
+		debug.debug("Generate package '" + pkg_name + "' v" + tools.version_to_string(pkg_properties["VERSION"]))
 		debug.debug("------------------------------------------------------------------------")
 		#output path
 		target_outpath = os.path.join(self.get_staging_path(pkg_name), pkg_name + ".app")
 		tools.create_directory_of_file(target_outpath)
 		
 		## Create share datas:
-		self.make_package_binary_data(target_outpath, pkg_name, base_pkg_path, heritage_list, static)
+		ret_share = self.make_package_binary_data(target_outpath, pkg_name, base_pkg_path, heritage_list, static)
 		
 		## copy binary files:
-		self.make_package_binary_bin(target_outpath, pkg_name, base_pkg_path, heritage_list, static)
+		ret_bin = self.make_package_binary_bin(target_outpath, pkg_name, base_pkg_path, heritage_list, static)
 		
 		## Create libraries:
-		self.make_package_binary_lib(target_outpath, pkg_name, base_pkg_path, heritage_list, static)
+		ret_lib = self.make_package_binary_lib(target_outpath, pkg_name, base_pkg_path, heritage_list, static)
 		
 		## Create generic files:
-		self.make_package_generic_files(target_outpath, pkg_properties, pkg_name, base_pkg_path, heritage_list, static)
+		ret_file = self.make_package_generic_files(target_outpath, pkg_properties, pkg_name, base_pkg_path, heritage_list, static)
 		
+		## create the package:
+		if    ret_share \
+		   or ret_bin \
+		   or ret_lib \
+		   or ret_file:
+			debug.info("TODO: create a windows pkg ...")
 	
 	def make_package_single_file(self, pkg_name, pkg_properties, base_pkg_path, heritage_list):
 		debug.debug("------------------------------------------------------------------------")

setup.py

@@ -16,7 +16,7 @@ def readme():
 
 # https://pypi.python.org/pypi?%3Aaction=list_classifiers
 setup(name='lutin',
-      version='1.2.1',
+      version='1.2.3',
       description='Lutin generic builder (might replace makefile, CMake ...)',
       long_description=readme(),
       url='http://github.com/HeeroYui/lutin',