[RELEASE] new version 1.2.6

now libc header is install in a specific directory
lib c++ header is install in a specific directory
idem for pthread, X11, openGL, m, ...

.travis.yml

@@ -0,0 +1,69 @@
+#language: python
+
+sudo: false
+
+branches:
+  only:
+    - master
+    - dev
+
+addons:
+  apt:
+    sources:
+      - ubuntu-toolchain-r-test
+    packages:
+      - g++-4.9
+      - expect
+      - binutils-mingw-w64-i686 # 32bit MinGW
+      - gcc-mingw-w64-i686
+      - g++-mingw-w64-i686
+      - binutils-mingw-w64-x86-64 # 64bit MinGW
+      - gcc-mingw-w64-x86-64
+      - g++-mingw-w64-x86-64
+
+matrix:
+  include:
+    - os: linux
+      env: CONF=release BUILDER=gcc TARGET=Linux TAG=Linux
+      compiler: gcc
+    - os: linux
+      env: CONF=debug BUILDER=clang TARGET=Linux
+      compiler: clang
+    - os: linux
+      env: CONF=release BUILDER=gcc TARGET=Windows TAG=Mingw
+      compiler: gcc
+    - os: linux
+      env: CONF=release BUILDER=gcc TARGET=Android TAG=Android DISABLE_PACKAGE=-p
+      compiler: gcc
+    - os: osx
+      env: CONF=release BUILDER=clang TARGET=MacOs TAG=MacOs
+      compiler: clang
+    - os: osx
+      env: CONF=release BUILDER=clang TARGET=IOs TAG=IOs
+      compiler: clang
+
+install:
+  - cd ..
+  # download NDK
+  - if [ "$TAG" == "Android" ]; then
+        git clone --depth 1 --branch master https://github.com/HeeroYui/android-download-tool;
+        ./android-download-tool/dl-android.sh;
+    fi
+  - git clone --depth 1 --branch master https://github.com/atria-soft/ci.git
+  - cd -
+
+before_script:
+  - ./setup.py build
+  - export PYTHONPATH=$PYTHONPATH:./lutin/build/lib.linux-x86_64-2.7/:./lutin/build/lib.linux-x86_64-2.7/lutin/:./lutin/build/lib:./lutin/build/lib/lutin/
+  - cd ..
+  - pwd
+  - ls -l *
+  - ./ci/build_send.py --tag=$TAG --status=START;
+
+script:
+  - ./lutin/build/scripts-2.7/lutin -w -j4 -C -P -t$TARGET -c $BUILDER $COMPILATOR_OPTION $BUS -m $CONF $GCOV $DISABLE_PACKAGE test-c; STATUS=$?
+  - ./ci/build_send.py --tag=$TAG --status="$STATUS";
+
+notifications:
+  email:
+    - yui.heero@gmail.com

README.rst

@@ -3,9 +3,52 @@ Lutin
 
 `lutin` is a generic builder and package maker is a FREE software tool.
 
+
 .. image:: https://badge.fury.io/py/lutin.png
     :target: https://pypi.python.org/pypi/lutin
 
+Release (master)
+----------------
+
+.. image:: https://travis-ci.org/HeeroYui/lutin.svg?branch=master
+    :target: https://travis-ci.org/HeeroYui/lutin
+
+
+.. image:: http://atria-soft.com/ci/build/HeeroYui/lutin.svg?branch=master&tag=Linux
+    :target: http://atria-soft.com/ci/HeeroYui/lutin
+.. image:: http://atria-soft.com/ci/build/HeeroYui/lutin.svg?branch=master&tag=MacOs
+    :target: http://atria-soft.com/ci/HeeroYui/lutin
+.. image:: http://atria-soft.com/ci/build/HeeroYui/lutin.svg?branch=master&tag=Mingw
+    :target: http://atria-soft.com/ci/HeeroYui/lutin
+
+
+.. image:: http://atria-soft.com/ci/build/HeeroYui/lutin.svg?branch=master&tag=Android
+    :target: http://atria-soft.com/ci/HeeroYui/lutin
+.. image:: http://atria-soft.com/ci/build/HeeroYui/lutin.svg?branch=master&tag=IOs
+    :target: http://atria-soft.com/ci/HeeroYui/lutin
+
+
+Developement (dev)
+------------------
+
+.. image:: https://travis-ci.org/HeeroYui/lutin.svg?branch=dev
+    :target: https://travis-ci.org/HeeroYui/lutin
+
+
+.. image:: http://atria-soft.com/ci/build/HeeroYui/lutin.svg?branch=dev&tag=Linux
+    :target: http://atria-soft.com/ci/HeeroYui/lutin
+.. image:: http://atria-soft.com/ci/build/HeeroYui/lutin.svg?branch=dev&tag=MacOs
+    :target: http://atria-soft.com/ci/HeeroYui/lutin
+.. image:: http://atria-soft.com/ci/build/HeeroYui/lutin.svg?branch=dev&tag=Mingw
+    :target: http://atria-soft.com/ci/HeeroYui/lutin
+
+
+.. image:: http://atria-soft.com/ci/build/HeeroYui/lutin.svg?branch=dev&tag=Android
+    :target: http://atria-soft.com/ci/HeeroYui/lutin
+.. image:: http://atria-soft.com/ci/build/HeeroYui/lutin.svg?branch=dev&tag=IOs
+    :target: http://atria-soft.com/ci/HeeroYui/lutin
+
+
 Instructions
 ------------
 

bin/lutin

@@ -1,4 +1,5 @@
 #!/usr/bin/python
+# -*- coding: utf-8 -*-
 ##
 ## @author Edouard DUPIN
 ##
@@ -10,6 +11,8 @@
 # for path inspection:
 import sys
 import os
+import copy
+import lutin
 import lutin.debug as debug
 import lutin.arg as arguments
 import lutin.host as host
@@ -17,6 +20,9 @@ import lutin.module as module
 import lutin.target as target
 import lutin.env as env
 import lutin.multiprocess as multiprocess
+import lutin.tools as tools
+import lutin.host as lutinHost
+import lutin.tools as lutinTools
 
 myArgs = arguments.LutinArg()
 myArgs.add(arguments.ArgDefine("h", "help", desc="Display this help"))
@@ -27,8 +33,11 @@ myArgs.add(arguments.ArgDefine("C", "color", desc="Display makefile output in co
 myArgs.add(arguments.ArgDefine("B", "force-build", desc="Force the rebuild without checking the dependency"))
 myArgs.add(arguments.ArgDefine("P", "pretty", desc="Print the debug has pretty display"))
 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(arguments.ArgDefine("i", "isolate-system", desc="Isolate system build (copy header of c and c++ system lib to not include unneeded external libs) EXPERIMENTAL (archlinux)"))
 
 myArgs.add_section("properties", "keep in the sequency of the cible")
 myArgs.add(arguments.ArgDefine("t", "target", haveParam=True, desc="Select a target (by default the platform is the computer that compile this) To know list : 'lutin.py --list-target'"))
@@ -66,7 +75,8 @@ def usage(full=False):
 	for mod in listOfAllModule:
 		data_print = "		"
 		if full == False:
-			if    mod["type"][:6] == "BINARY":
+			if     mod["type"] != None \
+			   and mod["type"][:6] == "BINARY":
 				data_print += color['blue']
 				if mod["sub-type"] == "":
 					data_print += "* "
@@ -78,9 +88,11 @@ def usage(full=False):
 					data_print += "S "
 				else:
 					data_print += "  "
-			elif mod["type"] == "PACKAGE":
+			elif     mod["type"] != None \
+			     and mod["type"] == "PACKAGE":
 				data_print += color['red'] + "# "
-			elif    mod["type"][:7] == "LIBRARY":
+			elif     mod["type"] != None \
+			     and mod["type"][:7] == "LIBRARY":
 				data_print += color['yellow'] + "  "
 			else:
 				data_print += color['default'] + "  "
@@ -89,9 +101,11 @@ def usage(full=False):
 		data_print += mod["name"] + color['default']
 		if full == False:
 			data_print += "\r\t\t\t\t\t\t\t"
-			if mod["license"] != "":
+			if     mod["license"] != None \
+			   and mod["license"] != "":
 				data_print += color['yellow'] + " [" + mod["license"] + "]" + color['default']
-			if mod["version"] != []:
+			if     mod["version"] != None \
+			   and mod["version"] != []:
 				version_ID = tools.version_to_string(mod["version"])
 				data_print += color['blue'] + " (" + version_ID + ")" + color['default']
 			"""
@@ -106,11 +120,14 @@ def usage(full=False):
 		if mod["description"] != "":
 			print("			" + mod["description"])
 		if full == True:
-			if mod["type"] != "":
+			if     mod["type"] != None \
+			   and mod["type"] != "":
 				print("				Type:     " + mod["type"])
-			if mod["sub-type"] != "":
+			if     mod["sub-type"] != None \
+			   and mod["sub-type"] != "":
 				print("				Sub-Type: " + mod["sub-type"])
-			if mod["version"] != []:
+			if     mod["version"] != None \
+			   and mod["version"] != []:
 				version_ID = ""
 				for id in mod["version"]:
 					if len(version_ID) != 0:
@@ -120,22 +137,37 @@ def usage(full=False):
 							version_ID+="."
 					version_ID += str(id)
 				print("				version:  " + color['blue'] + version_ID + color['default'])
-			if     mod["compagny-type"] != "" \
+			if     mod["compagny-type"] != None \
+			   and mod["compagny-name"] != None \
+			   and mod["compagny-type"] != "" \
 			   and mod["compagny-name"] != "":
 				print("				compagny: " + color['purple'] + mod["compagny-type"] + "/" + mod["compagny-name"] + color['default'])
-			elif mod["compagny-name"] != "":
+			elif     mod["compagny-name"] != None \
+			     and mod["compagny-name"] != "":
 				print("				compagny: " + color['purple'] + mod["compagny-name"] + color['default'])
-			if mod["license"] != "":
+			if     mod["license"] != None \
+			   and mod["license"] != "":
 				print("				license:  " + color['yellow'] + mod["license"] + color['default'])
-			if mod["maintainer"] != []:
+			if     mod["maintainer"] != None \
+			   and mod["maintainer"] != []:
 				print("				maintainers:")
 				for elem in mod["maintainer"]:
 					print("					" + str(elem))
 	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))
 	if argument.get_option_name() == "help":
 		if active==False:
 			usage()
@@ -170,42 +202,123 @@ def parseGenericArg(argument, active):
 		if active==True:
 			multiprocess.set_core_number(int(argument.get_arg()))
 		return True
+	elif argument.get_option_name()=="depth":
+		if active==True:
+			env.set_parse_depth(int(argument.get_arg()))
+		return True
 	elif argument.get_option_name() == "verbose":
 		if active==True:
 			debug.set_level(int(argument.get_arg()))
 		return True
 	elif argument.get_option_name() == "color":
 		if active==True:
-			debug.enable_color()
+			if check_boolean(argument.get_arg()) == True:
+				debug.enable_color()
+			else:
+				debug.disable_color()
 		return True
-	elif argument.get_option_name() == "force":
+	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:
-			env.set_print_pretty_mode(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() == "isolate-system":
+		if active==True:
+			if check_boolean(argument.get_arg()) == True:
+				env.set_isolate_system(True)
+			else:
+				env.set_isolate_system(False)
 		return True
 	elif argument.get_option_name() == "force-strip":
 		if active==True:
-			env.set_force_strip_mode(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:
-			env.set_warning_mode(True)
+			if check_boolean(argument.get_arg()) == True:
+				env.set_warning_mode(True)
+			else:
+				env.set_warning_mode(False)
 		return True
 	return False
 
+
+# open configuration of lutin:
+config_file_name = "lutinConfig.py"
+config_file = os.path.join(tools.get_run_path(), config_file_name)
+if os.path.isfile(config_file) == True:
+	sys.path.append(os.path.dirname(config_file))
+	debug.debug("Find basic configuration file: '" + config_file + "'")
+	# the file exist, we can open it and get the initial configuration:
+	configuration_file = __import__(config_file_name[:-3])
+	
+	if "get_exclude_path" in dir(configuration_file):
+		data = configuration_file.get_exclude_path()
+		debug.debug(" get default config 'get_exclude_path' val='" + str(data) + "'")
+		env.set_exclude_search_path(data)
+	
+	if "get_parsing_depth" in dir(configuration_file):
+		data = configuration_file.get_parsing_depth()
+		debug.debug(" get default config 'get_parsing_depth' val='" + str(data) + "'")
+		parseGenericArg(arguments.ArgElement("depth", str(data)), True)
+	
+	if "get_default_jobs" in dir(configuration_file):
+		data = configuration_file.get_default_jobs()
+		debug.debug(" get default config 'get_default_jobs' val='" + str(data) + "'")
+		parseGenericArg(arguments.ArgElement("jobs", str(data)), True)
+	
+	if "get_default_color" in dir(configuration_file):
+		data = configuration_file.get_default_color()
+		debug.debug(" get default config 'get_default_color' val='" + str(data) + "'")
+		parseGenericArg(arguments.ArgElement("color", str(data)), True)
+	
+	if "get_default_debug_level" in dir(configuration_file):
+		data = configuration_file.get_default_debug_level()
+		debug.debug(" get default config 'get_default_debug_level' val='" + str(data) + "'")
+		parseGenericArg(arguments.ArgElement("verbose", str(data)), True)
+	
+	if "get_default_print_pretty" in dir(configuration_file):
+		data = configuration_file.get_default_print_pretty()
+		debug.debug(" get default config 'get_default_print_pretty' val='" + str(data) + "'")
+		parseGenericArg(arguments.ArgElement("pretty", str(data)), True)
+	
+	if "get_default_force_optimisation" in dir(configuration_file):
+		data = configuration_file.get_default_force_optimisation()
+		debug.debug(" get default config 'get_default_force_optimisation' val='" + str(data) + "'")
+		parseGenericArg(arguments.ArgElement("force-optimisation", str(data)), True)
+	
+	if "get_default_isolate_system" in dir(configuration_file):
+		data = configuration_file.get_default_isolate_system()
+		debug.debug(" get default config 'get_default_isolate_system' val='" + str(data) + "'")
+		parseGenericArg(arguments.ArgElement("isolate-system", str(data)), True)
+		
+	
+
 # parse default unique argument:
 for argument in localArgument:
 	parseGenericArg(argument, True)
 
-
-import lutin
-
-
-import lutin.host as lutinHost
-import lutin.tools as lutinTools
+# initialize the system ...
+lutin.init()
 
 #available target : Linux / MacOs / Windows / Android ...
 targetName = host.OS
@@ -269,14 +382,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_nName() + "'")
+			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

@@ -1,4 +1,5 @@
 #!/usr/bin/python
+# -*- coding: utf-8 -*-
 ##
 ## @author Edouard DUPIN
 ##
@@ -8,6 +9,7 @@
 ##
 import os
 import sys
+import fnmatch
 # Local import
 from . import target
 from . import builder
@@ -16,32 +18,138 @@ from . import host
 from . import tools
 from . import debug
 from . import module
-
+from . import env
 is_init = False
 
-if is_init == False:
+
+def filter_name_and_file(root, list_files, filter):
+	# filter elements:
+	tmp_list = fnmatch.filter(list_files, filter)
+	out = []
+	for elem in tmp_list:
+		if os.path.isfile(os.path.join(root, elem)) == True:
+			out.append(elem);
+	return out;
+
+def filter_path(root, list_files):
+	out = []
+	for elem in list_files:
+		if    len(elem) == 0 \
+		   or elem[0] == '.':
+			continue
+		if os.path.isdir(os.path.join(root, elem)) == True:
+			out.append(elem);
+	return out;
+
+def import_path_local(path, limit_sub_folder, exclude_path = [], base_name = ""):
+	out = []
+	debug.verbose("lutin files: " + str(path) + " [START]")
+	if limit_sub_folder == 0:
+		debug.debug("Subparsing limitation append ...")
+		return []
+	try:
+		list_files = os.listdir(path)
+	except:
+		# an error occure, maybe read error ...
+		debug.warning("error when getting subdirectory of '" + str(path) + "'")
+		return []
+	if path in exclude_path:
+		debug.debug("find '" + str(path) + "' in exclude_path=" + str(exclude_path))
+		return []
+	# filter elements:
+	tmp_list_lutin_file = filter_name_and_file(path, list_files, base_name + "*.py")
+	debug.verbose("lutin files: " + str(path) + " : " + str(tmp_list_lutin_file))
+	# Import the module:
+	for filename in tmp_list_lutin_file:
+		out.append(os.path.join(path, filename))
+		debug.extreme_verbose("     Find a file : '" + str(out[-1]) + "'")
+	need_parse_sub_folder = True
+	rm_value = -1
+	# check if we need to parse sub_folder
+	if len(tmp_list_lutin_file) != 0:
+		need_parse_sub_folder = False
+	# 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)
+		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:
+			tmp_out = import_path_local(os.path.join(path, folder),
+			                            limit_sub_folder - rm_value,
+			                            exclude_path,
+			                            base_name)
+			# add all the elements:
+			for elem in tmp_out:
+				out.append(elem)
+	return out
+
+
+def init():
+	global is_init;
+	if is_init == True:
+		return
 	debug.verbose("Use Make as a make stadard")
 	sys.path.append(tools.get_run_path())
-	builder.import_path(tools.get_current_path(__file__))
-	module.import_path(tools.get_current_path(__file__))
-	system.import_path(tools.get_current_path(__file__))
-	target.import_path(tools.get_current_path(__file__))
-	
-	debug.debug("missing file lutinBase.py ==> loading subPath...");
+	# create the list of basic folder:
+	basic_folder_list = []
+	basic_folder_list.append([tools.get_current_path(__file__), True])
 	# Import all sub path without out and archive
-	for path in os.listdir("."):
-		if os.path.isdir(path)==True:
-			if     path.lower()!="android" \
-			   and path.lower()!="archive" \
-			   and path.lower()!="out" :
-				debug.debug("Automatic load path: '" + path + "'")
-				builder.import_path(path)
-				module.import_path(path)
-				system.import_path(path)
-				target.import_path(path)
+	for elem_path in os.listdir("."):
+		if os.path.isdir(elem_path) == False:
+			continue
+		if    elem_path.lower() == "android" \
+		   or elem_path == "out" :
+			continue
+		debug.debug("Automatic load path: '" + elem_path + "'")
+		basic_folder_list.append([elem_path, False])
+	
+	# create in a single path the basic list of lutin files  (all start with lutin and end with .py)
+	exclude_path = env.get_exclude_search_path()
+	limit_sub_folder = env.get_parse_depth()
+	list_of_lutin_files = []
+	for elem_path, is_system in basic_folder_list:
+		if is_system == True:
+			limit_sub_folder_tmp = 999999
+		else:
+			limit_sub_folder_tmp = limit_sub_folder
+		tmp_out = import_path_local(elem_path,
+		                            limit_sub_folder_tmp,
+		                            exclude_path,
+		                            env.get_build_system_base_name())
+		# add all the elements:
+		for elem in tmp_out:
+			list_of_lutin_files.append(elem)
+	
+	debug.debug("Files specific lutin: ")
+	for elem_path in list_of_lutin_files:
+		debug.debug("    " + elem_path)
+	# simply import element from the basic list of files (single parse ...)
+	builder.import_path(list_of_lutin_files)
+	module.import_path(list_of_lutin_files)
+	system.import_path(list_of_lutin_files)
+	target.import_path(list_of_lutin_files)
 	
 	builder.init()
-	
 	is_init = True
 
 

lutin/arg.py

@@ -1,4 +1,5 @@
 #!/usr/bin/python
+# -*- coding: utf-8 -*-
 ##
 ## @author Edouard DUPIN
 ##

lutin/builder.py

@@ -1,4 +1,5 @@
 #!/usr/bin/python
+# -*- coding: utf-8 -*-
 ##
 ## @author Edouard DUPIN
 ##
@@ -14,6 +15,7 @@ import datetime
 # Local import
 from . import debug
 from . import heritage
+from . import env
 
 ##
 ## constitution of dictionnary:
@@ -23,26 +25,37 @@ from . import heritage
 ##     - "builder": pointer on the element
 ##
 builder_list=[]
-__start_builder_name="lutinBuilder_"
+__start_builder_name="Builder_"
 
 
-def import_path(path):
+def import_path(path_list):
 	global builder_list
-	matches = []
-	debug.debug('BUILDER: Start find sub File : "%s"' %path)
-	for root, dirnames, filenames in os.walk(path):
-		tmpList = fnmatch.filter(filenames, __start_builder_name + "*.py")
-		# Import the module :
-		for filename in tmpList:
-			debug.debug('BUILDER:     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)) )
-			builder_name = filename.replace('.py', '')
-			the_builder = __import__(builder_name)
-			builder_list.append({"name":builder_name,
-			                     "element":the_builder
-			                    })
-			debug.debug('BUILDER:     type=' + the_builder.get_type() + " in=" + str(the_builder.get_input_type()) + " out=" + str(the_builder.get_output_type()))
+	global_base = env.get_build_system_base_name()
+	debug.debug("BUILDER: Init with Files list:")
+	for elem in path_list:
+		sys.path.append(os.path.dirname(elem))
+		# Get file name:
+		filename = os.path.basename(elem)
+		# Remove .py at the end:
+		filename = filename[:-3]
+		base_file_name = filename
+		# Remove global base name:
+		filename = filename[len(global_base):]
+		# Check if it start with the local patern:
+		if filename[:len(__start_builder_name)] != __start_builder_name:
+			debug.extreme_verbose("BUILDER:     Integrate: '" + filename + "' from '" + elem + "' ==> rejected")
+			continue
+		# Remove local patern
+		builder_name = filename[len(__start_builder_name):]
+		debug.verbose("BUILDER:     Integrate: '" + builder_name + "' from '" + elem + "'")
+		the_builder = __import__(base_file_name)
+		builder_list.append({"name":builder_name,
+		                     "element":the_builder
+		                    })
+		debug.debug('BUILDER:     type=' + the_builder.get_type() + " in=" + str(the_builder.get_input_type()) + " out=" + str(the_builder.get_output_type()))
+	debug.verbose("List of BUILDER: ")
+	for elem in builder_list:
+		debug.verbose("    " + str(elem["name"]))
 
 # we must have call all import before ...
 def init():

lutin/debug.py

@@ -1,4 +1,5 @@
 #!/usr/bin/python
+# -*- coding: utf-8 -*-
 ##
 ## @author Edouard DUPIN
 ##
@@ -11,8 +12,8 @@ import os
 import threading
 import re
 
-debugLevel=3
-debugColor=False
+debug_level=3
+debug_color=False
 
 color_default= ""
 color_red    = ""
@@ -23,20 +24,20 @@ color_purple = ""
 color_cyan   = ""
 
 
-debugLock = threading.Lock()
+debug_lock = threading.Lock()
 
 def set_level(id):
-	global debugLevel
-	debugLevel = id
-	#print "SetDebug level at " + str(debugLevel)
+	global debug_level
+	debug_level = id
+	#print "SetDebug level at " + str(debug_level)
 
 def get_level():
-	global debugLevel
-	return debugLevel
+	global debug_level
+	return debug_level
 
 def enable_color():
-	global debugColor
-	debugColor = True
+	global debug_color
+	debug_color = True
 	global color_default
 	color_default= "\033[00m"
 	global color_red
@@ -52,81 +53,108 @@ def enable_color():
 	global color_cyan
 	color_cyan   = "\033[36m"
 
+def disable_color():
+	global debug_color
+	debug_color = True
+	global color_default
+	color_default= ""
+	global color_red
+	color_red    = ""
+	global color_green
+	color_green  = ""
+	global color_yellow
+	color_yellow = ""
+	global color_blue
+	color_blue   = ""
+	global color_purple
+	color_purple = ""
+	global color_cyan
+	color_cyan   = ""
+
 def extreme_verbose(input, force=False):
-	global debugLock
-	global debugLevel
-	if    debugLevel >= 6 \
+	global debug_lock
+	global debug_level
+	if    debug_level >= 6 \
 	   or force == True:
-		debugLock.acquire()
+		debug_lock.acquire()
 		print(color_blue + input + color_default)
-		debugLock.release()
+		debug_lock.release()
 
 def verbose(input, force=False):
-	global debugLock
-	global debugLevel
-	if    debugLevel >= 5 \
+	global debug_lock
+	global debug_level
+	if    debug_level >= 5 \
 	   or force == True:
-		debugLock.acquire()
+		debug_lock.acquire()
 		print(color_blue + input + color_default)
-		debugLock.release()
+		debug_lock.release()
 
 def debug(input, force=False):
-	global debugLock
-	global debugLevel
-	if    debugLevel >= 4 \
+	global debug_lock
+	global debug_level
+	if    debug_level >= 4 \
 	   or force == True:
-		debugLock.acquire()
+		debug_lock.acquire()
 		print(color_green + input + color_default)
-		debugLock.release()
+		debug_lock.release()
 
 def info(input, force=False):
-	global debugLock
-	global debugLevel
-	if    debugLevel >= 3 \
+	global debug_lock
+	global debug_level
+	if    debug_level >= 3 \
 	   or force == True:
-		debugLock.acquire()
+		debug_lock.acquire()
 		print(input + color_default)
-		debugLock.release()
+		debug_lock.release()
 
 def warning(input, force=False):
-	global debugLock
-	global debugLevel
-	if    debugLevel >= 2 \
+	global debug_lock
+	global debug_level
+	if    debug_level >= 2 \
 	   or force == True:
-		debugLock.acquire()
+		debug_lock.acquire()
 		print(color_purple + "[WARNING] " + input + color_default)
-		debugLock.release()
+		debug_lock.release()
 
-def error(input, threadID=-1, force=False, crash=True):
-	global debugLock
-	global debugLevel
-	if    debugLevel >= 1 \
+def todo(input, force=False):
+	global debug_lock
+	global debug_level
+	if    debug_level >= 3 \
 	   or force == True:
-		debugLock.acquire()
+		debug_lock.acquire()
+		print(color_purple + "[TODO] " + input + color_default)
+		debug_lock.release()
+
+def error(input, thread_id=-1, force=False, crash=True):
+	global debug_lock
+	global debug_level
+	if    debug_level >= 1 \
+	   or force == True:
+		debug_lock.acquire()
 		print(color_red + "[ERROR] " + input + color_default)
-		debugLock.release()
-	if crash==True:
+		debug_lock.release()
+	if crash == True:
 		from . import multiprocess
-		multiprocess.error_occured()
-		if threadID != -1:
+		multiprocess.set_error_occured()
+		if thread_id != -1:
 			threading.interrupt_main()
 		exit(-1)
 		#os_exit(-1)
 		#raise "error happend"
 
 def print_element(type, lib, dir, name, force=False):
-	global debugLock
-	global debugLevel
-	if    debugLevel >= 3 \
+	global debug_lock
+	global debug_level
+	if    debug_level >= 3 \
 	   or force == True:
-		debugLock.acquire()
+		debug_lock.acquire()
 		print(color_cyan + type + color_default + " : " + color_yellow + lib + color_default + " " + dir + " " + color_blue + name + color_default)
-		debugLock.release()
+		debug_lock.release()
 
 def print_compilator(myString):
-	global debugColor
-	global debugLock
-	if debugColor == True:
+	global debug_color
+	global debug_lock
+	if debug_color == True:
 		myString = myString.replace('\\n', '\n')
 		myString = myString.replace('\\t', '\t')
 		myString = myString.replace('error:', color_red+'error:'+color_default)
@@ -136,9 +164,9 @@ def print_compilator(myString):
 		myString = myString.replace('-COLORIN-', color_yellow)
 		myString = myString.replace('-COLOROUT-', color_default)
 	
-	debugLock.acquire()
+	debug_lock.acquire()
 	print(myString)
-	debugLock.release()
+	debug_lock.release()
 
 def get_color_set() :
 	global color_default

lutin/depend.py

@@ -1,4 +1,5 @@
 #!/usr/bin/python
+# -*- coding: utf-8 -*-
 ##
 ## @author Edouard DUPIN
 ##

lutin/env.py

@@ -1,4 +1,5 @@
 #!/usr/bin/python
+# -*- coding: utf-8 -*-
 ##
 ## @author Edouard DUPIN
 ##
@@ -25,6 +26,66 @@ 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
+
+isolate_system=False
+
+def set_isolate_system(val):
+	global isolate_system
+	if val==1:
+		isolate_system = 1
+	else:
+		isolate_system = 0
+
+def get_isolate_system():
+	global isolate_system
+	return isolate_system
+
+parse_depth = 9999999
+
+def set_parse_depth(val):
+	global parse_depth
+	parse_depth = val
+	debug.debug("Set depth search element: " + str(parse_depth))
+
+def get_parse_depth():
+	global parse_depth
+	return parse_depth
+
+exclude_search_path = []
+
+def set_exclude_search_path(val):
+	global exclude_search_path
+	exclude_search_path = val
+	debug.debug("Set depth search element: " + str(exclude_search_path))
+
+def get_exclude_search_path():
+	global exclude_search_path
+	return exclude_search_path
+
+
+build_system_base_name = "lutin"
+
+def set_build_system_base_name(val):
+	global build_system_base_name
+	build_system_base_name = val
+	debug.debug("Set basename: '" + str(build_system_base_name) + "'")
+
+def get_build_system_base_name():
+	global build_system_base_name
+	return build_system_base_name
+
 
 print_pretty_mode=False
 
@@ -76,38 +137,55 @@ def print_pretty(my_string, force=False):
 		baseElementList = []
 		if end_with(cmdApplication, ["javac"]) == True:
 			baseElementList = [
-				"-d",
-				"-D",
-				"-classpath",
-				"-sourcepath"
-				]
+			    "-d",
+			    "-D",
+			    "-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",
-				"-C"
-				]
+			    "cf",
+			    "-C"
+			    ]
 		elif end_with(cmdApplication, ["aapt"]) == True:
 			baseElementList = [
-				"-M",
-				"-F",
-				"-I",
-				"-S",
-				"-J"
-				]
+			    "-M",
+			    "-F",
+			    "-I",
+			    "-S",
+			    "-J"
+			    ]
 		elif end_with(cmdApplication, ["g++", "gcc", "clang", "clang++", "ar", "ld", "ranlib"]) == True:
 			baseElementList = [
-				"-o",
-				"-D",
-				"-I",
-				"-L",
-				"-framework",
-				"-isysroot",
-				"-arch",
-				"-keystore",
-				"-sigalg",
-				"-digestalg",
-				"-target",
-				"-gcc-toolchain"]
+			    "-o",
+			    "-D",
+			    "-I",
+			    "-L",
+			    "-framework",
+			    "-isysroot",
+			    "-arch",
+			    "-keystore",
+			    "-sigalg",
+			    "-digestalg",
+			    "-target",
+			    "-gcc-toolchain",
+			    "-current_version",
+			    "-compatibility_version"
+			    ]
+
 		for element in baseElementList:
 			tmpcmdLine = tmpcmdLine.replace(element+'\n\t', element+' ')
 		for element in ["<", "<<", ">", ">>"]:

lutin/heritage.py

@@ -1,4 +1,5 @@
 #!/usr/bin/python
+# -*- coding: utf-8 -*-
 ##
 ## @author Edouard DUPIN
 ##
@@ -15,12 +16,12 @@ from . import debug
 def append_to_list(list_out, elem):
 	if type(elem) == str:
 		if elem not in list_out:
-			list_out.append(elem)
+			list_out.append(copy.deepcopy(elem))
 	else:
 		# mulyiple imput in the list ...
 		for element in elem:
 			if element not in list_out:
-				list_out.append(element)
+				list_out.append(copy.deepcopy(element))
 
 
 
@@ -60,6 +61,7 @@ class HeritageList:
 		self.regenerate_tree()
 	
 	def regenerate_tree(self):
+		debug.verbose("Regenerate heritage list:")
 		self.flags = {}
 		# sources list:
 		self.src = { 'src':[],
@@ -71,61 +73,86 @@ class HeritageList:
 		listHeritage = self.list_heritage
 		self.list_heritage = []
 		# first step : add all lib with no dependency:
+		debug.extreme_verbose("    add element with no dependency:")
 		for herit in listHeritage:
 			if len(herit.depends) == 0:
-				self.list_heritage.append(herit)
+				debug.extreme_verbose("        add: " + str(herit.name))
+				self.list_heritage.append(copy.deepcopy(herit))
 				listHeritage.remove(herit)
+		debug.extreme_verbose("    add element with dependency:")
 		while len(listHeritage) > 0:
 			currentHeritageSize = len(listHeritage)
-			debug.verbose("list heritage = " + str([[x.name, x.depends] for x in listHeritage]))
+			debug.verbose("        list heritage = " + str([[x.name, x.depends] for x in listHeritage]))
+			debug.extreme_verbose("        list heritage (rest):")
+			for tmppp_herit in listHeritage:
+				debug.extreme_verbose("            elem= " + str(tmppp_herit.name) + " : " + str(tmppp_herit.depends))
 			# Add element only when all dependence are resolved
 			for herit in listHeritage:
 				listDependsName = [y.name for y in self.list_heritage]
 				if all(x in listDependsName for x in herit.depends) == True:
+					debug.extreme_verbose("        add: " + str(herit.name))
 					listHeritage.remove(herit)
-					self.list_heritage.append(herit)
+					self.list_heritage.append(copy.deepcopy(herit))
 			if currentHeritageSize == len(listHeritage):
 				debug.warning("Not resolve dependency between the library ==> can be a cyclic dependency !!!")
 				for herit in listHeritage:
-					self.list_heritage.append(herit)
+					self.list_heritage.append(copy.deepcopy(herit))
 				listHeritage = []
 				debug.warning("new heritage list:")
 				for element in self.list_heritage:
 					debug.warning("	" + element.name + " " + str(element.depends))
-		debug.verbose("new heritage list:")
+		debug.extreme_verbose("new heritage list:")
 		for element in self.list_heritage:
-			debug.verbose("	" + element.name + " " + str(element.depends))
+			debug.extreme_verbose("	" + element.name + " " + str(element.depends))
 		for element in reversed(self.list_heritage):
 			for flags in element.flags:
-				if flags in ["c-version", "c++-version"]:
-					continue
+				# get value
 				value = element.flags[flags]
-				if flags not in self.flags:
-					self.flags[flags] = value
-				else:
-					append_to_list(self.flags[flags], value)
+				# if it is a list, simply add element on the previous one
+				if type(value) == list:
+					if flags not in self.flags:
+						self.flags[flags] = value
+					else:
+						append_to_list(self.flags[flags], value)
+				elif type(value) == bool:
+					if flags not in self.flags:
+						self.flags[flags] = value
+					else:
+						# keep only true, if false ==> bad case ...
+						if    self.flags[flags] == True \
+						   or value == True:
+							self.flags[flags] = True
+				elif type(value) == int:
+					# case of "c-version", "c++-version"
+					if flags not in self.flags:
+						self.flags[flags] = value
+					else:
+						# keep only true, if false ==> bad case ...
+						if self.flags[flags] < value:
+							self.flags[flags] = value
+			append_to_list(self.src['src'], element.src['src'])
+			append_to_list(self.src['dynamic'], element.src['dynamic'])
+			append_to_list(self.src['static'], element.src['static'])
+		for element in self.list_heritage:
+			debug.extreme_verbose("    elem: " + str(element.name))
+			debug.extreme_verbose("    Path (base): " + str(self.path))
+			debug.extreme_verbose("         inside: " + str(element.path))
 			for ppp in element.path:
-				value = element.path[ppp]
+				value = copy.deepcopy(element.path[ppp])
 				if ppp not in self.path:
 					self.path[ppp] = value
 				else:
 					append_to_list(self.path[ppp], value)
-			append_to_list(self.src['src'], element.src['src'])
-			append_to_list(self.src['dynamic'], element.src['dynamic'])
-			append_to_list(self.src['static'], element.src['static'])
-			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
-
+			debug.extreme_verbose("Path : " + str(self.path))
+		for ppp in self.path:
+			tmp = self.path[ppp]
+			self.path[ppp] = []
+			for iii in reversed(tmp):
+				self.path[ppp].append(iii)
+		debug.extreme_verbose("Path : " + str(self.path))
+	
+	def __repr__(self):
+		return "{HeritageList:" + str(self.list_heritage) + "}"
 
 class heritage:
 	def __init__(self, module, target):
@@ -149,8 +176,8 @@ class heritage:
 			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"]
+			self.flags = module.flags["export"] # have no deep copy here is a feature ...
+			self.path = copy.deepcopy(module.path["export"])
 			# if the user install some header ==> they will ba autoamaticaly exported ...
 			if target != None:
 				if len(module.header) > 0:
@@ -202,7 +229,7 @@ class heritage:
 		for flags in other.flags:
 			value = other.flags[flags]
 			if flags not in self.flags:
-				self.flags[flags] = value
+				self.flags[flags] = copy.deepcopy(value)
 			else:
 				append_to_list(self.flags[flags], value)
 		self.add_import_path(other.path)
@@ -219,5 +246,8 @@ class heritage:
 				if self.flags["c++-version"] > ver:
 					ver = self.flags["c++-version"]
 			self.flags["c++-version"] = ver
+	
+	def __repr__(self):
+		return "{Heritage:" + str(self.name) + " ... }"
 
 

lutin/host.py

@@ -1,4 +1,5 @@
 #!/usr/bin/python
+# -*- coding: utf-8 -*-
 ##
 ## @author Edouard DUPIN
 ##

lutin/image.py

@@ -1,4 +1,5 @@
 #!/usr/bin/python
+# -*- coding: utf-8 -*-
 ##
 ## @author Edouard DUPIN
 ##
@@ -35,12 +36,15 @@ def get_pow_2_multiple(size):
 #        check if time change
 #        check if command line change
 def resize(src_file, dest_file, x, y, cmd_file=None):
-	if enable_resize_image == False:
-		return
 	if os.path.exists(src_file) == False:
 		debug.error("Request a resize an image that does not existed : '" + src_file + "'")
+		return
+	if enable_resize_image == False:
+		debug.warning("Can not resize image missing pillow or CoreGraphics : '" + src_file + "' (just copy)")
+		tools.copy_file(src_file, dest_file)
+		return
 	cmd_line = "resize Image : " + src_file + " ==> " + dest_file + " newSize=(" + str(x) + "x" + str(y) + ")"
-	if False==depend.need_re_build(dest_file, src_file, file_cmd=cmd_file , cmd_line=cmd_line):
+	if depend.need_re_build(dest_file, src_file, file_cmd=cmd_file , cmd_line=cmd_line) == False:
 		return
 	# add cmdLine ...
 	x = get_pow_2_multiple(x)

lutin/license.py

@@ -0,0 +1,101 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+
+license_base = {
+	"APACHE-2": {
+		"generic":True,
+		"contaminate-static":False,
+		"contaminate-dynamic":False,
+		"redistribute-source":False,
+		"title":"APACHE v2.0 license",
+		"licence-file":"licence/apache-2.txt"
+		},
+	"GPL-2": {
+		"generic":True,
+		"contaminate-static":True,
+		"contaminate-dynamic":True,
+		"redistribute-source":True,
+		"title":"GPL: Gnu Public Licence v2.0",
+		"licence-file":"licence/GPL-2.txt"
+		},
+	"GPL-3": {
+		"generic":True,
+		"contaminate-static":True,
+		"contaminate-dynamic":True,
+		"redistribute-source":True,
+		"title":"GPL: GNU General Public License v3.0",
+		"licence-file":"licence/GPL-3.txt"
+		},
+	"LGPL-2": {
+		"generic":True,
+		"contaminate-static":False,
+		"contaminate-dynamic":False,
+		"redistribute-source":True,
+		"title":"LGPL: GNU Lesser General Public License v2.0",
+		"licence-file":"licence/LGPL-2.txt"
+		},
+	"LGPL-3": {
+		"generic":True,
+		"contaminate-static":True,
+		"contaminate-dynamic":False,
+		"redistribute-source":True,
+		"title":"LGPL: GNU Lesser General Public License v3.0",
+		"licence-file":"licence/LGPL-3.txt"
+		},
+	"MIT": {
+		"generic":True,
+		"contaminate-static":False,
+		"contaminate-dynamic":False,
+		"redistribute-source":False,
+		"title":"MIT: Massachusetts Institute of Technology License",
+		"licence-file":"licence/MIT.txt"
+		},
+	"BSD-2": {
+		"generic":True,
+		"contaminate-static":False,
+		"contaminate-dynamic":False,
+		"redistribute-source":False,
+		"title":"BSD 2-clauses: Berkeley Software Distribution License",
+		"licence-file":"licence/BSD-2.txt"
+		},
+	"BSD-3": {
+		"generic":True,
+		"contaminate-static":False,
+		"contaminate-dynamic":False,
+		"redistribute-source":False,
+		"title":"BSD 3-clauses: Berkeley Software Distribution License",
+		"licence-file":"licence/BSD-3.txt"
+		},
+	"BSD-4": {
+		"generic":True,
+		"contaminate-static":False,
+		"contaminate-dynamic":False,
+		"redistribute-source":False,
+		"title":"BSD 4-clauses: Berkeley Software Distribution License",
+		"licence-file":"licence/BSD-4.txt"
+		},
+	"PNG": {
+		"generic":True,
+		"contaminate-static":False,
+		"contaminate-dynamic":False,
+		"redistribute-source":False,
+		"title":"PNG License",
+		"licence-file":"licence/png.txt"
+		}
+}
+
+def get_basic_list():
+	global license_base
+	out = []
+	for name in license_base:
+		out.append(name)
+	return out
+
+

lutin/multiprocess.py

@@ -1,4 +1,5 @@
 #!/usr/bin/python
+# -*- coding: utf-8 -*-
 ##
 ## @author Edouard DUPIN
 ##
@@ -24,13 +25,13 @@ from . import tools
 from . import env
 from . import depend
 
-queueLock = threading.Lock()
-workQueue = queue.Queue()
-currentThreadWorking = 0
+queue_lock = threading.Lock()
+work_queue = queue.Queue()
+current_thread_working = 0
 threads = []
 # To know the first error arrive in the pool ==> to display all the time the same error file when multiple compilation
-currentIdExecution = 0
-errorExecution = {
+current_id_execution = 0
+error_execution = {
 	"id":-1,
 	"cmd":"",
 	"return":0,
@@ -38,10 +39,26 @@ errorExecution = {
 	"out":"",
 }
 
-exitFlag = False # resuest stop of the thread
-isinit = False # the thread are initialized
-errorOccured = False # a thread have an error
-processorAvaillable = 1 # number of CPU core availlable
+exit_flag = False # resuest stop of the thread
+is_init = False # the thread are initialized
+error_occured = False # a thread have an error
+processor_availlable = 1 # number of CPU core availlable
+##
+## @brief Execute the command with no get of output
+##
+def run_command_no_lock_out(cmd_line):
+	# prepare command line:
+	args = shlex.split(cmd_line)
+	debug.info("cmd = " + str(args))
+	try:
+		# create the subprocess
+		p = subprocess.Popen(args)
+	except subprocess.CalledProcessError as e:
+		debug.error("subprocess.CalledProcessError : " + str(args))
+	except:
+		debug.error("Exception on : " + str(args))
+	# launch the subprocess:
+	p.communicate()
 
 ##
 ## @brief Execute the command and ruturn generate data
@@ -72,9 +89,10 @@ def run_command_direct(cmd_line):
 
 
 def run_command(cmd_line, store_cmd_line="", build_id=-1, file="", store_output_file="", depend_data=None):
-	global errorOccured
-	global exitFlag
-	global currentIdExecution
+	global error_occured
+	global exit_flag
+	global current_id_execution
+	global error_execution
 	# prepare command line:
 	args = shlex.split(cmd_line)
 	debug.verbose("cmd = " + str(args))
@@ -95,7 +113,7 @@ def run_command(cmd_line, store_cmd_line="", build_id=-1, file="", store_output_
 	# Check error :
 	if p.returncode == 0:
 		debug.debug(env.print_pretty(cmd_line))
-		queueLock.acquire()
+		queue_lock.acquire()
 		if depend_data != None:
 			depend.create_dependency_file(depend_data['file'], depend_data['data'])
 		# TODO : Print the output all the time .... ==> to show warnings ...
@@ -105,10 +123,10 @@ def run_command(cmd_line, store_cmd_line="", build_id=-1, file="", store_output_
 			debug.print_compilator(output)
 		if err != "":
 			debug.print_compilator(err)
-		queueLock.release()
+		queue_lock.release()
 	else:
-		errorOccured = True
-		exitFlag = True
+		error_occured = True
+		exit_flag = True
 		# if No ID : Not in a multiprocess mode ==> just stop here
 		if build_id < 0:
 			debug.debug(env.print_pretty(cmd_line), force=True)
@@ -120,18 +138,18 @@ def run_command(cmd_line, store_cmd_line="", build_id=-1, file="", store_output_
 				debug.error("can not compile file ... ret : " + str(p.returncode))
 		else:
 			# in multiprocess interface
-			queueLock.acquire()
+			queue_lock.acquire()
 			# if an other write an error before, check if the current process is started before ==> then is the first error
-			if errorExecution["id"] >= build_id:
+			if error_execution["id"] >= build_id:
 				# nothing to do ...
-				queueLock.release()
+				queue_lock.release()
 				return;
-			errorExecution["id"] = build_id
-			errorExecution["cmd"] = cmd_line
-			errorExecution["return"] = p.returncode
-			errorExecution["err"] = err,
-			errorExecution["out"] = output,
-			queueLock.release()
+			error_execution["id"] = build_id
+			error_execution["cmd"] = cmd_line
+			error_execution["return"] = p.returncode
+			error_execution["err"] = err,
+			error_execution["out"] = output,
+			queue_lock.release()
 		# not write the command file...
 		return
 	debug.verbose("done 3")
@@ -141,38 +159,46 @@ def run_command(cmd_line, store_cmd_line="", build_id=-1, file="", store_output_
 
 
 class myThread(threading.Thread):
-	def __init__(self, threadID, lock, queue):
+	def __init__(self, thread_id, lock, queue):
 		threading.Thread.__init__(self)
-		self.thread_id = threadID
-		self.name = "Thread " + str(threadID)
+		self.thread_id = thread_id
+		self.name = "Thread " + str(thread_id)
 		self.queue = queue
 		self.lock = lock
 	def run(self):
 		debug.verbose("Starting " + self.name)
-		global exitFlag
-		global currentThreadWorking
-		workingSet = False
-		while exitFlag == False:
+		global exit_flag
+		global current_thread_working
+		working_set = False
+		while exit_flag == False:
 			self.lock.acquire()
 			if not self.queue.empty():
-				if workingSet==False:
-					currentThreadWorking += 1
-					workingSet = True
+				if working_set == False:
+					current_thread_working += 1
+					working_set = True
 				data = self.queue.get()
 				self.lock.release()
 				debug.verbose(self.name + " processing '" + data[0] + "'")
-				if data[0]=="cmdLine":
+				if data[0]=="cmd_line":
 					comment = data[2]
-					cmdLine = data[1]
-					cmdStoreFile = data[3]
-					debug.print_element( "[" + str(data[4]) + "][" + str(self.thread_id) + "] " + comment[0], comment[1], comment[2], comment[3])
-					run_command(cmdLine, cmdStoreFile, build_id=data[4], file=comment[3], store_output_file=data[5], depend_data=data[6])
+					cmd_line = data[1]
+					cmd_store_file = data[3]
+					debug.print_element("[" + str(data[4]) + "][" + str(self.thread_id) + "] " + comment[0],
+					                    comment[1],
+					                    comment[2],
+					                    comment[3])
+					run_command(cmd_line,
+					            cmd_store_file,
+					            build_id=data[4],
+					            file=comment[3],
+					            store_output_file=data[5],
+					            depend_data=data[6])
 				else:
 					debug.warning("unknow request command : " + data[0])
 			else:
-				if workingSet==True:
-					currentThreadWorking -= 1
-					workingSet=False
+				if working_set==True:
+					current_thread_working -= 1
+					working_set=False
 				# no element to parse, just wait ...
 				self.lock.release()
 				time.sleep(0.2)
@@ -180,39 +206,41 @@ class myThread(threading.Thread):
 		debug.verbose("Exiting " + self.name)
 
 
-def error_occured():
-	global exitFlag
-	exitFlag = True
+def set_error_occured():
+	global exit_flag
+	exit_flag = True
 
-def set_core_number(numberOfcore):
-	global processorAvaillable
-	processorAvaillable = numberOfcore
-	debug.debug(" set number of core for multi process compilation : " + str(processorAvaillable))
+def set_core_number(number_of_core):
+	global processor_availlable
+	processor_availlable = number_of_core
+	debug.debug(" set number of core for multi process compilation : " + str(processor_availlable))
 	# nothing else to do
 
 def init():
-	global exitFlag
-	global isinit
-	if isinit==False:
-		isinit=True
+	global error_occured
+	global exit_flag
+	global is_init
+	if is_init == False:
+		is_init = True
+		error_occured = False
 		global threads
-		global queueLock
-		global workQueue
+		global queue_lock
+		global work_queue
 		# Create all the new threads
-		threadID = 0
-		while threadID < processorAvaillable:
-			thread = myThread(threadID, queueLock, workQueue)
+		thread_id = 0
+		while thread_id < processor_availlable:
+			thread = myThread(thread_id, queue_lock, work_queue)
 			thread.start()
 			threads.append(thread)
-			threadID += 1
+			thread_id += 1
 		
 
 
 def un_init():
-	global exitFlag
+	global exit_flag
 	# Notify threads it's time to exit
-	exitFlag = True
-	if processorAvaillable > 1:
+	exit_flag = True
+	if processor_availlable > 1:
 		# Wait for all threads to complete
 		for tmp in threads:
 			debug.verbose("join thread ...")
@@ -222,53 +250,53 @@ def un_init():
 
 
 def run_in_pool(cmd_line, comment, store_cmd_line="", store_output_file="", depend_data=None):
-	global currentIdExecution
-	if processorAvaillable <= 1:
+	global current_id_execution
+	if processor_availlable <= 1:
 		debug.print_element(comment[0], comment[1], comment[2], comment[3])
 		run_command(cmd_line, store_cmd_line, file=comment[3], store_output_file=store_output_file, depend_data=depend_data)
 		return
 	# multithreaded mode
 	init()
 	# Fill the queue
-	queueLock.acquire()
-	debug.verbose("add : in pool cmdLine")
-	workQueue.put(["cmdLine", cmd_line, comment, store_cmd_line, currentIdExecution, store_output_file, depend_data])
-	currentIdExecution +=1;
-	queueLock.release()
+	queue_lock.acquire()
+	debug.verbose("add : in pool cmd_line")
+	work_queue.put(["cmd_line", cmd_line, comment, store_cmd_line, current_id_execution, store_output_file, depend_data])
+	current_id_execution +=1;
+	queue_lock.release()
 	
 
 def pool_synchrosize():
-	global errorOccured
-	global errorExecution
-	if processorAvaillable <= 1:
+	global error_occured
+	global error_execution
+	if processor_availlable <= 1:
 		#in this case : nothing to synchronise
 		return
 	
 	debug.verbose("wait queue process ended\n")
 	# Wait for queue to empty
-	while not workQueue.empty() \
-	      and False==errorOccured:
+	while not work_queue.empty() \
+	      and error_occured == False:
 		time.sleep(0.2)
 		pass
 	# Wait all thread have ended their current process
-	while currentThreadWorking != 0 \
-	      and False==errorOccured:
+	while current_thread_working != 0 \
+	      and error_occured == False:
 		time.sleep(0.2)
 		pass
-	if False==errorOccured:
+	if error_occured == False:
 		debug.verbose("queue is empty")
 	else:
 		un_init()
 		debug.debug("Thread return with error ... ==> stop all the pool")
-		if errorExecution["id"] == -1:
+		if error_execution["id"] == -1:
 			debug.error("Pool error occured ... (No return information on Pool)")
 			return
-		debug.error("Error in an pool element : [" + str(errorExecution["id"]) + "]", crash=False)
-		debug.debug(env.print_pretty(errorExecution["cmd"]), force=True)
-		debug.print_compilator(str(errorExecution["out"][0]))
-		debug.print_compilator(str(errorExecution["err"][0]))
-		if errorExecution["return"] == 2:
+		debug.error("Error in an pool element : [" + str(error_execution["id"]) + "]", crash=False)
+		debug.debug(env.print_pretty(error_execution["cmd"]), force=True)
+		debug.print_compilator(str(error_execution["out"][0]))
+		debug.print_compilator(str(error_execution["err"][0]))
+		if error_execution["return"] == 2:
 			debug.error("can not compile file ... [keyboard interrrupt]")
 		else:
-			debug.error("can not compile file ... return value : " + str(errorExecution["return"]))
+			debug.error("can not compile file ... return value : " + str(error_execution["return"]))
 	

lutin/system.py

@@ -1,4 +1,5 @@
 #!/usr/bin/python
+# -*- coding: utf-8 -*-
 ##
 ## @author Edouard DUPIN
 ##
@@ -15,81 +16,78 @@ import datetime
 # Local import
 from . import debug
 from . import module
+from . import tools
+from . import env
 
 class System:
 	def __init__(self):
 		self.valid=False;
 		self.help="";
-		self.include_cc=[]
-		self.export_flags_cc=[]
-		self.export_flags_xx=[]
-		self.export_flags_mm=[]
-		self.export_flags_m=[]
-		self.export_flags_ar=[]
-		self.export_flags_ld=[]
-		self.export_flags_ld_shared=[]
-		self.export_libs_ld=[]
-		self.export_libs_ld_shared=[]
+		self.export_depends=[]
+		self.export_flags={}
 		self.export_src=[]
+		self.export_path=[]
 		self.action_on_state={}
-		
-	def append_and_check(self, listout, newElement, order):
-		for element in listout:
-			if element==newElement:
-				return
-		listout.append(newElement)
-		if True==order:
-			listout.sort()
+		self.headers=[]
+		self.version=None
 	
-	def append_to_internal_list(self, listout, list, order=False):
-		if type(list) == type(str()):
-			self.append_and_check(listout, list, order)
-		else:
-			# mulyiple imput in the list ...
-			for elem in list:
-				self.append_and_check(listout, elem, order)
+	def add_export_sources(self, list):
+		tools.list_append_to(self.export_src, list)
 	
-	def add_export_flag_LD(self, list):
-		self.append_to_internal_list(self.export_flags_ld, list)
+	# todo : add other than C ...
+	def add_export_path(self, list):
+		tools.list_append_to(self.export_path, list)
 	
-	def add_export_flag_CC(self, list):
-		self.append_to_internal_list(self.export_flags_cc, list)
+	def add_module_depend(self, list):
+		tools.list_append_to(self.export_depends, list, True)
 	
-	def add_export_flag_XX(self, list):
-		self.append_to_internal_list(self.export_flags_xx, list)
+	def add_export_flag(self, type, list):
+		tools.list_append_to_2(self.export_flags, type, list)
 	
-	def add_export_flag_M(self, list):
-		self.append_to_internal_list(self.export_flags_m, list)
-	
-	def add_export_flag_MM(self, list):
-		self.append_to_internal_list(self.export_flags_mm, list)
-	
-	def add_export_SRC(self, list):
-		self.append_to_internal_list(self.export_src, list)
+	def set_version(self, version_list):
+		self.version = version_list
 	
 	def add_action(self, name_of_state="PACKAGE", level=5, name="no-name", action=None):
-		if name_of_state not in self.action_on_state:
+		if name_of_state not in self.action_on_add_src_filestate:
 			self.action_on_state[name_of_state] = [[level, name, action]]
 		else:
 			self.action_on_state[name_of_state].append([level, name, action])
-	
+	def add_header_file(self, list, destination_path=None, clip_path=None, recursive=False):
+		self.headers.append({
+		  "list":list,
+		  "dst":destination_path,
+		  "clip":clip_path,
+		  "recursive":recursive
+		  })
+	def __repr__(self):
+		return "{lutin.System}"
 
 
 
-def createModuleFromSystem(target, dict):
+def create_module_from_system(target, dict):
 	myModule = module.Module(dict["path"], dict["name"], 'PREBUILD')
-	
-	myModule.add_export_flag('c', dict["system"].export_flags_cc)
-	myModule.add_export_flag('link', dict["system"].export_flags_ld)
-	myModule.add_export_flag('c++', dict["system"].export_flags_xx)
-	myModule.add_export_flag('m', dict["system"].export_flags_m)
-	myModule.add_export_flag('mm', dict["system"].export_flags_mm)
+	# add element flags to export
+	for elem in dict["system"].export_flags:
+		debug.verbose("add element :" + str(elem) + " elems=" + str(dict["system"].export_flags[elem]))
+		myModule.add_export_flag(elem, dict["system"].export_flags[elem])
+	# add module dependency
+	myModule.add_module_depend(dict["system"].export_depends)
+	# add exporting sources
 	myModule.add_src_file(dict["system"].export_src)
-	
+	# add export path
+	myModule.add_export_path(dict["system"].export_path)
+	# Export all actions ...
 	for elem in dict["system"].action_on_state:
 		level, name, action = dict["system"].action_on_state[elem]
 		target.add_action(elem, level, name, action)
-	
+	for elem in dict["system"].headers:
+		myModule.add_header_file(
+		    elem["list"],
+		    destination_path=elem["dst"],
+		    clip_path=elem["clip"],
+		    recursive=elem["recursive"])
+	if dict["system"].version != None:
+		myModule.package_prop["VERSION"] = dict["system"].version
 	return myModule
 
 
@@ -97,82 +95,91 @@ def createModuleFromSystem(target, dict):
 
 # Dictionnaire of Target name
 #   inside table of ["Name of the lib", "path of the lib", boolean loaded, module loaded]
-systemList={}
-__start_system_name="lutinSystem_"
+system_list={}
+__start_system_name="System_"
 
+def import_path(path_list):
+	global system_list
+	global_base = env.get_build_system_base_name()
+	debug.debug("SYSTEM: Init with Files list:")
+	for elem in path_list:
+		sys.path.append(os.path.dirname(elem))
+		# Get file name:
+		filename = os.path.basename(elem)
+		# Remove .py at the end:
+		filename = filename[:-3]
+		# Remove global base name:
+		filename = filename[len(global_base):]
+		# Check if it start with the local patern:
+		if filename[:len(__start_system_name)] != __start_system_name:
+			debug.extreme_verbose("SYSTEM:     NOT-Integrate: '" + filename + "' from '" + elem + "' ==> rejected")
+			continue
+		# Remove local patern
+		system_name = filename[len(__start_system_name):]
+		system_type, system_name = system_name.split('_')
+		debug.verbose("SYSTEM:     Integrate: '" + system_type + "':'" + system_name + "' from '" + elem + "'")
+		if system_type in system_list:
+			system_list[system_type].append({"name":system_name,
+			                               "path":elem,
+			                               "system":None,
+			                               "loaded":False,
+			                               "exist":False,
+			                               "module":None})
+		else:
+			system_list[system_type] = [{"name":system_name,
+			                           "path":elem,
+			                           "system":None,
+			                           "loaded":False,
+			                           "exist":False,
+			                           "module":None}]
+	debug.verbose("New list system: ")
+	for elem in system_list:
+		debug.verbose("    " + str(elem))
+		for val in system_list[elem]:
+			debug.verbose("        " + str(val["name"]))
 
-def import_path(path):
-	global targetList
-	matches = []
-	debug.debug('Start find sub File : "%s"' %path)
-	for root, dirnames, filenames in os.walk(path):
-		tmpList = fnmatch.filter(filenames, __start_system_name + "*.py")
-		# Import the module :
-		for filename in tmpList:
-			debug.verbose('    Find a file : "%s"' %os.path.join(root, filename))
-			sys.path.append(os.path.dirname(os.path.join(root, filename)) )
-			systemName = filename.replace('.py', '')
-			systemName = systemName.replace(__start_system_name, '')
-			targetType, systemName = systemName.split('_')
-			debug.debug("integrate system: '" + targetType + "':'" + systemName + "' from '" + os.path.join(root, filename) + "'")
-			if targetType in systemList:
-				systemList[targetType].append({"name":systemName,
-				                               "path":os.path.join(root, filename),
-				                               "system":None,
-				                               "loaded":False,
-				                               "exist":False,
-				                               "module":None})
-			else:
-				systemList[targetType] = [{"name":systemName,
-				                           "path":os.path.join(root, filename),
-				                           "system":None,
-				                           "loaded":False,
-				                           "exist":False,
-				                           "module":None}]
-	debug.debug("list system=" + str(systemList))
 
 def display():
-	global systemList
-	for elementName in systemList:
-		debug.info("integrate system: '" + elementName +"'")
-		for data in systemList[elementName]:
-			debug.info("    '" + data["name"] +"' in " + data["path"])
-
+	global system_list
+	for elementName in system_list:
+		debug.info("SYSTEM:     Integrate system: '" + elementName +"'")
+		for data in system_list[elementName]:
+			debug.info("SYSTEM:    '" + data["name"] +"' in " + data["path"])
 
 def exist(lib_name, target_name, target) :
-	global systemList
+	global system_list
 	debug.verbose("exist= " + lib_name + " in " + target_name)
-	if target_name not in systemList:
+	if target_name not in system_list:
 		return False
-	for data in systemList[target_name]:
+	for data in system_list[target_name]:
 		if data["name"] == lib_name:
 			# we find it in the List ==> need to check if it is present in the system :
 			if data["loaded"] == False:
 				debug.verbose("add to path: '" + os.path.dirname(data["path"]) + "'")
 				sys.path.append(os.path.dirname(data["path"]))
 				debug.verbose("import system : '" + data["name"] + "'")
-				theSystem = __import__(__start_system_name + target_name + "_" + data["name"])
+				the_system = __import__(env.get_build_system_base_name() + __start_system_name + target_name + "_" + data["name"])
 				#create the system module
-				try:
-					debug.info("call : " + data["name"])
-					data["system"] = theSystem.System(target)
+				debug.verbose("SYSTEM: request: " + str(data["name"]))
+				if "System" in dir(the_system):
+					data["system"] = the_system.System(target)
 					data["exist"] = data["system"].valid
-				except:
+				else:
 					debug.warning("Not find: '" + data["name"] + "' ==> get exception")
 			return data["exist"]
 	return False
 
 def load(target, lib_name, target_name):
-	global systemList
-	if target_name not in systemList:
+	global system_list
+	if target_name not in system_list:
 		debug.error("you must call this function after checking of the system exist() !1!")
-	for data in systemList[target_name]:
+	for data in system_list[target_name]:
 		if data["name"] == lib_name:
 			if data["exist"] == False:
 				debug.error("you must call this function after checking of the system exist() !2!")
 			if data["module"] == None:
 				# create a module from the system interface...
-				data["module"] = createModuleFromSystem(target, data)
+				data["module"] = create_module_from_system(target, data)
 				data["loaded"] = True
 			target.add_module(data["module"])
 			return

lutin/target.py

@@ -1,4 +1,5 @@
 #!/usr/bin/python
+# -*- coding: utf-8 -*-
 ##
 ## @author Edouard DUPIN
 ##
@@ -19,6 +20,7 @@ from . import tools
 from . import module
 from . import system
 from . import multiprocess
+from . import env
 
 class Target:
 	def __init__(self, name, config, arch):
@@ -43,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"] + "'");
@@ -54,11 +57,11 @@ class Target:
 		# Target global variables.
 		###############################################################################
 		self.global_include_cc=[]
+		"""
 		self.global_flags_cc=['-D__TARGET_OS__'+self.name,
 		                      '-D__TARGET_ARCH__'+self.select_arch,
 		                      '-D__TARGET_ADDR__'+self.select_bus + 'BITS',
 		                      '-D_REENTRANT']
-		
 		self.global_flags_xx=[]
 		self.global_flags_mm=[]
 		if self.name == "Windows":
@@ -68,6 +71,9 @@ class Target:
 		self.global_flags_ar=['rcs']
 		self.global_flags_ld=[]
 		self.global_flags_ld_shared=[]
+		"""
+		self.global_flags={}
+		
 		self.global_libs_ld=[]
 		self.global_libs_ld_shared=[]
 		
@@ -86,33 +92,60 @@ class Target:
 		self.path_generate_code="/generate_header"
 		self.path_arch="/" + self.name
 		
+		self.add_flag("c", [
+		    '-D__TARGET_OS__' + self.name,
+		    '-D__TARGET_ARCH__' + self.select_arch,
+		    '-D__TARGET_ADDR__' + self.select_bus + 'BITS',
+		    '-D_REENTRANT'
+		    ])
+		self.add_flag("c", "-nodefaultlibs")
+		self.add_flag("c++", "-nostdlib")
+		self.add_flag("ar", 'rcs')
+		
+		if self.name == "Windows":
+			self.add_flag("c++", ['-static-libgcc', '-static-libstdc++'])
+		
 		if "debug" == self.config["mode"]:
-			self.global_flags_cc.append("-g")
-			self.global_flags_cc.append("-DDEBUG")
-			self.global_flags_cc.append("-O0")
+			self.add_flag("c", [
+			    "-g",
+			    "-DDEBUG"
+			    ])
+			if env.get_force_optimisation() == False:
+				self.add_flag("c", "-O0")
+			else:
+				self.add_flag("c", "-O3")
 		else:
-			self.global_flags_cc.append("-DNDEBUG")
-			self.global_flags_cc.append("-O3")
+			self.add_flag("c", [
+			    "-DNDEBUG",
+			    "-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")
+			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="usr/bin"
-		self.path_lib="usr/lib"
-		self.path_data="usr/share"
-		self.path_doc="usr/share/doc"
-		"""
 		self.path_bin="bin"
 		self.path_lib="lib"
 		self.path_data="share"
 		self.path_doc="doc"
 		self.path_include="include"
+		self.path_temporary_generate="generate"
 		self.path_object="obj"
 		
 		
@@ -134,6 +167,14 @@ class Target:
 		self.pkg_path_readme_file = "readme.txt"
 		self.pkg_path_change_log_file = "changelog.txt"
 		
+		# special case for IOS (example) no build dynamicly ...
+		self.support_dynamic_link = True
+	
+	def __repr__(self):
+		return "{lutin.Target}"
+	
+	def add_flag(self, type, list):
+		tools.list_append_to_2(self.global_flags, type, list)
 	
 	def update_path_tree(self):
 		self.path_out = os.path.join("out", self.name + "_" + self.config["arch"] + "_" + self.config["bus-size"], self.config["mode"])
@@ -142,6 +183,9 @@ class Target:
 		self.path_build = os.path.join("build", self.config["compilator"])
 	
 	def create_number_from_version_string(self, data):
+		tmp_data = data.split("-")
+		if len(tmp_data) > 1:
+			data = tmp_data[0]
 		list = data.split(".")
 		if len(list) == 1:
 			list.append("0")
@@ -191,6 +235,16 @@ class Target:
 		self.strip = self.cross + "strip"
 		self.dlltool = self.cross + "dlltool"
 		self.update_path_tree()
+		
+		#some static libraries that is sometime needed when not use stdlib ...
+		ret = multiprocess.run_command_direct(self.xx + " -print-file-name=libgcc.a");
+		if ret == False:
+			debug.error("Can not get the g++/clang++ libgcc.a ...")
+		self.stdlib_name_libgcc = ret;
+		ret = multiprocess.run_command_direct(self.xx + " -print-file-name=libsupc++.a");
+		if ret == False:
+			debug.error("Can not get the g++/clang++ libsupc++.a ...")
+		self.stdlib_name_libsupc = ret;
 	
 	def get_build_mode(self):
 		return self.config["mode"]
@@ -309,6 +363,9 @@ class Target:
 	def get_build_path_include(self, binary_name):
 		return os.path.join(self.get_build_path(binary_name), self.path_include)
 	
+	def get_build_path_temporary_generate(self, binary_name):
+		return os.path.join(self.get_build_path(binary_name), self.path_temporary_generate)
+	
 	
 	def get_build_file_bin(self, binary_name):
 		return os.path.join(self.get_build_path_bin(binary_name), binary_name + self.suffix_binary)
@@ -397,19 +454,18 @@ class Target:
 		for elem in self.module_list:
 			if elem.name == name:
 				return True
-		# TODO : Check internal module and system module ...
-		# need to import the module (or the system module ...)
-		exist = system.exist(name, self.name, self)
-		if exist == True:
-			system.load(self, name, self.name)
-			return True;
 		# try to find in the local Modules:
 		exist = module.exist(self, name)
 		if exist == True:
 			module.load_module(self, name)
 			return True;
-		else:
-			return False;
+		# need to import the module (or the system module ...)
+		exist = system.exist(name, self.name, self)
+		if exist == True:
+			system.load(self, name, self.name)
+			return True;
+		# we did not find the module ...
+		return False;
 	
 	def load_all(self):
 		listOfAllTheModule = module.list_all_module()
@@ -422,15 +478,25 @@ 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 parsig on a specific library or binary ==> not supported now for all")
+			debug.error("must set the gcov parsing on a specific library or binary ==> not supported now for all")
 		if name == "dump":
 			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")
@@ -449,53 +515,100 @@ 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]
-			if len(gettedElement)>=3:
-				sub_action_name = gettedElement[2]
-			else:
-				sub_action_name = ""
-			if len(gettedElement)>=2:
-				actionName = gettedElement[1]
-			else :
-				actionName = "build"
-			debug.verbose("requested : " + module_name + "?" + actionName)
-			if actionName == "install":
-				self.build(module_name + "?build")
-				self.install_package(module_name)
-			elif actionName == "uninstall":
-				self.un_install_package(module_name)
-			elif actionName == "log":
-				self.Log(module_name)
-			else:
-				present = self.load_if_needed(module_name, optionnal=optionnal)
-				if     present == False \
-				   and optionnal == True:
-					return [heritage.HeritageList(), False]
-				# clean requested
-				for mod in self.module_list:
-					if mod.name == module_name:
-						if actionName == "dump":
-							debug.info("dump module '" + module_name + "'")
-							return mod.display(self)
-						elif actionName == "clean":
-							debug.info("clean module '" + module_name + "'")
-							return mod.clean(self)
-						elif actionName == "gcov":
-							debug.debug("gcov on module '" + module_name + "'")
-							if sub_action_name == "output":
-								return mod.gcov(self, generate_output=True)
-							return mod.gcov(self, generate_output=False)
-						elif actionName == "build":
-							debug.debug("build module '" + module_name + "'")
-							if optionnal == True:
-								return [mod.build(self, None), True]
-							return mod.build(self, None)
-				if optionnal == True:
-					return [heritage.HeritageList(), False]
-				debug.error("not know module name : '" + module_name + "' to '" + actionName + "' it")
+			module_name = name
+			action_list = actions
+			for action_name in action_list:
+				debug.verbose("requested : " + module_name + "?" + action_name + " [START]")
+				ret = None;
+				if action_name == "install":
+					try:
+						self.install_package(module_name)
+					except AttributeError:
+						debug.error("target have no 'install_package' instruction")
+				elif action_name == "uninstall":
+					try:
+						self.un_install_package(module_name)
+					except AttributeError:
+						debug.error("target have no 'un_install_package' instruction")
+				elif action_name[:3] == "run":
+					if len(action_name) > 3:
+						# we have option:
+						action_name2 = action_name.replace("\:", "1234COLUMN4321")
+						option_list = action_name2.split(":")
+						if len(option_list) == 0:
+							debug.warning("action 'run' wrong options options ... : '" + action_name + "' might be separate with ':'")
+							option_list = []
+						else:
+							option_list_tmp = option_list[1:]
+							option_list = []
+							for elem in option_list_tmp:
+								option_list.append(elem.replace("1234COLUMN4321", ":"))
+					else:
+						option_list = []
+					#try:
+					self.run(module_name, option_list)
+					#except AttributeError:
+					#	debug.error("target have no 'run' instruction")
+				elif action_name == "log":
+					try:
+						self.show_log(module_name)
+					except AttributeError:
+						debug.error("target have no 'show_log' instruction")
+				else:
+					present = self.load_if_needed(module_name, optionnal=optionnal)
+					if     present == False \
+					   and optionnal == True:
+						ret = [heritage.HeritageList(), False]
+					else:
+						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()
+									break
+								elif action_name[:5] == "clean":
+									debug.info("clean module '" + module_name + "'")
+									if len(action_name) > 5:
+										debug.warning("action 'clean' does not support options ... : '" + action_name + "'")
+									ret = mod.clean(self)
+									break
+								elif action_name[:4] == "gcov":
+									debug.debug("gcov on module '" + module_name + "'")
+									if len(action_name) > 4:
+										# we have option:
+										option_list = action_name.split(":")
+										if len(option_list) == 0:
+											debug.warning("action 'gcov' wrong options options ... : '" + action_name + "' might be separate with ':'")
+											option_list = []
+										else:
+											option_list = option_list[1:]
+									else:
+										option_list = []
+									if "output" in option_list:
+										ret = mod.gcov(self, generate_output=True)
+									else:
+										ret = mod.gcov(self, generate_output=False)
+									break
+								elif action_name[:5] == "build":
+									if len(action_name) > 5:
+										debug.warning("action 'build' does not support options ... : '" + action_name + "'")
+									debug.debug("build module '" + module_name + "'")
+									if optionnal == True:
+										ret = [mod.build(self, None), True]
+									else:
+										ret = mod.build(self, None)
+									break
+						if     optionnal == True \
+						   and ret == None:
+							ret = [heritage.HeritageList(), False]
+							break
+						if ret == None:
+							debug.error("not know module name : '" + module_name + "' to '" + action_name + "' it")
+				debug.verbose("requested : " + module_name + "?" + action_name + " [STOP]")
+			if len(action_list) == 1:
+				return ret
 	
 	def add_action(self, name_of_state="PACKAGE", level=5, name="no-name", action=None):
 		debug.verbose("add action : " + name)
@@ -528,9 +641,9 @@ class Target:
 			return
 		if    module.get_type() == 'BINARY' \
 		   or module.get_type() == 'BINARY_STAND_ALONE':
-			self.make_package_generic_binary(pkg_name, pkg_properties, base_pkg_path, heritage_list, static = True)
+			self.make_package_binary(pkg_name, pkg_properties, base_pkg_path, heritage_list, static = True)
 		if module.get_type() == 'BINARY_SHARED':
-			self.make_package_generic_binary(pkg_name, pkg_properties, base_pkg_path, heritage_list, static = False)
+			self.make_package_binary(pkg_name, pkg_properties, base_pkg_path, heritage_list, static = False)
 		if module.get_type() == 'PACKAGE':
 			debug.info("Can not create package for package");
 			return
@@ -542,6 +655,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)
@@ -575,9 +690,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
@@ -585,6 +701,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={}
@@ -597,10 +715,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
@@ -608,6 +728,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={}
@@ -628,46 +750,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:
 		"""
@@ -686,13 +811,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 ","
@@ -712,25 +844,32 @@ class Target:
 
 
 target_list=[]
-__start_target_name="lutinTarget_"
+__start_target_name="Target_"
 
 
-def import_path(path):
+def import_path(path_list):
 	global target_list
-	matches = []
-	debug.debug('TARGET: Start find sub File : "%s"' %path)
-	for root, dirnames, filenames in os.walk(path):
-		tmpList = fnmatch.filter(filenames, __start_target_name + "*.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(__start_target_name, '')
-			debug.debug("TARGET:     integrate module: '" + targetName + "' from '" + os.path.join(root, filename) + "'")
-			target_list.append([targetName,os.path.join(root, filename)])
-
+	global_base = env.get_build_system_base_name()
+	debug.debug("TARGET: Init with Files list:")
+	for elem in path_list:
+		sys.path.append(os.path.dirname(elem))
+		# Get file name:
+		filename = os.path.basename(elem)
+		# Remove .py at the end:
+		filename = filename[:-3]
+		# Remove global base name:
+		filename = filename[len(global_base):]
+		# Check if it start with the local patern:
+		if filename[:len(__start_target_name)] != __start_target_name:
+			debug.extreme_verbose("TARGET:     NOT-Integrate: '" + filename + "' from '" + elem + "' ==> rejected")
+			continue
+		# Remove local patern
+		target_name = filename[len(__start_target_name):]
+		debug.verbose("TARGET:     Integrate: '" + target_name + "' from '" + elem + "'")
+		target_list.append([target_name, elem])
+	debug.verbose("New list TARGET: ")
+	for elem in target_list:
+		debug.verbose("    " + str(elem[0]))
 
 def load_target(name, config):
 	global target_list
@@ -742,8 +881,8 @@ def load_target(name, config):
 		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 : '" + __start_target_name + name + "'")
-			theTarget = __import__(__start_target_name + name)
+			debug.verbose("import target : '" + env.get_build_system_base_name() + __start_target_name + name + "'")
+			theTarget = __import__(env.get_build_system_base_name() + __start_target_name + name)
 			#create the target
 			tmpTarget = theTarget.Target(config)
 			return tmpTarget
@@ -761,7 +900,7 @@ def list_all_target_with_desc():
 	tmpList = []
 	for mod in target_list:
 		sys.path.append(os.path.dirname(mod[1]))
-		theTarget = __import__(__start_target_name + mod[0])
+		theTarget = __import__(env.get_build_system_base_name() + __start_target_name + mod[0])
 		try:
 			tmpdesc = theTarget.get_desc()
 			tmpList.append([mod[0], tmpdesc])

lutin/tools.py

@@ -1,4 +1,5 @@
 #!/usr/bin/python
+# -*- coding: utf-8 -*-
 ##
 ## @author Edouard DUPIN
 ##
@@ -50,6 +51,8 @@ def remove_path_and_sub_path(path):
 def remove_file(path):
 	if os.path.isfile(path):
 		os.remove(path)
+	elif os.path.islink(path):
+		os.remove(path)
 
 def file_size(path):
 	if not os.path.isfile(path):
@@ -84,16 +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()):
@@ -127,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:
@@ -134,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))
@@ -144,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)
@@ -159,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
@@ -206,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:
@@ -227,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 = []
@@ -297,3 +317,35 @@ def store_warning(file, output, err):
 	file2.close()
 
 
+## List tools:
+def list_append_and_check(listout, newElement, order):
+	for element in listout:
+		if element==newElement:
+			return
+	listout.append(newElement)
+	if order == True:
+		if type(newElement) is not dict:
+			listout.sort()
+
+def list_append_to(out_list, in_list, order=False):
+	if type(in_list) == str:
+		list_append_and_check(out_list, in_list, order)
+	elif type(in_list) == list:
+		# mulyiple imput in the list ...
+		for elem in in_list:
+			list_append_and_check(out_list, elem, order)
+	elif type(in_list) == dict:
+		list_append_and_check(out_list, in_list, order)
+	else:
+		debug.warning("can not add in list other than {list/dict/str} : " + str(type(in_list)))
+
+def list_append_to_2(listout, module, list, order=False):
+	# sepcial cse of bool
+	if type(list) == bool:
+		listout[module] = list
+		return
+	# add list in the Map
+	if module not in listout:
+		listout[module] = []
+	# add elements...
+	list_append_to(listout[module], list, order)

lutin/z_builder/__init__.py

@@ -0,0 +1,9 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##

lutin/z_builder/lutinBuilder_binary.py

@@ -1,3 +1,13 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+
 ##
 ## Executable/binary builder
 ##
@@ -36,11 +46,18 @@ def get_input_type():
 def get_output_type():
 	return ["", "exe", "bin"]
 
+##
+## @brief Get builder support multi-threading or not
+## @return True Multithreading supported
+## @return False Multithreading NOT supported
+##
+def get_support_multithreading():
+	return False
 
 ##
 ## @brief Commands for running gcc to link an executable.
 ##
-def link(file, binary, target, depancy, name, basic_path, static = False):
+def link(file, binary, target, depancy, flags, name, basic_path, static = False):
 	file_src, file_dst, file_depend, file_cmd, file_warning = target.generate_file(binary, name, basic_path, file, "bin")
 	debug.extreme_verbose("list files = " + str(depancy.src))
 	list_static = []
@@ -62,9 +79,14 @@ def link(file, binary, target, depancy, name, basic_path, static = False):
 			if lib_name not in depancy.src['dynamic']:
 				list_static.append(elem)
 	#create comand line:
-	cmd = [
-		target.xx
-		]
+	cmd = []
+	# a specific case to not depend on the libstdc++ automaticly added by the G++ or clang++ compilator ==> then need to compile with GCC or CLANG if use libcxx from llvm or other ...
+	if     "need-libstdc++" in depancy.flags \
+	   and depancy.flags["need-libstdc++"] == True:
+		cmd.append(target.xx)
+	else:
+		cmd.append(target.cc)
+	
 	try:
 		cmd.append(target.arch)
 	except:
@@ -99,11 +121,13 @@ def link(file, binary, target, depancy, name, basic_path, static = False):
 			lib_name = elem[len(lib_path)+len(target.prefix_lib)+1:-len(target.suffix_lib_dynamic)]
 			cmd.append("-L" + lib_path)
 			cmd.append("-l" + lib_name)
-		if len(list_dynamic) > 0:
-			cmd.append("-Wl,-R$ORIGIN/../lib/")
-			pass
+		if     target.name != "MacOs" \
+		   and target.name != "Android":
+			if len(list_dynamic) > 0:
+				cmd.append("-Wl,-R$ORIGIN/../lib/")
 	except:
 		pass
+	cmd.append("-Wl,-rpath,\"\$ORIGIN/../lib\"")
 	try:
 		cmd.append(flags["local"]["link"])
 	except:
@@ -113,9 +137,29 @@ def link(file, binary, target, depancy, name, basic_path, static = False):
 	except:
 		pass
 	try:
-		cmd.append(target.global_flags_ld)
+		cmd.append(target.global_flags["link"])
 	except:
 		pass
+	for view in ["local", "export"]:
+		if view not in flags:
+			continue
+		for type in ["link-lib"]:
+			if type in flags[view]:
+				cmd.append([("-l" + sss).replace("-l/", "/") for sss in flags[view][type] ])
+		for type in ["link-bin"]:
+			if type in flags[view]:
+				cmd.append(flags[view][type])
+	for type in ["link-lib"]:
+		if type in depancy.flags:
+			cmd.append([("-l" + sss).replace("-l/", "/") for sss in depancy.flags[type] ])
+	for type in ["link-lib"]:
+		if type in target.global_flags:
+			cmd.append([("-l" + sss).replace("-l/", "/") for sss in target.global_flags[type] ])
+	for type in ["link-bin"]:
+		if type in target.global_flags:
+			cmd.append(target.global_flags[type])
+		if type in depancy.flags:
+			cmd.append(depancy.flags[type])
 	cmd_line = tools.list_to_str(cmd)
 	# check the dependency for this file :
 	if     depend.need_re_package(file_dst, file_src, True, file_cmd=file_cmd, cmd_line=cmd_line) == False \

lutin/z_builder/lutinBuilder_c.py

@@ -1,3 +1,13 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+
 ##
 ## C builder
 ##
@@ -37,6 +47,14 @@ def get_input_type():
 def get_output_type():
 	return ["o"]
 
+##
+## @brief Get builder support multi-threading or not
+## @return True Multithreading supported
+## @return False Multithreading NOT supported
+##
+def get_support_multithreading():
+	return True
+
 ##
 ## @brief Commands for running gcc to compile a C file in object file.
 ##
@@ -52,8 +70,7 @@ def compile(file, binary, target, depancy, flags, path, name, basic_path, module
 		target.cc,
 		"-o", file_dst,
 		target.arch,
-		target.sysroot,
-		target.global_include_cc]
+		target.sysroot]
 	for view in ["export", "local"]:
 		try:
 			cmd.append(tools.add_prefix("-I", path[view]["c"]))
@@ -63,12 +80,13 @@ def compile(file, binary, target, depancy, flags, path, name, basic_path, module
 		cmd.append(tools.add_prefix("-I", depancy.path["c"]))
 	except:
 		pass
+	cmd.append(target.global_include_cc)
 	try:
 		cmd.append(get_version_compilation_flags(flags, depancy.flags))
 	except:
 		pass
 	try:
-		cmd.append(target.global_flags_cc)
+		cmd.append(target.global_flags["c"])
 	except:
 		pass
 	try:

lutin/z_builder/lutinBuilder_cpp.py

@@ -1,3 +1,13 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+
 ##
 ## C++ builder
 ##
@@ -36,6 +46,21 @@ def get_input_type():
 def get_output_type():
 	return ["o"]
 
+##
+## @brief Get builder support multi-threading or not
+## @return True Multithreading supported
+## @return False Multithreading NOT supported
+##
+def get_support_multithreading():
+	return True
+
+def remove_element(data, to_remove):
+	out = []
+	for elem in data:
+		if elem not in to_remove:
+			out.append(elem)
+	return out;
+
 ##
 ## @brief Commands for running gcc to compile a C++ file in object file.
 ##
@@ -50,8 +75,7 @@ def compile(file, binary, target, depancy, flags, path, name, basic_path, module
 		target.xx,
 		"-o", file_dst,
 		target.arch,
-		target.sysroot,
-		target.global_include_cc
+		target.sysroot
 		]
 	for view in ["export", "local"]:
 		for type in ["c", "c++"]:
@@ -64,33 +88,58 @@ def compile(file, binary, target, depancy, flags, path, name, basic_path, module
 			cmd.append(tools.add_prefix("-I",depancy.path[type]))
 		except:
 			pass
+	cmd.append(target.global_include_cc)
 	try:
 		cmd.append(get_version_compilation_flags(flags, depancy.flags))
 	except:
 		pass
+	list_flags = [];
 	try:
-		cmd.append(target.global_flags_cc)
+		list_flags.append(target.global_flags["c"])
 	except:
 		pass
 	try:
-		cmd.append(target.global_flags_xx)
+		list_flags.append(target.global_flags["c++"])
 	except:
 		pass
 	for type in ["c", "c++"]:
 		try:
-			cmd.append(depancy.flags[type])
+			list_flags.append(depancy.flags[type])
 		except:
 			pass
 	for view in ["local", "export"]:
 		for type in ["c", "c++"]:
 			try:
-				cmd.append(flags[view][type])
+				list_flags.append(flags[view][type])
 			except:
 				pass
+	# get blacklist of flags
+	list_flags_blacklist = [];
+	try:
+		list_flags_blacklist.append(target.global_flags["c-remove"])
+	except:
+		pass
+	try:
+		list_flags_blacklist.append(target.global_flags["c++-remove"])
+	except:
+		pass
+	for type in ["c-remove", "c++-remove"]:
+		try:
+			list_flags_blacklist.append(depancy.flags[type])
+		except:
+			pass
+	for view in ["local", "export"]:
+		for type in ["c-remove", "c++-remove"]:
+			try:
+				list_flags_blacklist.append(flags[view][type])
+			except:
+				pass
+	# apply blacklisting of data and add it on the cmdLine
+	cmd.append(remove_element(list_flags, list_flags_blacklist));
 	cmd.append(["-c", "-MMD", "-MP"])
 	cmd.append(file_src)
 	# Create cmd line
-	cmdLine=tools.list_to_str(cmd)
+	cmdLine = tools.list_to_str(cmd)
 	# check the dependency for this file :
 	if depend.need_re_build(file_dst, file_src, file_depend, file_cmd, cmdLine) == False:
 		return {"action":"add", "file":file_dst}

lutin/z_builder/lutinBuilder_jar.py

@@ -1,3 +1,13 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+
 ##
 ## Dynamic library builder
 ##
@@ -35,10 +45,18 @@ def get_input_type():
 def get_output_type():
 	return ["jar"]
 
+##
+## @brief Get builder support multi-threading or not
+## @return True Multithreading supported
+## @return False Multithreading NOT supported
+##
+def get_support_multithreading():
+	return False
+
 ##
 ## @brief Commands for running gcc to link a shared library.
 ##
-def link(file, binary, target, depancy, name, basic_path):
+def link(file, binary, target, depancy, flags, name, basic_path):
 	file_src, file_dst, file_depend, file_cmd, file_warning = target.generate_file(binary, name, basic_path, file, "jar")
 	#create command Line
 	cmd = [

lutin/z_builder/lutinBuilder_java.py

@@ -1,3 +1,13 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+
 ##
 ## Java builder
 ##
@@ -33,6 +43,14 @@ def get_input_type():
 def get_output_type():
 	return ["class"]
 
+##
+## @brief Get builder support multi-threading or not
+## @return True Multithreading supported
+## @return False Multithreading NOT supported
+##
+def get_support_multithreading():
+	return False
+
 def create_dependency_files(target, src, heritage_src, basic_path):
 	depend = []
 	for elem in src:

lutin/z_builder/lutinBuilder_javah.py

@@ -1,3 +1,13 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+
 ##
 ## Java builder
 ##
@@ -33,6 +43,14 @@ def get_input_type():
 def get_output_type():
 	return ["h"]
 
+##
+## @brief Get builder support multi-threading or not
+## @return True Multithreading supported
+## @return False Multithreading NOT supported
+##
+def get_support_multithreading():
+	return False
+
 def create_dependency_files(target, src, heritage_src, basic_path):
 	depend = []
 	for elem in src:

lutin/z_builder/lutinBuilder_libraryDynamic.py

@@ -1,3 +1,13 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+
 ##
 ## Dynamic library builder
 ##
@@ -35,10 +45,18 @@ def get_input_type():
 def get_output_type():
 	return ["so", "dynlib", "dll"]
 
+##
+## @brief Get builder support multi-threading or not
+## @return True Multithreading supported
+## @return False Multithreading NOT supported
+##
+def get_support_multithreading():
+	return False
+
 ##
 ## @brief Commands for running gcc to link a shared library.
 ##
-def link(file, binary, target, depancy, name, basic_path, static=False):
+def link(file, binary, target, depancy, flags, name, basic_path, static=False):
 	file_src, file_dst, file_depend, file_cmd, file_warning = target.generate_file(binary, name, basic_path, file, "lib-shared")
 	list_static = []
 	list_dynamic = []
@@ -59,10 +77,15 @@ def link(file, binary, target, depancy, name, basic_path, static=False):
 			if lib_name not in depancy.src['dynamic']:
 				list_static.append(elem)
 	#create command Line
-	cmd = [
-		target.xx,
-		"-o", file_dst
-		]
+	cmd = []
+	# a specific case to not depend on the libstdc++ automaticly added by the G++ or clang++ compilator ==> then need to compile with GCC or CLANG if use libcxx from llvm or other ...
+	if     "need-libstdc++" in depancy.flags \
+	   and depancy.flags["need-libstdc++"] == True:
+		cmd.append(target.xx)
+	else:
+		cmd.append(target.cc)
+	
+	cmd.append(["-o", file_dst])
 	try:
 		cmd.append(target.global_sysroot)
 	except:
@@ -76,39 +99,48 @@ def link(file, binary, target, depancy, name, basic_path, static=False):
 		cmd.append(file_src)
 	except:
 		pass
-	try:
-		# keep only compilated files ...
-		cmd.append(tools.filter_extention(depancy.src['src'], get_input_type()))
-	except:
-		pass
 	try:
 		cmd.append(list_static)
 	except:
 		pass
+	for view in ["local", "export"]:
+		if view not in flags:
+			continue
+		for type in ["link", "link-dynamic"]:
+			if type in flags[view]:
+				cmd.append(flags[view][type])
+	for type in ["link", "link-dynamic"]:
+		if type in depancy.flags:
+			cmd.append(depancy.flags[type])
+	for type in ["link", "link-dynamic"]:
+		if type in target.global_flags:
+			cmd.append(target.global_flags[type])
+	if 'src' in depancy.src:
+		cmd.append(tools.filter_extention(depancy.src['src'], get_input_type()))
 	try:
 		for elem in list_dynamic:
 			lib_path = os.path.dirname(elem)
 			lib_name = elem[len(lib_path)+len(target.prefix_lib)+1:-len(target.suffix_lib_dynamic)]
 			cmd.append("-L" + lib_path)
 			cmd.append("-l" + lib_name)
-		if     target != "MacOs" \
+		if     target.name != "MacOs" \
 		   and target.name != "Android":
 			if len(list_dynamic) > 0:
 				cmd.append("-Wl,-R$ORIGIN/../lib/")
 	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
+	for view in ["local", "export"]:
+		if view not in flags:
+			continue
+		for type in ["link-lib"]:
+			if type in flags[view]:
+				cmd.append([("-l" + sss).replace("-l/", "/") for sss in flags[view][type] ])
+	for type in ["link-lib"]:
+		if type in depancy.flags:
+			cmd.append([("-l" + sss).replace("-l/", "/") for sss in depancy.flags[type] ])
+	for type in ["link-lib"]:
+		if type in target.global_flags:
+			cmd.append([("-l" + sss).replace("-l/", "/") for sss in target.global_flags[type] ])
 	cmdLine=tools.list_to_str(cmd)
 	# check the dependency for this file :
 	if     depend.need_re_package(file_dst, file_src, True, file_cmd, cmdLine) == False \
@@ -123,9 +155,15 @@ def link(file, binary, target, depancy, name, basic_path, static=False):
 		# get the file size of the non strip file
 		originSize = tools.file_size(file_dst);
 		debug.print_element("SharedLib(strip)", name, "", "")
-		cmdLineStrip=tools.list_to_str([
-			target.strip,
-			file_dst])
+		if target.name == "MacOs":
+			cmdLineStrip=tools.list_to_str([
+				target.strip,
+				"-u",
+				file_dst])
+		else:
+			cmdLineStrip=tools.list_to_str([
+				target.strip,
+				file_dst])
 		multiprocess.run_command(cmdLineStrip, store_output_file=file_warning)
 		# get the stip size of the binary
 		stripSize = tools.file_size(file_dst)

lutin/z_builder/lutinBuilder_libraryStatic.py

@@ -1,3 +1,13 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+
 ##
 ## Static library builder
 ##
@@ -35,17 +45,25 @@ def get_input_type():
 def get_output_type():
 	return ["a"]
 
+##
+## @brief Get builder support multi-threading or not
+## @return True Multithreading supported
+## @return False Multithreading NOT supported
+##
+def get_support_multithreading():
+	return False
+
 ##
 ## @brief Commands for running ar.
 ##
-def link(file, binary, target, depancy, name, basic_path):
+def link(file, binary, target, depancy, flags, name, basic_path):
 	file_src, file_dst, file_depend, file_cmd, file_warning = target.generate_file(binary, name, basic_path, file, "lib-static")
 	#$(Q)$(TARGET_AR) $(TARGET_GLOBAL_ARFLAGS) $(PRIVATE_ARFLAGS) $@ $(PRIVATE_ALL_OBJECTS)
 	cmd = [
 		target.ar
 		]
 	try:
-		cmd.append(target.global_flags_ar)
+		cmd.append(target.global_flags["ar"])
 	except:
 		pass
 	try:

lutin/z_builder/lutinBuilder_m.py

@@ -1,3 +1,13 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+
 ##
 ## Objective-C builder
 ##
@@ -38,6 +48,14 @@ def get_input_type():
 def get_output_type():
 	return ["o"]
 
+##
+## @brief Get builder support multi-threading or not
+## @return True Multithreading supported
+## @return False Multithreading NOT supported
+##
+def get_support_multithreading():
+	return True
+
 ##
 ## @brief Commands for running gcc to compile a m file in object file.
 ##
@@ -70,11 +88,11 @@ def compile(file, binary, target, depancy, flags, path, name, basic_path, module
 	except:
 		pass
 	try:
-		cmd.append(target.global_flags_cc)
+		cmd.append(target.global_flags["c"])
 	except:
 		pass
 	try:
-		cmd.append(target.global_flags_m)
+		cmd.append(target.global_flags["m"])
 	except:
 		pass
 	for type in ["c", "m"]:
@@ -94,7 +112,7 @@ def compile(file, binary, target, depancy, flags, path, name, basic_path, module
 	# Create cmd line
 	cmdLine=tools.list_to_str(cmd)
 	# check the dependency for this file :
-	if False==depend.need_re_build(file_dst, file_src, file_depend, file_cmd, cmdLine):
+	if depend.need_re_build(file_dst, file_src, file_depend, file_cmd, cmdLine) == False:
 		return {"action":"add", "file":file_dst}
 	tools.create_directory_of_file(file_dst)
 	comment = ["m", name, "<==", file]

lutin/z_builder/lutinBuilder_mm.py

@@ -1,3 +1,13 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+
 ##
 ## Objective C++ builder
 ##
@@ -38,6 +48,14 @@ def get_input_type():
 def get_output_type():
 	return ["o"]
 
+##
+## @brief Get builder support multi-threading or not
+## @return True Multithreading supported
+## @return False Multithreading NOT supported
+##
+def get_support_multithreading():
+	return True
+
 ##
 ## @brief Commands for running gcc to compile a m++ file in object file.
 ##
@@ -69,14 +87,11 @@ def compile(file, binary, target, depancy, flags, path, name, basic_path, module
 		cmd.append(local_ref_on_builder_cpp.get_version_compilation_flags(flags, depancy.flags))
 	except:
 		pass
-	try:
-		cmd.append(target.global_flags_cc)
-	except:
-		pass
-	try:
-		cmd.append(target.global_flags_mm)
-	except:
-		pass
+	for type in ["c", "c++", "m", "mm"]:
+		try:
+			cmd.append(target.global_flags[type])
+		except:
+			pass
 	for type in ["c", "c++", "m", "mm"]:
 		try:
 			cmd.append(depancy.flags[type])

lutin/z_builder/lutinBuilder_s.py

@@ -1,3 +1,13 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+
 ##
 ## ASM builder
 ##
@@ -31,3 +41,65 @@ def get_input_type():
 ##
 def get_output_type():
 	return ["o"]
+
+##
+## @brief Get builder support multi-threading or not
+## @return True Multithreading supported
+## @return False Multithreading NOT supported
+##
+def get_support_multithreading():
+	return True
+
+##
+## @brief Commands for running gcc to compile a C file in object file.
+##
+def compile(file, binary, target, depancy, flags, path, name, basic_path, module_src):
+	file_src = target.get_full_name_source(basic_path, file)
+	file_cmd = target.get_full_name_cmd(name, basic_path, file)
+	file_dst = target.get_full_name_destination(name, basic_path, file, get_output_type())
+	file_depend = target.get_full_dependency(name, basic_path, file)
+	file_warning = target.get_full_name_warning(name, basic_path, file)
+	
+	# create the command line befor requesting start:
+	cmd = [
+		target.cc,
+		"-o", file_dst,
+		target.arch,
+		target.sysroot]
+	for view in ["export", "local"]:
+		try:
+			cmd.append(tools.add_prefix("-I", path[view]["c"]))
+		except:
+			pass
+	try:
+		cmd.append(tools.add_prefix("-I", depancy.path["c"]))
+	except:
+		pass
+	cmd.append(target.global_include_cc)
+	try:
+		cmd.append(target.global_flags["c"])
+	except:
+		pass
+	try:
+		cmd.append(depancy.flags["c"])
+	except:
+		pass
+	for view in ["local", "export"]:
+		try:
+			cmd.append(flags[view]["c"])
+		except:
+			pass
+	cmd.append("-c")
+	cmd.append("-MMD")
+	cmd.append("-MP")
+	cmd.append(file_src)
+	# Create cmd line
+	cmdLine=tools.list_to_str(cmd)
+	# check the dependency for this file :
+	if depend.need_re_build(file_dst, file_src, file_depend, file_cmd, cmdLine) == False:
+		return {"action":"add", "file":file_dst}
+	tools.create_directory_of_file(file_dst)
+	comment = ["s", name, "<==", file]
+	# process element
+	multiprocess.run_in_pool(cmdLine, comment, file_cmd, store_output_file=file_warning)
+	return {"action":"add", "file":file_dst}

lutin/z_system/__init__.py

@@ -0,0 +1,9 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##

lutin/z_system/lutinSystem_Android_ADMOD.py

@@ -1,4 +1,5 @@
 #!/usr/bin/python
+# -*- coding: utf-8 -*-
 ##
 ## @author Edouard DUPIN
 ##
@@ -10,6 +11,7 @@
 from lutin import debug
 from lutin import system
 from lutin import tools
+from lutin import env
 import os
 
 class System(system.System):
@@ -20,7 +22,7 @@ class System(system.System):
 		# todo : Check if present ...
 		self.valid = True
 		# todo : create a searcher of the presence of the library:
-		self.add_export_SRC(target.path_sdk + "/extras/google/google_play_services/libproject/google-play-services_lib/libs/google-play-services.jar")
+		self.add_export_sources(target.path_sdk + "/extras/google/google_play_services/libproject/google-play-services_lib/libs/google-play-services.jar")
 		self.add_action("PACKAGE", 10, "admod-auto-wrapper", tool_generate_main_java_class)
 
 

lutin/z_system/lutinSystem_Android_SDK.py

@@ -1,4 +1,5 @@
 #!/usr/bin/python
+# -*- coding: utf-8 -*-
 ##
 ## @author Edouard DUPIN
 ##
@@ -10,6 +11,7 @@
 from lutin import debug
 from lutin import system
 from lutin import tools
+from lutin import env
 import os
 
 class System(system.System):
@@ -17,12 +19,14 @@ class System(system.System):
 		system.System.__init__(self)
 		# create some HELP:
 		self.help="SDK: Android SDK basic interface java\n"
+		# jar file:
+		jar_file_path=os.path.join(target.path_sdk, "platforms", "android-" + str(target.board_id), "android.jar")
 		# TODO : Check if the android sdk android.jar is present ...
 		self.valid = True
 		# todo : create a searcher of the presence of the library:
-		self.add_export_SRC(target.path_sdk + "/platforms/android-" + str(target.boardId) + "/android.jar")
-		self.add_export_flag_LD("-ldl")
-		self.add_export_flag_LD("-llog")
-		self.add_export_flag_LD("-landroid")
+		self.add_export_sources(jar_file_path)
+		self.add_export_flag("link-lib", "dl")
+		self.add_export_flag("link-lib", "log")
+		self.add_export_flag("link-lib", "android")
 
 

lutin/z_system/lutinSystem_Android_c.py

@@ -0,0 +1,23 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @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
+from lutin import env
+import os
+
+class System(system.System):
+	def __init__(self, target):
+		system.System.__init__(self)
+		# create some HELP:
+		self.help = "C: Generic C library"
+		self.valid = True
+

lutin/z_system/lutinSystem_Android_cxx.py

@@ -0,0 +1,77 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @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
+from lutin import env
+import os
+
+class System(system.System):
+	def __init__(self, target):
+		system.System.__init__(self)
+		# create some HELP:
+		self.help = "CXX: Generic C++ library"
+		self.valid = True
+		if target.config["compilator"] == "clang":
+			if target.board_id < 21:
+				debug.error("Clang work only with the board wersion >= 21 : android 5.x.x")
+				self.valid = False
+				return
+			self.add_export_flag("c++", "-D__STDCPP_LLVM__")
+			# llvm is BSD-like licence
+			self.add_export_path(os.path.join(target.path_ndk, "sources", "cxx-stl", "llvm-libc++", "libcxx", "include"))
+			if target.type_arch == "armv5":
+				stdCppBasePath = os.path.join(target.path_ndk, "sources", "cxx-stl", "llvm-libc++", "libcxx", "libs", "armeabi")
+				self.add_export_path(        os.path.join(stdCppBasePath, "include"))
+				self.add_export_flag("link", os.path.join(stdCppBasePath, "libc++_static.a"))
+			elif target.type_arch == "armv7":
+				stdCppBasePath = os.path.join(target.path_ndk, "sources", "cxx-stl", "llvm-libc++", "libs", "armeabi-v7a")
+				self.add_export_path(        os.path.join(stdCppBasePath + "include"))
+				self.add_export_flag("link", os.path.join(stdCppBasePath, "thumb", "libc++_static.a"))
+			elif target.type_arch == "mips":
+				stdCppBasePath = os.path.join(target.path_ndk, "sources", "cxx-stl", "llvm-libc++", "libcxx", "libs", "mips")
+				self.add_export_path(        os.path.join(stdCppBasePath + "include"))
+				self.add_export_flag("link", os.path.join(stdCppBasePath + "libc++_static.a"))
+			elif target.type_arch == "x86":
+				stdCppBasePath = os.path.join(target.path_ndk, "sources", "cxx-stl", "llvm-libc++", "libcxx", "libs", "x86")
+				self.add_export_path(        os.path.join(stdCppBasePath, "include"))
+				self.add_export_flag("link", os.path.join(stdCppBasePath, "libc++_static.a"))
+			else:
+				debug.warning("unknow architecture: '" + str(target.arch) + "'");
+		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":
+				stdCppBasePath = os.path.join(target.path_ndk, "sources", "cxx-stl", "gnu-libstdc++", target.compilator_version, "libs", "armeabi")
+				self.add_export_path(        os.path.join(stdCppBasePath, "include"))
+				self.add_export_flag("link", os.path.join(stdCppBasePath, "thumb", "libgnustl_static.a"))
+				self.add_export_flag("link", os.path.join(stdCppBasePath, "thumb", "libsupc++.a"))
+			elif target.type_arch == "armv7":
+				stdCppBasePath = os.path.join(target.path_ndk, "sources", "cxx-stl", "gnu-libstdc++", target.compilator_version, "libs", "armeabi-v7a")
+				self.add_export_path(        os.path.join(stdCppBasePath, "include"))
+				self.add_export_flag("link", os.path.join(stdCppBasePath, "thumb", "libgnustl_static.a"))
+				self.add_export_flag("link", os.path.join(stdCppBasePath, "thumb", "libsupc++.a"))
+			elif target.type_arch == "mips":
+				stdCppBasePath = os.path.join(target.path_ndk, "sources", "cxx-stl", "gnu-libstdc++", target.compilator_version, "libs", "mips")
+				self.add_export_path(        os.path.join(stdCppBasePath, "include/"))
+				self.add_export_flag("link", os.path.join(stdCppBasePath, "libgnustl_static.a"))
+				self.add_export_flag("link", os.path.join(stdCppBasePath, "libsupc++.a"))
+			elif target.type_arch == "x86":
+				stdCppBasePath = os.path.join(target.path_ndk, "sources", "cxx-stl", "gnu-libstdc++", target.compilator_version, "libs", "x86")
+				self.add_export_path(        os.path.join(stdCppBasePath, "include"))
+				self.add_export_flag("link", os.path.join(stdCppBasePath, "libgnustl_static.a"))
+				self.add_export_flag("link", os.path.join(stdCppBasePath, "libsupc++.a"))
+			else:
+				debug.warning("unknow architecture: '" + str(target.arch) + "'");
+			debug.warning("plop")

lutin/z_system/lutinSystem_Android_m.py

@@ -0,0 +1,27 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @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
+from lutin import env
+import os
+
+class System(system.System):
+	def __init__(self, target):
+		system.System.__init__(self)
+		# create some HELP:
+		self.help="M : m library \n base of std libs (availlagle in GNU C lib and bionic"
+		# No check ==> on the basic std libs:
+		self.valid = True
+		# todo : create a searcher of the presence of the library:
+		self.add_export_flag("link-lib", "m")
+
+

lutin/z_system/lutinSystem_Android_opengl.py

@@ -0,0 +1,36 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @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
+from lutin import env
+import os
+
+class System(system.System):
+	def __init__(self, target):
+		system.System.__init__(self)
+		# create some HELP:
+		self.help = "OpenGL: Generic graphic library"
+		self.valid = True
+		# no check needed ==> just add this:
+		self.add_module_depend([
+		    'c',
+		    ])
+		"""
+		self.add_header_file([
+		    "/usr/include/GL/*"
+		    ],
+		    destination_path="GL",
+		    recursive=True)
+		"""
+		self.add_export_flag('link-lib', "GLESv2")
+
+

lutin/z_system/lutinSystem_Android_pthread.py

@@ -0,0 +1,35 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @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
+from lutin import env
+import os
+
+class System(system.System):
+	def __init__(self, target):
+		system.System.__init__(self)
+		# create some HELP:
+		self.help="pthread : Generic multithreading system\n Can be install with the package:\n    - pthread-dev"
+		# check if the library exist:
+		"""
+		if     not os.path.isfile("/usr/include/pthread.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", "pthread")
+		self.add_module_depend([
+		    'c'
+		    ])
+
+

lutin/z_system/lutinSystem_Android_z.py

@@ -0,0 +1,29 @@
+#!/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
+from lutin import env
+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_system/lutinSystem_IOs_CoreAudio.py

@@ -1,4 +1,5 @@
 #!/usr/bin/python
+# -*- coding: utf-8 -*-
 ##
 ## @author Edouard DUPIN
 ##
@@ -10,6 +11,7 @@
 from lutin import debug
 from lutin import system
 from lutin import tools
+from lutin import env
 import os
 
 class System(system.System):
@@ -19,7 +21,7 @@ class System(system.System):
 		self.help="CoreAudio : Ios interface for audio (all time present, just system interface)"
 		self.valid = True
 		# todo : create a searcher of the presence of the library:
-		self.add_export_flag_LD("-framework CoreAudio")
-		self.add_export_flag_LD("-framework AudioToolbox")
+		self.add_export_flag("link", "-framework CoreAudio")
+		self.add_export_flag("link", "-framework AudioToolbox")
 
 

lutin/z_system/lutinSystem_IOs_cxx.py

@@ -0,0 +1,28 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @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
+from lutin import env
+import os
+
+class System(system.System):
+	def __init__(self, target):
+		system.System.__init__(self)
+		# create some HELP:
+		self.help = "CXX: Generic C++ library"
+		self.valid = True
+		# no check needed ==> just add this:
+		self.add_export_flag("c++", "-D__STDCPP_LLVM__")
+		self.add_export_flag("c++-remove", "-nostdlib")
+		self.add_export_flag("need-libstdc++", True)
+
+

lutin/z_system/lutinSystem_IOs_m.py

@@ -0,0 +1,27 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @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
+from lutin import env
+import os
+
+class System(system.System):
+	def __init__(self, target):
+		system.System.__init__(self)
+		# create some HELP:
+		self.help="M : m library \n base of std libs (availlagle in GNU C lib and bionic"
+		# No check ==> on the basic std libs:
+		self.valid = True
+		# todo : create a searcher of the presence of the library:
+		self.add_export_flag("link-lib", "m")
+
+

lutin/z_system/lutinSystem_Linux_X11.py

@@ -0,0 +1,33 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @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
+from lutin import env
+import os
+
+class System(system.System):
+	def __init__(self, target):
+		system.System.__init__(self)
+		# create some HELP:
+		self.help = "X11: Basic interface of Linux Graphic interface"
+		self.valid = True
+		# no check needed ==> just add this:
+		self.add_module_depend(['c'])
+		self.add_export_flag('link-lib', 'X11')
+		if env.get_isolate_system() == False:
+			self.add_header_file([
+			    "/usr/include/X11/*"
+			    ],
+			    destination_path="X11",
+			    recursive=True)
+
+

lutin/z_system/lutinSystem_Linux_alsa.py

@@ -1,4 +1,5 @@
 #!/usr/bin/python
+# -*- coding: utf-8 -*-
 ##
 ## @author Edouard DUPIN
 ##
@@ -10,6 +11,7 @@
 from lutin import debug
 from lutin import system
 from lutin import tools
+from lutin import env
 import os
 
 class System(system.System):
@@ -23,7 +25,22 @@ class System(system.System):
 			# 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_LD("-lasound")
+		if env.get_isolate_system() == False:
+			self.add_export_flag("link-lib", "asound")
+		else:
+			self.add_export_flag("link-lib", "asound")
+			self.add_header_file([
+			    "/usr/include/alsa/*",
+			    ],
+			    destination_path="alsa",
+			    recursive=True)
+			self.add_header_file([
+			    "/usr/include/dssi/*",
+			    ],
+			    destination_path="dssi",
+			    recursive=True)
+			self.add_module_depend([
+			    'c'
+			    ])
 
 

lutin/z_system/lutinSystem_Linux_arpa.py

@@ -0,0 +1,41 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @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
+from lutin import env
+import os
+
+class System(system.System):
+	def __init__(self, target):
+		system.System.__init__(self)
+		# create some HELP:
+		self.help="rpc : generic RPC library (developed by oracle)"
+		# check if the library exist:
+		if not os.path.isfile("/usr/include/arpa/ftp.h"):
+			# we did not find the library reqiested (just return) (automaticly set at false)
+			return;
+		# No check ==> on the basic std libs:
+		self.valid = True
+		if env.get_isolate_system() == True:
+			#self.add_export_flag("link-lib", "xns")
+			self.add_header_file([
+			    "/usr/include/arpa/*"
+			    ],
+			    destination_path="arpa",
+			    recursive=True)
+			self.add_module_depend([
+			    'c'
+			    ])
+		
+
+
+

lutin/z_system/lutinSystem_Linux_boost.py

@@ -1,4 +1,5 @@
 #!/usr/bin/python
+# -*- coding: utf-8 -*-
 ##
 ## @author Edouard DUPIN
 ##
@@ -10,6 +11,7 @@
 from lutin import debug
 from lutin import system
 from lutin import tools
+from lutin import env
 import os
 
 class System(system.System):
@@ -22,12 +24,22 @@ class System(system.System):
 			# 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_LD([
-		    "-lboost_system",
-		    "-lboost_thread",
-		    "-lboost_chrono"
-		    ])
+		if env.get_isolate_system() == False:
+			# todo : create a searcher of the presence of the library:
+			self.add_export_flag("link-lib", [
+			    "boost_system",
+			    "boost_thread",
+			    "boost_chrono"
+			    ])
+		else:
+			self.add_header_file([
+			    "/usr/include/boost/*"
+			    ],
+			    destination_path="boost",
+			    recursive=True)
+			self.add_module_depend([
+			    'cxx'
+			    ])
 		
 
 

lutin/z_system/lutinSystem_Linux_c.py

@@ -0,0 +1,175 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @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
+from lutin import env
+import os
+
+class System(system.System):
+	def __init__(self, target):
+		system.System.__init__(self)
+		# create some HELP:
+		self.help = "C: Generic C library"
+		self.valid = True
+		if env.get_isolate_system() == False:
+			# We must have it ... all time
+			pass
+		else:
+			# grep "This file is part of the GNU C Library" /usr/include/*
+			self.add_header_file([
+			    '/usr/include/aio.h*',
+			    '/usr/include/aliases.h*',
+			    '/usr/include/alloca.h*',
+			    '/usr/include/ansidecl.h*',
+			    '/usr/include/argp.h*',
+			    '/usr/include/argz.h*',
+			    '/usr/include/ar.h*',
+			    '/usr/include/assert.h*',
+			    '/usr/include/byteswap.h*',
+			    '/usr/include/complex.h*',
+			    '/usr/include/cpio.h*',
+			    '/usr/include/ctype.h*',
+			    '/usr/include/dirent.h*',
+			    '/usr/include/dlfcn.h*',
+			    '/usr/include/elf.h*',
+			    '/usr/include/endian.h*',
+			    '/usr/include/envz.h*',
+			    '/usr/include/err.h*',
+			    '/usr/include/errno.h*',
+			    '/usr/include/error.h*',
+			    '/usr/include/execinfo.h*',
+			    '/usr/include/fcntl.h*',
+			    '/usr/include/features.h*',
+			    '/usr/include/fenv.h*',
+			    '/usr/include/fmtmsg.h*',
+			    '/usr/include/fnmatch.h*',
+			    '/usr/include/fpu_control.h*',
+			    '/usr/include/fts.h*',
+			    '/usr/include/ftw.h*',
+			    '/usr/include/gconv.h*',
+			    '/usr/include/getopt.h*',
+			    '/usr/include/glob.h*',
+			    '/usr/include/gnu-versions.h*',
+			    '/usr/include/grp.h*',
+			    '/usr/include/gshadow.h*',
+			    '/usr/include/iconv.h*',
+			    '/usr/include/ieee754.h*',
+			    '/usr/include/ifaddrs.h*',
+			    '/usr/include/inttypes.h*',
+			    '/usr/include/langinfo.h*',
+			    '/usr/include/libgen.h*',
+			    '/usr/include/libintl.h*',
+			    '/usr/include/libio.h*',
+			    '/usr/include/limits.h*',
+			    '/usr/include/link.h*',
+			    '/usr/include/locale.h*',
+			    '/usr/include/malloc.h*',
+			    '/usr/include/mcheck.h*',
+			    '/usr/include/memory.h*',
+			    '/usr/include/mntent.h*',
+			    '/usr/include/monetary.h*',
+			    '/usr/include/mqueue.h*',
+			    '/usr/include/netdb.h*',
+			    '/usr/include/nl_types.h*',
+			    '/usr/include/nss.h*',
+			    '/usr/include/obstack.h*',
+			    '/usr/include/printf.h*',
+			    '/usr/include/pthread.h*',
+			    '/usr/include/pty.h*',
+			    '/usr/include/pwd.h*',
+			    '/usr/include/re_comp.h*',
+			    '/usr/include/regex.h*',
+			    '/usr/include/regexp.h*',
+			    '/usr/include/sched.h*',
+			    '/usr/include/search.h*',
+			    '/usr/include/semaphore.h*',
+			    '/usr/include/setjmp.h*',
+			    '/usr/include/sgtty.h*',
+			    '/usr/include/shadow.h*',
+			    '/usr/include/signal.h*',
+			    '/usr/include/spawn.h*',
+			    '/usr/include/stdc-predef.h*',
+			    '/usr/include/stdint.h*',
+			    '/usr/include/stdio_ext.h*',
+			    '/usr/include/stdio.h*',
+			    '/usr/include/stdlib.h*',
+			    '/usr/include/string.h*',
+			    '/usr/include/strings.h*',
+			    '/usr/include/stropts.h*',
+			    '/usr/include/tar.h*',
+			    '/usr/include/termios.h*',
+			    '/usr/include/tgmath.h*',
+			    '/usr/include/thread_db.h*',
+			    '/usr/include/time.h*',
+			    '/usr/include/uchar.h*',
+			    '/usr/include/ucontext.h*',
+			    '/usr/include/ulimit.h*',
+			    '/usr/include/unistd.h*',
+			    '/usr/include/utime.h*',
+			    '/usr/include/utmp.h*',
+			    '/usr/include/utmpx.h*',
+			    '/usr/include/values.h*',
+			    '/usr/include/wchar.h*',
+			    '/usr/include/wctype.h*',
+			    '/usr/include/wordexp.h*',
+			    '/usr/include/xlocale.h*',
+			    ],
+			    destination_path="")
+			self.add_header_file([
+			    '/usr/include/poll.h*',
+			    '/usr/include/unistdio.h*',
+			    '/usr/include/syslog.h*',
+			    '/usr/include/_G_config.h*',
+			    ],
+			    destination_path="")
+			self.add_header_file([
+			    "/usr/include/sys/*",
+			    ],
+			    destination_path="sys",
+			    recursive=True)
+			self.add_header_file([
+			    "/usr/include/bits/*",
+			    ],
+			    destination_path="bits",
+			    recursive=True)
+			self.add_header_file([
+			    "/usr/include/gnu/*",
+			    ],
+			    destination_path="gnu",
+			    recursive=True)
+			self.add_header_file([
+			    "/usr/include/linux/*",
+			    ],
+			    destination_path="linux",
+			    recursive=True)
+			self.add_header_file([
+			    "/usr/include/asm/*",
+			    ],
+			    destination_path="asm",
+			    recursive=True)
+			self.add_header_file([
+			    "/usr/include/asm-generic/*",
+			    ],
+			    destination_path="asm-generic",
+			    recursive=True)
+			self.add_header_file([
+			    "/usr/include/netinet/*",
+			    ],
+			    destination_path="netinet",
+			    recursive=True)
+			self.add_header_file([
+			    "/usr/include/net/*",
+			    ],
+			    destination_path="net",
+			    recursive=True)
+			self.add_export_flag("link", "-B/usr/lib")
+

lutin/z_system/lutinSystem_Linux_cxx.py

@@ -0,0 +1,50 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @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
+from lutin import multiprocess
+from lutin import env
+import os
+
+class System(system.System):
+	def __init__(self, target):
+		system.System.__init__(self)
+		# create some HELP:
+		self.help = "CXX: Generic C++ library"
+		self.valid = True
+		# no check needed ==> just add this:
+		self.add_module_depend([
+		    'c',
+		    'm',
+		    'pthread'
+		    ])
+		self.add_export_flag("c++", "-D__STDCPP_GNU__")
+		if env.get_isolate_system() == False:
+			self.add_export_flag("c++-remove", "-nostdlib")
+			self.add_export_flag("need-libstdc++", True)
+		else:
+			self.add_export_flag("link-lib", "stdc++")
+			compilator_gcc = "g++"
+			if target.config["compilator-version"] != "":
+				compilator_gcc = compilator_gcc + "-" + target.config["compilator-version"]
+			
+			#get g++ compilation version :
+			version_cpp = multiprocess.run_command_direct(compilator_gcc + " -dumpversion");
+			if version_cpp == False:
+				debug.error("Can not get the g++ version ...")
+			
+			self.add_header_file([
+			    "/usr/include/c++/" + version_cpp + "/*"
+			    ],
+			    recursive=True)
+
+

lutin/z_system/lutinSystem_Linux_jack.py

@@ -1,4 +1,5 @@
 #!/usr/bin/python
+# -*- coding: utf-8 -*-
 ##
 ## @author Edouard DUPIN
 ##
@@ -10,6 +11,7 @@
 from lutin import debug
 from lutin import system
 from lutin import tools
+from lutin import env
 import os
 
 class System(system.System):
@@ -22,7 +24,16 @@ class System(system.System):
 			# 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_LD("-ljack")
+		self.add_module_depend([
+		    'uuid',
+		    'c'
+		    ])
+		self.add_export_flag("link-lib", "jack")
+		if env.get_isolate_system() == True:
+			self.add_header_file([
+			    "/usr/include/jack/*",
+			    ],
+			    destination_path="jack",
+			    recursive=True)
 
 

lutin/z_system/lutinSystem_Linux_m.py

@@ -0,0 +1,37 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @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
+from lutin import env
+import os
+
+class System(system.System):
+	def __init__(self, target):
+		system.System.__init__(self)
+		# create some HELP:
+		self.help="M : m library \n base of std libs (availlagle in GNU C lib and bionic"
+		# No check ==> on the basic std libs:
+		self.valid = True
+		# todo : create a searcher of the presence of the library:
+		self.add_export_flag("link-lib", "m")
+		self.add_module_depend([
+		    'c'
+		    ])
+		if env.get_isolate_system() == True:
+			self.add_header_file([
+			    "/usr/include/math.h"
+			    ],
+			    clip_path="/usr/include",
+			    recursive=False)
+
+
+

lutin/z_system/lutinSystem_Linux_opengl.py

@@ -0,0 +1,54 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @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
+from lutin import env
+import os
+
+class System(system.System):
+	def __init__(self, target):
+		system.System.__init__(self)
+		# create some HELP:
+		self.help = "OpenGL: Generic graphic library"
+		self.valid = True
+		# no check needed ==> just add this:
+		self.add_module_depend([
+		    'c',
+		    'X11'
+		    ])
+		self.add_export_flag('link-lib', 'GL')
+		if env.get_isolate_system() == True:
+				self.add_header_file([
+			    "/usr/include/GL/*"
+			    ],
+			    destination_path="GL",
+			    recursive=True)
+		
+		"""
+		if target.name=="Linux":
+			
+		elif target.name=="Android":
+			my_module.add_export_flag('link-lib', "GLESv2")
+		elif target.name=="Windows":
+			my_module.add_module_depend([
+			    "glew"
+			    ])
+		elif target.name=="MacOs":
+			my_module.add_export_flag('link', [
+			    "-framework OpenGL"])
+		elif target.name=="IOs":
+			my_module.add_export_flag('link', [
+			    "-framework OpenGLES"
+			    ])
+		"""
+
+

lutin/z_system/lutinSystem_Linux_oss.py

@@ -1,4 +1,5 @@
 #!/usr/bin/python
+# -*- coding: utf-8 -*-
 ##
 ## @author Edouard DUPIN
 ##
@@ -10,6 +11,7 @@
 from lutin import debug
 from lutin import system
 from lutin import tools
+from lutin import env
 import os
 
 class System(system.System):
@@ -24,7 +26,7 @@ class System(system.System):
 			return;
 		self.valid = True
 		# todo : create a searcher of the presence of the library:
-		self.add_export_flag_CC("-ljack")
+		self.add_export_flag("link-lib", "oss")
 		"""
 
 

lutin/z_system/lutinSystem_Linux_pthread.py

@@ -0,0 +1,39 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @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
+from lutin import env
+import os
+
+class System(system.System):
+	def __init__(self, target):
+		system.System.__init__(self)
+		# create some HELP:
+		self.help="pthread : Generic multithreading system\n Can be install with the package:\n    - pthread-dev"
+		# check if the library exist:
+		if     not os.path.isfile("/usr/include/pthread.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", "pthread")
+		self.add_module_depend([
+		    'c'
+		    ])
+		if env.get_isolate_system() == True:
+			self.add_header_file([
+			    "/usr/include/sched.h",
+			    "/usr/include/pthread.h"
+			    ],
+			    clip_path="/usr/include/")
+
+

lutin/z_system/lutinSystem_Linux_pulse.py

@@ -1,4 +1,5 @@
 #!/usr/bin/python
+# -*- coding: utf-8 -*-
 ##
 ## @author Edouard DUPIN
 ##
@@ -10,6 +11,7 @@
 from lutin import debug
 from lutin import system
 from lutin import tools
+from lutin import env
 import os
 
 class System(system.System):
@@ -21,8 +23,43 @@ class System(system.System):
 		if     not os.path.isfile("/usr/include/pulse/pulseaudio.h"):
 			# we did not find the library reqiested (just return) (automaticly set at false)
 			return;
+		dst_data = tools.file_read_data("/usr/include/pulse/version.h")
+		lines = dst_data.split("\n")
+		patern = "#define pa_get_headers_version() (\""
+		version = None
+		for line in lines:
+			if line[:len(patern)] == patern:
+				#Find the version line
+				version = line[len(patern)]
+				version2 = line[len(patern)+2]
+				debug.verbose("detect version '" + version + "'")
+				break;
+		if version == None:
+			debug.warning("Can not det version of Pulseaudio ... ==> remove it")
+			return
+		self.set_version([int(version),int(version2)])
 		self.valid = True
-		# todo : create a searcher of the presence of the library:
-		self.add_export_flag_LD(["-lpulse-simple", "-lpulse"])
+		self.add_module_depend([
+		    'c'
+		    ])
+		if env.get_isolate_system() == False:
+			self.add_export_flag("link-lib", [
+			    "pulse-simple",
+			    "pulse"
+			    ])
+		else:
+			# todo : create a searcher of the presence of the library:
+			self.add_export_flag("link-lib", [
+			    "pulsecommon-" + version + ".0",
+			    "pulse-mainloop-glib",
+			    "pulse-simple",
+			    "pulse"
+			    ])
+			self.add_export_flag("link", "-L/usr/lib/pulseaudio")
+			self.add_header_file([
+			    "/usr/include/pulse/*",
+			    ],
+			    destination_path="pulse",
+			    recursive=True)
 
 

lutin/z_system/lutinSystem_Linux_rpc.py

@@ -0,0 +1,38 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @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
+from lutin import env
+import os
+
+class System(system.System):
+	def __init__(self, target):
+		system.System.__init__(self)
+		# create some HELP:
+		self.help="rpc : generic RPC library (developed by oracle)"
+		# No check ==> on the basic std libs:
+		self.valid = True
+		self.add_module_depend([
+		    'c'
+		    ])
+		# todo : create a searcher of the presence of the library:
+		self.add_export_flag("link-lib", "rpcsvc")
+		if env.get_isolate_system() == False:
+			self.add_header_file([
+			    "/usr/include/rpc/*"
+			    ],
+			    destination_path="rpc",
+			    recursive=True)
+		
+
+
+

lutin/z_system/lutinSystem_Linux_uuid.py

@@ -0,0 +1,39 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @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
+from lutin import env
+import os
+
+class System(system.System):
+	def __init__(self, target):
+		system.System.__init__(self)
+		# create some HELP:
+		self.help="uuid: Unique ID library"
+		# check if the library exist:
+		if     not os.path.isfile("/usr/include/uuid/uuid.h"):
+			# we did not find the library reqiested (just return) (automaticly set at false)
+			return;
+		self.valid = True
+		self.add_module_depend([
+		    'c'
+		    ])
+		# todo : create a searcher of the presence of the library:
+		self.add_export_flag("link-lib", "uuid")
+		if env.get_isolate_system() == False:
+			self.add_header_file([
+			    "/usr/include/uuid/*",
+			    ],
+			    destination_path="uuid",
+			    recursive=True)
+
+

lutin/z_system/lutinSystem_Linux_z.py

@@ -1,4 +1,5 @@
 #!/usr/bin/python
+# -*- coding: utf-8 -*-
 ##
 ## @author Edouard DUPIN
 ##
@@ -10,6 +11,7 @@
 from lutin import debug
 from lutin import system
 from lutin import tools
+from lutin import env
 import os
 
 class System(system.System):
@@ -23,6 +25,15 @@ class System(system.System):
 			return;
 		self.valid = True
 		# todo : create a searcher of the presence of the library:
-		self.add_export_flag_LD(["-lz"])
+		self.add_export_flag("link-lib", "z")
+		self.add_module_depend([
+		    'c'
+		    ])
+		    
+		if env.get_isolate_system() == False:
+			self.add_header_file([
+			    "/usr/include/zlib.h"
+			    ],
+			    destination_path="")
 
 

lutin/z_system/lutinSystem_MacOs_CoreAudio.py

@@ -1,4 +1,5 @@
 #!/usr/bin/python
+# -*- coding: utf-8 -*-
 ##
 ## @author Edouard DUPIN
 ##
@@ -10,6 +11,7 @@
 from lutin import debug
 from lutin import system
 from lutin import tools
+from lutin import env
 import os
 
 class System(system.System):
@@ -19,6 +21,6 @@ class System(system.System):
 		self.help="CoreAudio : MacOs interface for audio (all time present, just system interface)"
 		self.valid = True
 		# todo : create a searcher of the presence of the library:
-		self.add_export_flag_LD("-framework CoreAudio")
-		self.add_export_flag_LD("-framework CoreFoundation")
+		self.add_export_flag("link", "-framework CoreAudio")
+		self.add_export_flag("link", "-framework CoreFoundation")
 

lutin/z_system/lutinSystem_MacOs_cxx.py

@@ -0,0 +1,28 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @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
+from lutin import env
+import os
+
+class System(system.System):
+	def __init__(self, target):
+		system.System.__init__(self)
+		# create some HELP:
+		self.help = "CXX: Generic C++ library"
+		self.valid = True
+		# no check needed ==> just add this:
+		self.add_export_flag("c++","-D__STDCPP_LLVM__")
+		self.add_export_flag("c++-remove","-nostdlib")
+		self.add_export_flag("need-libstdc++", True)
+
+

lutin/z_system/lutinSystem_MacOs_m.py

@@ -0,0 +1,27 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @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
+from lutin import env
+import os
+
+class System(system.System):
+	def __init__(self, target):
+		system.System.__init__(self)
+		# create some HELP:
+		self.help="M : m library \n base of std libs (availlagle in GNU C lib and bionic"
+		# No check ==> on the basic std libs:
+		self.valid = True
+		# todo : create a searcher of the presence of the library:
+		self.add_export_flag("link-lib", "m")
+
+

lutin/z_system/lutinSystem_Windows_asio.py

@@ -0,0 +1,9 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##

lutin/z_system/lutinSystem_Windows_cxx.py

@@ -0,0 +1,34 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @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
+from lutin import env
+import os
+
+class System(system.System):
+	def __init__(self, target):
+		system.System.__init__(self)
+		# create some HELP:
+		self.help = "CXX: Generic C++ library"
+		self.valid = True
+		# no check needed ==> just add this:
+		self.add_export_flag("c++","-D__STDCPP_GNU__")
+		self.add_export_flag("c++-remove","-nostdlib")
+		# force static link to prenvent many errors ...
+		self.add_export_flag("link", [
+		    "-static-libgcc",
+		    "-static-libstdc++",
+		    "-static"
+		    ])
+		self.add_export_flag("need-libstdc++", True)
+
+

lutin/z_system/lutinSystem_Windows_ds.py

@@ -1,4 +1,5 @@
 #!/usr/bin/python
+# -*- coding: utf-8 -*-
 ##
 ## @author Edouard DUPIN
 ##
@@ -10,6 +11,7 @@
 from lutin import debug
 from lutin import system
 from lutin import tools
+from lutin import env
 import os
 
 class System(system.System):
@@ -23,9 +25,10 @@ class System(system.System):
 			return;
 		self.valid = True
 		# todo : create a searcher of the presence of the library:
-		self.add_export_flag_LD(["-ldsound",
-		                         "-lwinmm",
-		                         "-lole32"
-		                         ])
+		self.add_export_flag("link-lib",[
+		    "dsound",
+		    "winmm",
+		    "ole32"
+		    ])
 
 

lutin/z_system/lutinSystem_Windows_m.py

@@ -0,0 +1,27 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @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
+from lutin import env
+import os
+
+class System(system.System):
+	def __init__(self, target):
+		system.System.__init__(self)
+		# create some HELP:
+		self.help="M : m library \n base of std libs (availlagle in GNU C lib and bionic"
+		# No check ==> on the basic std libs:
+		self.valid = True
+		# todo : create a searcher of the presence of the library:
+		self.add_export_flag("link-lib", "m")
+
+

lutin/z_target/__init__.py

@@ -0,0 +1,9 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##

lutin/z_target/lutinTarget_Android.py

@@ -1,4 +1,5 @@
 #!/usr/bin/python
+# -*- coding: utf-8 -*-
 ##
 ## @author Edouard DUPIN
 ##
@@ -7,7 +8,6 @@
 ## @license APACHE v2.0 (see license file)
 ##
 
-
 from lutin import debug
 from lutin import target
 from lutin import tools
@@ -25,13 +25,13 @@ class Target(target.Target):
 		#bus size selection (auto/32/64)
 		if config["bus-size"] == "auto":
 			config["bus-size"] = "32"
-		arch = ""
-		target.Target.__init__(self, "Android", config, arch)
+		self.type_arch = ""
+		target.Target.__init__(self, "Android", config, self.type_arch)
 		
 		if config["bus-size"] == "32":
-			arch="armv7"
+			self.type_arch="armv7"
 		else:
-			arch="arm64"
+			self.type_arch="arm64"
 		
 		self.path_ndk = os.getenv('PROJECT_NDK', "AUTO")
 		self.path_sdk = os.getenv('PROJECT_SDK', "AUTO")
@@ -60,10 +60,14 @@ class Target(target.Target):
 		
 		tmpOsVal = "64"
 		gccVersion = "4.9"
+		# TODO : Remove this or set it better ...
+		self.compilator_version = gccVersion
 		if host.BUS_SIZE==64:
 			tmpOsVal = "_64"
 		if self.config["compilator"] == "clang":
 			self.set_cross_base(self.path_ndk + "/toolchains/llvm-3.6/prebuilt/linux-x86" + tmpOsVal + "/bin/")
+			# Patch for LLVM AR tool
+			self.ar = self.cross + "llvm-ar"
 		else:
 			basepathArm = self.path_ndk + "/toolchains/arm-linux-androideabi-" + gccVersion + "/prebuilt/linux-x86" + tmpOsVal + "/bin/"
 			basepathMips = self.path_ndk + "/toolchains/mipsel-linux-android-" + gccVersion + "/prebuilt/linux-x86" + tmpOsVal + "/bin/"
@@ -87,120 +91,121 @@ class Target(target.Target):
 		self.pkg_path_lib = "data/lib/armeabi"
 		self.pkg_path_license = "license"
 		
-		# board id at 15 is for android 4.0.3 and more ... (note: API 14 has been removed ...)
-		self.boardId = 15
-		self.global_flags_cc.append("-D__ANDROID_BOARD_ID__=" + str(self.boardId))
-		if arch == "armv5" or arch == "armv7":
-			self.global_include_cc.append("-I" + self.path_ndk +"/platforms/android-" + str(self.boardId) + "/arch-arm/usr/include/")
-		elif arch == "mips":
-			self.global_include_cc.append("-I" + self.path_ndk +"/platforms/android-" + str(self.boardId) + "/arch-mips/usr/include/")
-		elif arch == "x86":
-			self.global_include_cc.append("-I" + self.path_ndk +"/platforms/android-" + str(self.boardId) + "/arch-x86/usr/include/")
+		# If the env variable is not define, find the newest version of the BOARD_ID (Note: 0: autofind)
+		self.board_id = int(os.getenv('PROJECT_NDK_BOARD_ID', "0"))
+		if self.board_id != 0:
+			# check if element existed :
+			if not os.path.isdir(self.path_sdk +"/platforms/android-" + str(self.board_id)):
+				debug.error("Specify PROJECT_NDK_BOARD_ID env variable and the BOARD_ID does not exit ... : " + str(self.board_id) + "==> auto-search")
+				self.board_id = 0
+		if self.board_id == 0:
+			debug.debug("Auto-search BOARD-ID")
+			for iii in reversed(range(0, 50)):
+				debug.debug("try: " + os.path.join(self.path_sdk, "platforms", "android-" + str(iii)))
+				if os.path.isdir(os.path.join(self.path_sdk, "platforms", "android-" + str(iii))):
+					debug.debug("Find BOARD-ID : " + str(iii))
+					self.board_id = iii
+					break;
+		if self.board_id == 0:
+			debug.error("Can not find BOARD-ID ==> update your android SDK")
 		
-		if True:
-			if self.config["compilator"] == "clang":
-				if self.boardId < 21:
-					debug.error("Clang work only with the board wersion >= 21 : android 5.x.x")
-				self.global_flags_cc.append("-D__STDCPP_LLVM__")
-				# llvm-libc++ : BSD | MIT
-				self.global_include_cc.append("-gcc-toolchain " + self.path_ndk +"/sources/android/support/include")
-				self.global_include_cc.append("-I" + self.path_ndk +"/sources/android/support/include")
-				self.global_include_cc.append("-I" + self.path_ndk +"/sources/cxx-stl/llvm-libc++/libcxx/include/")
-				if arch == "armv5":
-					stdCppBasePath = self.path_ndk +"/sources/cxx-stl/llvm-libc++/libcxx/libs/armeabi/"
-					self.global_include_cc.append("-I" + stdCppBasePath + "include/")
-					self.global_flags_ld.append(         stdCppBasePath + "libc++_static.a")
-				elif arch == "armv7":
-					# The only one tested ... ==> but we have link error ...
-					self.global_flags_cc.append("-target armv7-none-linux-androideabi")
-					self.global_flags_cc.append("-march=armv7-a")
-					self.global_flags_cc.append("-mfpu=vfpv3-d16")
-					self.global_flags_cc.append("-mhard-float")
-					stdCppBasePath = self.path_ndk +"/sources/cxx-stl/llvm-libc++/libs/armeabi-v7a/"
-					self.global_flags_ld.append(         stdCppBasePath + "thumb/libc++_static.a")
-					self.global_flags_ld.append("-target armv7-none-linux-androideabi")
-					self.global_flags_ld.append("-Wl,--fix-cortex-a8")
-					self.global_flags_ld.append("-Wl,--no-warn-mismatch")
-					self.global_flags_ld.append("-lm_hard")
-				elif arch == "mips":
-					stdCppBasePath = self.path_ndk +"/sources/cxx-stl/llvm-libc++/libcxx/libs/mips/"
-					self.global_include_cc.append("-I" + stdCppBasePath + "include/")
-					self.global_flags_ld.append(         stdCppBasePath + "libc++_static.a")
-				elif arch == "x86":
-					stdCppBasePath = self.path_ndk +"/sources/cxx-stl/llvm-libc++/libcxx/libs/x86/"
-					self.global_include_cc.append("-I" + stdCppBasePath + "include/")
-					self.global_flags_ld.append(         stdCppBasePath + "libc++_static.a")
-			else:
-				self.global_flags_cc.append("-D__STDCPP_GNU__")
-				# GPL v3 (+ exception link for gcc compilator)
-				self.global_include_cc.append("-I" + self.path_ndk +"/sources/cxx-stl/gnu-libstdc++/" + gccVersion + "/include/")
-				self.global_include_cc.append("-I" + self.path_ndk +"/sources/android/support/include/")
-				if arch == "armv5":
-					stdCppBasePath = self.path_ndk +"/sources/cxx-stl/gnu-libstdc++/" + gccVersion + "/libs/armeabi/"
-					self.global_include_cc.append("-I" + stdCppBasePath + "include/")
-					self.global_flags_ld.append(         stdCppBasePath + "thumb/libgnustl_static.a")
-					self.global_flags_ld.append(         stdCppBasePath + "thumb/libsupc++.a")
-				elif arch == "armv7":
-					stdCppBasePath = self.path_ndk +"/sources/cxx-stl/gnu-libstdc++/" + gccVersion + "/libs/armeabi-v7a/"
-					self.global_include_cc.append("-I" + stdCppBasePath + "include/")
-					self.global_flags_ld.append(         stdCppBasePath + "thumb/libgnustl_static.a")
-					self.global_flags_ld.append(         stdCppBasePath + "thumb/libsupc++.a")
-				elif arch == "mips":
-					stdCppBasePath = self.path_ndk +"/sources/cxx-stl/gnu-libstdc++/" + gccVersion + "/libs/mips/"
-					self.global_include_cc.append("-I" + stdCppBasePath + "include/")
-					self.global_flags_ld.append(         stdCppBasePath + "libgnustl_static.a")
-					self.global_flags_ld.append(         stdCppBasePath + "libsupc++.a")
-				elif arch == "x86":
-					stdCppBasePath = self.path_ndk +"/sources/cxx-stl/gnu-libstdc++/" + gccVersion + "/libs/x86/"
-					self.global_include_cc.append("-I" + stdCppBasePath + "include/")
-					self.global_flags_ld.append(         stdCppBasePath + "libgnustl_static.a")
-					self.global_flags_ld.append(         stdCppBasePath + "libsupc++.a")
-		else :
-			self.global_include_cc.append("-I" + self.path_ndk +"/sources/cxx-stl/system/include/")
-			self.global_include_cc.append("-I" + self.path_ndk +"/sources/cxx-stl/stlport/stlport/")
-			self.global_flags_ld.append(self.path_ndk +"/platforms/android-" + str(self.boardId) + "/arch-arm/usr/lib/libstdc++.a")
+		self.add_flag("c", "-D__ANDROID_BOARD_ID__=" + str(self.board_id))
+		if self.type_arch == "armv5" or self.type_arch == "armv7":
+			self.global_include_cc.append("-I" + os.path.join(self.path_ndk, "platforms", "android-" + str(self.board_id), "arch-arm", "usr", "include"))
+		elif self.type_arch == "mips":
+			self.global_include_cc.append("-I" + os.path.join(self.path_ndk, "platforms", "android-" + str(self.board_id), "arch-mips", "usr", "include"))
+		elif self.type_arch == "x86":
+			self.global_include_cc.append("-I" + os.path.join(self.path_ndk, "platforms", "android-" + str(self.board_id), "arch-x86", "usr", "include"))
 		
-		self.global_sysroot = "--sysroot=" + self.path_ndk +"/platforms/android-" + str(self.boardId) + "/arch-arm"
+		self.global_include_cc.append("-I" + os.path.join(self.path_ndk, "sources", "android", "support", "include"))
 		
-		self.global_flags_cc.append("-D__ARM_ARCH_5__")
-		self.global_flags_cc.append("-D__ARM_ARCH_5T__")
-		self.global_flags_cc.append("-D__ARM_ARCH_5E__")
-		self.global_flags_cc.append("-D__ARM_ARCH_5TE__")
+		if self.config["compilator"] == "clang":
+			self.global_include_cc.append("-gcc-toolchain " + os.path.join(self.path_ndk, "sources", "android", "support", "include"))
+			if self.type_arch == "armv5":
+				pass
+			elif self.type_arch == "armv7":
+				# The only one tested ... ==> but we have link error ...
+				self.add_flag("c", [
+				    "-target armv7-none-linux-androideabi",
+				    "-march=armv7-a",
+				    "-mfpu=vfpv3-d16",
+				    "-mhard-float"
+				    ])
+				self.add_flag("link", [
+				    "-target armv7-none-linux-androideabi",
+				    "-Wl,--fix-cortex-a8",
+				    "-Wl,--no-warn-mismatch",
+				    "-lm_hard"
+				    ])
+			elif self.type_arch == "mips":
+				pass
+			elif self.type_arch == "x86":
+				pass
+		else:
+			if self.type_arch == "armv5":
+				pass
+			elif self.type_arch == "armv7":
+				pass
+			elif self.type_arch == "mips":
+				pass
+			elif self.type_arch == "x86":
+				pass
+		
+		self.global_sysroot = "--sysroot=" + os.path.join(self.path_ndk, "platforms", "android-" + str(self.board_id), "arch-arm")
+		
+		self.add_flag("c", [
+		    "-D__ARM_ARCH_5__",
+		    "-D__ARM_ARCH_5T__",
+		    "-D__ARM_ARCH_5E__",
+		    "-D__ARM_ARCH_5TE__"
+		    ])
 		if self.config["compilator"] != "clang":
-			if self.arch == "armv5":
+			if self.type_arch == "armv5":
 				# -----------------------
 				# -- arm V5 :
 				# -----------------------
-				self.global_flags_cc.append("-march=armv5te")
-				self.global_flags_cc.append("-msoft-float")
+				self.add_flag("c", [
+				    "-march=armv5te",
+				    "-msoft-float"
+				    ])
 			else:
 				# -----------------------
 				# -- arm V7 (Neon) :
 				# -----------------------
-				self.global_flags_cc.append("-mfpu=neon")
-				self.global_flags_cc.append("-mfloat-abi=softfp")
-				self.global_flags_ld.append("-mfpu=neon")
-				self.global_flags_ld.append("-mfloat-abi=softfp")
-				self.global_flags_cc.append("-D__ARM_ARCH_7__")
-				self.global_flags_cc.append("-D__ARM_NEON__")
+				self.add_flag("c", [
+				    "-mfpu=neon",
+				    "-march=armv7-a",
+				    "-mfloat-abi=softfp",
+				    "-D__ARM_ARCH_7__",
+				    "-D__ARM_NEON__"
+				    ])
+				self.add_flag("link", [
+				    "-mfpu=neon",
+				    "-mfloat-abi=softfp",
+				    "-Wl,--fix-cortex-a8",
+				    ])
 		
 		# the -mthumb must be set for all the android produc, some ot the not work coretly without this one ... (all android code is generated with this flags)
-		self.global_flags_cc.append("-mthumb")
+		self.add_flag("c", "-mthumb")
 		# -----------------------
 		# -- Common flags :
 		# -----------------------
-		self.global_flags_cc.append("-fpic")
+		self.add_flag("c", "-fpic")
 		if self.config["compilator"] != "clang":
-			self.global_flags_cc.append("-ffunction-sections")
-			self.global_flags_cc.append("-funwind-tables")
-			self.global_flags_cc.append("-fstack-protector")
-			self.global_flags_cc.append("-Wno-psabi")
-			self.global_flags_cc.append("-mtune=xscale")
-			self.global_flags_cc.append("-fomit-frame-pointer")
-			self.global_flags_cc.append("-fno-strict-aliasing")
-		self.global_flags_xx.append("-frtti")
-		self.global_flags_cc.append("-fexceptions")
-		self.global_flags_xx.append("-Wa,--noexecstack")
+			self.add_flag("c", [
+			    "-ffunction-sections",
+			    "-funwind-tables",
+			    "-fstack-protector",
+			    "-Wno-psabi",
+			    "-mtune=xscale",
+			    "-fomit-frame-pointer",
+			    "-fno-strict-aliasing"
+			    ])
+		self.add_flag("c++", [
+		    "-frtti",
+		    "-fexceptions",
+		    "-Wa,--noexecstack"
+		    ])
 	
 	def check_right_package(self, pkg_properties, value):
 		for val in pkg_properties["RIGHT"]:
@@ -208,12 +213,19 @@ class Target(target.Target):
 				return True
 		return False
 	
+	def convert_name_application(self, pkg_name):
+		value = pkg_name.lower()
+		value = value.replace(' ', '')
+		value = value.replace('-', '')
+		value = value.replace('_', '')
+		return value
+	
 	"""
 	def get_staging_path_data(self, binary_name):
 		return self.get_staging_path(binary_name) + self.path_data
 	"""
 	
-	def make_package_generic_binary(self, pkg_name, pkg_properties, base_pkg_path, heritage_list, static):
+	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("------------------------------------------------------------------------")
@@ -266,16 +278,27 @@ class Target(target.Target):
 		pkg_name_application_name = pkg_name
 		if self.config["mode"] == "debug":
 			pkg_name_application_name += "debug"
+		#debug.info("ploppppp: " + str(pkg_properties))
 		# FINAL_path_JAVA_PROJECT
 		self.path_java_project = os.path.join(target_outpath,
-		                                      "src",
-		                                      pkg_properties["COMPAGNY_TYPE"],
-		                                      pkg_properties["COMPAGNY_NAME2"],
+		                                      "src")
+		if pkg_properties["COMPAGNY_TYPE"] != "":
+			self.path_java_project = os.path.join(self.path_java_project,
+			                                      pkg_properties["COMPAGNY_TYPE"])
+		if pkg_properties["COMPAGNY_NAME2"] != "":
+			self.path_java_project = os.path.join(self.path_java_project,
+			                                      pkg_properties["COMPAGNY_NAME2"])
+		self.path_java_project = os.path.join(self.path_java_project,
 		                                      pkg_name_application_name)
 		#FINAL_FILE_ABSTRACTION
 		self.file_final_abstraction = os.path.join(self.path_java_project, pkg_name_application_name + ".java")
 		
-		compleatePackageName = pkg_properties["COMPAGNY_TYPE"]+"."+pkg_properties["COMPAGNY_NAME2"]+"." + pkg_name_application_name
+		compleatePackageName = ""
+		if pkg_properties["COMPAGNY_TYPE"] != "":
+			compleatePackageName += pkg_properties["COMPAGNY_TYPE"] + "."
+		if pkg_properties["COMPAGNY_NAME2"] != "":
+			compleatePackageName += pkg_properties["COMPAGNY_NAME2"] + "."
+		compleatePackageName += pkg_name_application_name
 		
 		if "ADMOD_ID" in pkg_properties:
 			pkg_properties["RIGHT"].append("INTERNET")
@@ -321,21 +344,25 @@ class Target(target.Target):
 		# http://asantoso.wordpress.com/2009/09/15/how-to-build-android-application-package-apk-from-the-command-line-using-the-sdk-tools-continuously-integrated-using-cruisecontrol/
 		debug.print_element("pkg", "R.java", "<==", "Resources files")
 		tools.create_directory_of_file(target_outpath + "/src/noFile")
-		androidToolPath = self.path_sdk + "/build-tools/"
+		android_tool_path = self.path_sdk + "/build-tools/"
 		# find android tool version
-		dirnames = tools.get_list_sub_path(androidToolPath)
-		if len(dirnames) != 1:
-			debug.error("an error occured when getting the tools for android")
-		androidToolPath += dirnames[0] + "/"
+		dirnames = tools.get_list_sub_path(android_tool_path)
+		if len(dirnames) == 0:
+			debug.warning("This does not comport directory: '" + android_tool_path + "'")
+			debug.error("An error occured when getting the tools for android")
+		elif len(dirnames) > 1:
+			dirnames = sorted(dirnames, reverse=True)
+			debug.debug("sort tools directory: '" + str(dirnames) + "' ==> select : " + str(dirnames[0]))
+		android_tool_path += dirnames[0] + "/"
 		
 		# this is to create resource file for android ... (we did not use aset in jar with ewol ...
 		adModResoucepath = ""
 		if "ADMOD_ID" in pkg_properties:
 			adModResoucepath = " -S " + self.path_sdk + "/extras/google/google_play_services/libproject/google-play-services_lib/res/ "
-		cmdLine = androidToolPath + "aapt p -f " \
+		cmdLine = android_tool_path + "aapt p -f " \
 		          + "-M " + target_outpath + "/AndroidManifest.xml " \
 		          + "-F " + target_outpath + "/resources.res " \
-		          + "-I " + self.path_sdk + "/platforms/android-" + str(self.boardId) + "/android.jar "\
+		          + "-I " + self.path_sdk + "/platforms/android-" + str(self.board_id) + "/android.jar "\
 		          + "-S " + target_outpath + "/res/ " \
 		          + adModResoucepath \
 		          + "-J " + target_outpath + "/src/ "
@@ -360,7 +387,7 @@ class Target(target.Target):
 		
 		cmdLine = "javac " \
 		          + "-d " + self.get_staging_path(pkg_name) + "/build/classes " \
-		          + "-classpath " + self.path_sdk + "/platforms/android-" + str(self.boardId) + "/android.jar" \
+		          + "-classpath " + self.path_sdk + "/platforms/android-" + str(self.board_id) + "/android.jar" \
 		          + adModJarFile + " " \
 		          + filesString \
 		          + self.file_final_abstraction + " "  \
@@ -385,7 +412,7 @@ class Target(target.Target):
 		multiprocess.run_command(cmdLine)
 		
 		debug.print_element("pkg", ".dex", "<==", "*.class")
-		cmdLine = androidToolPath + "dx " \
+		cmdLine = android_tool_path + "dx " \
 		          + "--dex --no-strict " \
 		          + "--output=" + target_outpath + "/build/" + pkg_name_application_name + ".dex " \
 		          + target_outpath + "/build/classes/ "
@@ -442,7 +469,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
@@ -456,7 +483,7 @@ class Target(target.Target):
 		debug.print_element("pkg", ".apk(aligned)", "<==", ".apk (not aligned)")
 		tools.remove_file(target_outpath + "/" + pkg_name_application_name + ".apk")
 		# verbose mode : -v
-		cmdLine = androidToolPath + "zipalign 4 " \
+		cmdLine = android_tool_path + "zipalign 4 " \
 		          + target_outpath + "/build/" + pkg_name_application_name + "-unalligned.apk " \
 		          + target_outpath + "/" + pkg_name_application_name + ".apk "
 		multiprocess.run_command(cmdLine)
@@ -487,7 +514,7 @@ class Target(target.Target):
 		cmdLine = self.path_sdk + "/platform-tools/adb uninstall " + pkg_name_application_name
 		Rmultiprocess.run_command(cmdLine)
 	
-	def Log(self, pkg_name):
+	def show_log(self, pkg_name):
 		debug.debug("------------------------------------------------------------------------")
 		debug.info("logcat of android board")
 		debug.debug("------------------------------------------------------------------------")

lutin/z_target/lutinTarget_Debian.py

@@ -0,0 +1,200 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+
+from lutin import debug
+from lutin import target
+from lutin import tools
+import os
+import stat
+import re
+from lutin import host
+from lutin import multiprocess
+
+class Target(target.Target):
+	def __init__(self, config):
+		#processor type selection (auto/arm/ppc/x86)
+		if config["arch"] == "auto":
+			config["arch"] = "x86"
+		#bus size selection (auto/32/64)
+		if config["bus-size"] == "auto":
+			config["bus-size"] = str(host.BUS_SIZE)
+		target.Target.__init__(self, "Linux", config, "")
+		if self.config["bus-size"] == "64":
+			# 64 bits
+			if host.BUS_SIZE != 64:
+				self.add_flag("c", "-m64")
+		else:
+			# 32 bits
+			if host.BUS_SIZE != 32:
+				self.add_flag("c", "-m32")
+		
+		self.add_flag("c", "-fpic")
+		
+		self.pkg_path_data = "share"
+		self.pkg_path_bin = "bin"
+		self.pkg_path_lib = "lib"
+		self.pkg_path_license = "license"
+	
+	"""
+	.local/application
+	    *--> applName -> applName.app/bin/applName
+	    *--> applName.app
+	        *--> appl_description.txt
+	        *--> appl_name.txt
+	        *--> changelog.txt
+	        *--> copyright.txt
+	        *--> readme.txt
+	        *--> version.txt
+	        *--> website.txt
+	        *--> icon.png
+	        *--> bin
+	        *    *--> applName
+	        *--> doc
+	        *    *--> applName
+	        *--> lib
+	        *    *--> XX.so
+	        *    *--> YY.so
+	        *--> license
+	        *    *--> applName.txt
+	        *    *--> libXX.txt
+	        *    *--> libYY.txt
+	        *--> man
+	        *--> share
+	        *    *--> applName
+	        *    *--> XX
+	        *    *--> YY
+	        *--> sources
+	"""
+	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("------------------------------------------------------------------------")
+		#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)
+		
+		## copy binary files:
+		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)
+		
+		## Create generic files:
+		self.make_package_generic_files(target_outpath, pkg_properties, pkg_name, base_pkg_path, heritage_list, static)
+		
+		## create the package:
+		debug.debug("package : " + 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(self.get_staging_path(pkg_name) + "/" + pkg_name + ".app.tar.gz", self.get_final_path() + "/" + pkg_name + ".app.gpkg")
+	
+	
+	
+	
+	def make_package_debian(self, pkg_name, pkg_properties, base_pkg_path, heritage_list):
+		# http://alp.developpez.com/tutoriels/debian/creer-paquet/
+		debianpkg_name = re.sub("_", "-", pkg_name)
+		debug.debug("------------------------------------------------------------------------")
+		debug.info("Generate package '" + debianpkg_name + "' v"+pkg_properties["VERSION"])
+		debug.debug("------------------------------------------------------------------------")
+		self.get_staging_path(pkg_name)
+		target_outpathDebian = self.get_staging_path(pkg_name) + "/DEBIAN/"
+		finalFileControl = target_outpathDebian + "control"
+		finalFilepostRm = target_outpathDebian + "postrm"
+		# create the paths :
+		tools.create_directory_of_file(finalFileControl)
+		tools.create_directory_of_file(finalFilepostRm)
+		## Create the control file
+		tools.create_directory_of_file(finalFileControl)
+		tmpFile = open(finalFileControl, 'w')
+		tmpFile.write("Package: " + debianpkg_name + "\n")
+		tmpFile.write("Version: " + pkg_properties["VERSION"] + "\n")
+		tmpFile.write("Section: " + self.generate_list_separate_coma(pkg_properties["SECTION"]) + "\n")
+		tmpFile.write("Priority: " + pkg_properties["PRIORITY"] + "\n")
+		tmpFile.write("Architecture: all\n")
+		tmpFile.write("Depends: bash\n")
+		tmpFile.write("Maintainer: " + self.generate_list_separate_coma(pkg_properties["MAINTAINER"]) + "\n")
+		tmpFile.write("Description: " + pkg_properties["DESCRIPTION"] + "\n")
+		tmpFile.write("\n")
+		tmpFile.flush()
+		tmpFile.close()
+		## Create the PostRm
+		tmpFile = open(finalFilepostRm, 'w')
+		tmpFile.write("#!/bin/bash\n")
+		tmpFile.write("touch ~/." + pkg_name + "\n")
+		if pkg_name != "":
+			tmpFile.write("touch ~/.local/share/" + pkg_name + "\n")
+			tmpFile.write("rm -r ~/.local/share/" + pkg_name + "\n")
+		tmpFile.write("\n")
+		tmpFile.flush()
+		tmpFile.close()
+		## Enable Execution in script
+		os.chmod(finalFilepostRm, stat.S_IRWXU + stat.S_IRGRP + stat.S_IXGRP + stat.S_IROTH + stat.S_IXOTH);
+		## Readme donumentation
+		readmeFileDest = self.get_staging_path(pkg_name) + "/usr/share/doc/"+ debianpkg_name + "/README"
+		tools.create_directory_of_file(readmeFileDest)
+		if os.path.exists(base_pkg_path + "/os-Linux/README")==True:
+			tools.copy_file(base_pkg_path + "/os-Linux/README", readmeFileDest)
+		elif os.path.exists(base_pkg_path + "/README")==True:
+			tools.copy_file(base_pkg_path + "/README", readmeFileDest)
+		elif os.path.exists(base_pkg_path + "/README.md")==True:
+			tools.copy_file(base_pkg_path + "/README.md", readmeFileDest)
+		else:
+			debug.info("no file 'README', 'README.md' or 'os-Linux/README' ==> generate an empty one")
+			tmpFile = open(readmeFileDest, 'w')
+			tmpFile.write("No documentation for " + pkg_name + "\n")
+			tmpFile.flush()
+			tmpFile.close()
+		## licence file
+		license_file_dest = self.get_staging_path(pkg_name) + "/usr/share/doc/"+ debianpkg_name + "/copyright"
+		tools.create_directory_of_file(license_file_dest)
+		if os.path.exists(base_pkg_path + "/license.txt")==True:
+			tools.copy_file(base_pkg_path + "/license.txt", license_file_dest)
+		else:
+			debug.info("no file 'license.txt' ==> generate an empty one")
+			tmpFile = open(license_file_dest, 'w')
+			tmpFile.write("No license define by the developper for " + pkg_name + "\n")
+			tmpFile.flush()
+			tmpFile.close()
+		##changeLog file
+		change_log_file_dest = self.get_staging_path(pkg_name) + "/usr/share/doc/"+ debianpkg_name + "/changelog"
+		tools.create_directory_of_file(change_log_file_dest)
+		if os.path.exists(base_pkg_path + "/changelog")==True:
+			tools.copy_file(base_pkg_path + "/changelog", change_log_file_dest)
+		else:
+			debug.info("no file 'changelog' ==> generate an empty one")
+			tmpFile = open(change_log_file_dest, 'w')
+			tmpFile.write("No changelog data " + pkg_name + "\n")
+			tmpFile.flush()
+			tmpFile.close()
+		## create the package :
+		debug.debug("package : " + self.get_staging_path(pkg_name) + "/" + debianpkg_name + ".deb")
+		os.system("cd " + self.get_staging_path("") + " ; dpkg-deb --build " + pkg_name)
+		tools.create_directory_of_file(self.get_final_path())
+		tools.copy_file(self.get_staging_path("") + "/" + pkg_name + self.suffix_package, self.get_final_path() + "/" + pkg_name + self.suffix_package)
+	
+	def install_package(self, pkg_name):
+		debug.debug("------------------------------------------------------------------------")
+		debug.info("Install package '" + pkg_name + "'")
+		debug.debug("------------------------------------------------------------------------")
+		os.system("sudo dpkg -i " + self.get_final_path() + "/" + pkg_name + self.suffix_package)
+	
+	def un_install_package(self, pkg_name):
+		debug.debug("------------------------------------------------------------------------")
+		debug.info("Un-Install package '" + pkg_name + "'")
+		debug.debug("------------------------------------------------------------------------")
+		os.system("sudo dpkg -r " + self.get_final_path() + "/" + pkg_name + self.suffix_package)
+	
+
+

lutin/z_target/lutinTarget_IOs.py

@@ -1,4 +1,5 @@
 #!/usr/bin/python
+# -*- coding: utf-8 -*-
 ##
 ## @author Edouard DUPIN
 ##
@@ -56,32 +57,34 @@ class Target(target.Target):
 		
 		if self.sumulator == True:
 			self.sysroot = "-isysroot /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator.sdk"
-			self.global_flags_ld.append("-mios-simulator-version-min=8.0")
-			self.global_flags_cc.append("-mios-simulator-version-min=8.0")
+			self.add_flag("link", "-mios-simulator-version-min=8.0")
+			self.add_flag("c", "-mios-simulator-version-min=8.0")
 		else:
 			self.sysroot = "-isysroot /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk"
-			self.global_flags_ld.append("-miphoneos-version-min=8.0")
-			self.global_flags_cc.append("-miphoneos-version-min=8.0")
+			self.add_flag("link", "-miphoneos-version-min=8.0")
+			self.add_flag("c", "-miphoneos-version-min=8.0")
 		
-		self.global_flags_cc.append("-D__STDCPP_LLVM__")
-		self.global_flags_ld.append([
-			"-Xlinker",
-			"-objc_abi_version",
-			"-Xlinker 2",
-			"-Xlinker",
-			"-no_implicit_dylibs",
-			"-stdlib=libc++",
-			"-fobjc-arc",
-			"-fobjc-link-runtime"])
+		self.add_flag("link", [
+		    "-Xlinker",
+		    "-objc_abi_version",
+		    "-Xlinker 2",
+		    "-Xlinker",
+		    "-no_implicit_dylibs",
+		    "-stdlib=libc++",
+		    "-fobjc-arc",
+		    "-fobjc-link-runtime"
+		    ])
 		
-		self.global_flags_m.append("-fobjc-arc")
-		#self.global_flags_m.append("-fmodules")
+		self.add_flag("m", ["-fobjc-arc"])
+		#self.add_flag("m", ["-fmodules"])
 		
 		self.pkg_path_data = "share"
 		self.pkg_path_bin = ""
 		self.pkg_path_lib = "lib"
 		self.pkg_path_license = "license"
 		
+		# Disable capabiliteis to compile in shared mode
+		self.support_dynamic_link = False
 	
 	def make_package_binary(self, pkg_name, pkg_properties, base_pkg_path, heritage_list, static):
 		debug.debug("------------------------------------------------------------------------")
@@ -109,23 +112,23 @@ class Target(target.Target):
 			# Resize all icon needed for Ios ...
 			# TODO : Do not regenerate if source resource is not availlable
 			# TODO : Add a colored background ...
-			debug.print_element("pkg", "iTunesArtwork.png", "<==", pkg_properties["ICON"])
+			debug.print_element("pkg", os.path.relpath(pkg_properties["ICON"]), "==>", "iTunesArtwork.png")
 			image.resize(pkg_properties["ICON"], os.path.join(target_outpath, "iTunesArtwork.png"), 512, 512)
-			debug.print_element("pkg", "iTunesArtwork@2x.png", "<==", pkg_properties["ICON"])
+			debug.print_element("pkg", os.path.relpath(pkg_properties["ICON"]), "==>", "iTunesArtwork@2x.png")
 			image.resize(pkg_properties["ICON"], os.path.join(target_outpath, "iTunesArtwork@2x.png"), 1024, 1024)
-			debug.print_element("pkg", "Icon-60@2x.png", "<==", pkg_properties["ICON"])
+			debug.print_element("pkg", os.path.relpath(pkg_properties["ICON"]), "==>", "Icon-60@2x.png")
 			image.resize(pkg_properties["ICON"], os.path.join(target_outpath, "Icon-60@2x.png"), 120, 120)
-			debug.print_element("pkg", "Icon-76.png", "<==", pkg_properties["ICON"])
+			debug.print_element("pkg", os.path.relpath(pkg_properties["ICON"]), "==>", "Icon-76.png")
 			image.resize(pkg_properties["ICON"], os.path.join(target_outpath, "Icon-76.png"), 76, 76)
-			debug.print_element("pkg", "Icon-76@2x.png", "<==", pkg_properties["ICON"])
+			debug.print_element("pkg", os.path.relpath(pkg_properties["ICON"]), "==>", "Icon-76@2x.png")
 			image.resize(pkg_properties["ICON"], os.path.join(target_outpath, "Icon-76@2x.png"), 152, 152)
-			debug.print_element("pkg", "Icon-Small-40.png", "<==", pkg_properties["ICON"])
+			debug.print_element("pkg", os.path.relpath(pkg_properties["ICON"]), "==>", "Icon-Small-40.png")
 			image.resize(pkg_properties["ICON"], os.path.join(target_outpath, "Icon-Small-40.png"), 40, 40)
-			debug.print_element("pkg", "Icon-Small-40@2x.png", "<==", pkg_properties["ICON"])
+			debug.print_element("pkg", os.path.relpath(pkg_properties["ICON"]), "==>", "Icon-Small-40@2x.png")
 			image.resize(pkg_properties["ICON"], os.path.join(target_outpath, "Icon-Small-40@2x.png"), 80, 80)
-			debug.print_element("pkg", "Icon-Small.png", "<==", pkg_properties["ICON"])
+			debug.print_element("pkg", os.path.relpath(pkg_properties["ICON"]), "==>", "Icon-Small.png")
 			image.resize(pkg_properties["ICON"], os.path.join(target_outpath, "Icon-Small.png"), 29, 29)
-			debug.print_element("pkg", "Icon-Small@2x.png", "<==", pkg_properties["ICON"])
+			debug.print_element("pkg", os.path.relpath(pkg_properties["ICON"]), "==>", "Icon-Small@2x.png")
 			image.resize(pkg_properties["ICON"], os.path.join(target_outpath, "Icon-Small@2x.png"), 58, 58)
 		
 		## Create the info file:
@@ -177,9 +180,9 @@ class Target(target.Target):
 		data_file += "			</array>\n"
 		data_file += "			\n"
 		data_file += "			<key>CFBundleShortVersionString</key>\n"
-		data_file += "			<string>"+pkg_properties["VERSION"]+"</string>\n"
+		data_file += "			<string>"+tools.version_to_string(pkg_properties["VERSION"])+"</string>\n"
 		data_file += "			<key>CFBundleVersion</key>\n"
-		data_file += "			<string>"+pkg_properties["VERSION_CODE"]+"</string>\n"
+		data_file += "			<string>"+str(pkg_properties["VERSION_CODE"])+"</string>\n"
 		data_file += "			\n"
 		data_file += "			<key>CFBundleResourceSpecification</key>\n"
 		data_file += "			<string>ResourceRules.plist</string>\n"
@@ -312,8 +315,10 @@ class Target(target.Target):
 		# Must create the tarball of the application 
 		#cd $(TARGET_OUT_FINAL)/; tar -cf $(PROJECT_NAME).tar $(PROJECT_NAME).app
 		#cd $(TARGET_OUT_FINAL)/; tar -czf $(PROJECT_NAME).tar.gz $(PROJECT_NAME).app
-		
 		if self.sumulator == False:
+			if "APPLE_APPLICATION_IOS_ID" not in pkg_properties:
+				pkg_properties["APPLE_APPLICATION_IOS_ID"] = "00000000"
+				debug.warning("Missing package property : APPLE_APPLICATION_IOS_ID USE " + pkg_properties["APPLE_APPLICATION_IOS_ID"] + " ID ... ==> CAN NOT WORK ..." )
 			# Create the info file
 			tmpFile = open(os.path.join(target_outpath, pkg_name + ".xcent"), 'w')
 			tmpFile.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n")
@@ -321,15 +326,12 @@ class Target(target.Target):
 			tmpFile.write("<plist version=\"1.0\">\n")
 			tmpFile.write("    <dict>\n")
 			tmpFile.write("        <key>application-identifier</key>\n")
-			try:
-				tmpFile.write("        <string>" + pkg_properties["APPLE_APPLICATION_IOS_ID"] + "." + pkg_properties["COMPAGNY_TYPE"] + "." + pkg_properties["COMPAGNY_NAME2"] + "." + pkg_name + "</string>\n")
-			except:
-				debug.error("Missing package property : APPLE_APPLICATION_IOS_ID")
+			tmpFile.write("        <string>" + pkg_properties["APPLE_APPLICATION_IOS_ID"] + "." + pkg_properties["COMPAGNY_TYPE"] + "." + pkg_properties["COMPAGNY_NAME2"] + "." + pkg_name + "</string>\n")
 			tmpFile.write("        <key>get-task-allow</key>\n")
 			tmpFile.write("        <true/>\n")
 			tmpFile.write("        <key>keychain-access-groups</key>\n")
 			tmpFile.write("        <array>\n")
-			tmpFile.write("            <string>" + pkg_properties["APPLE_APPLICATION_IOS_ID"] + ".atriasoft.worddown</string>\n")
+			tmpFile.write("            <string>" + pkg_properties["APPLE_APPLICATION_IOS_ID"] + "." + pkg_properties["COMPAGNY_TYPE"] + "." + pkg_properties["COMPAGNY_NAME2"] + "." + pkg_name + "</string>\n")
 			tmpFile.write("        </array>\n")
 			tmpFile.write("    </dict>\n")
 			tmpFile.write("</plist>\n")
@@ -339,21 +341,17 @@ class Target(target.Target):
 			debug.print_element("pkg(signed)", "pkg", "<==", "Signing application")
 			iosDevelopperKeyFile = ".iosKey.txt"
 			if tools.file_size(iosDevelopperKeyFile) < 10:
-				debug.error("To sign an application we need to have a signing key in the file '" + iosDevelopperKeyFile + "' \n it is represented like: 'iPhone Developer: Francis DUGENOUX (YRRQE5KGTH)'\n you can obtain it with : 'certtool y | grep \"Developer\"'")
-			signatureKey = tools.file_read_data(iosDevelopperKeyFile)
-			signatureKey = re.sub('\n', '', signatureKey)
-			cmdLine  = 'codesign  --force --sign '
-			# to get this key ;    certtool y | grep "Developer"
-			cmdLine += ' "' + signatureKey + '" '
-			cmdLine += ' --entitlements ' + self.get_build_path(pkg_name) + '/worddown.xcent'
-			cmdLine += ' ' + self.get_staging_path(pkg_name)
-			multiprocess.run_command(cmdLine)
-			
-			# --force --sign "iPhone Developer: Edouard DUPIN (SDFGSDFGSDFG)"
-			#		  --resource-rules=/Users/edouarddupin/Library/Developer/Xcode/DerivedData/worddown-cmuvjchgtiteexdiacyqoexsyadg/Build/Products/Debug-iphoneos/worddown.app/ResourceRules.plist
-			#		  --entitlements /Users/edouarddupin/Library/Developer/Xcode/DerivedData/worddown-cmuvjchgtiteexdiacyqoexsyadg/Build/Intermediates/worddown.build/Debug-iphoneos/worddown.build/worddown.xcent
-			#		  /Users/edouarddupin/Library/Developer/Xcode/DerivedData/worddown-cmuvjchgtiteexdiacyqoexsyadg/Build/Products/Debug-iphoneos/worddown.app
-
+				debug.warning("To sign an application we need to have a signing key in the file '" + iosDevelopperKeyFile + "' \n it is represented like: 'iPhone Developer: Francis DUGENOUX (YRRQE5KGTH)'\n you can obtain it with : 'certtool y | grep \"Developer\"'")
+				debug.warning("Can not be install ... not runnable")
+			else:
+				signatureKey = tools.file_read_data(iosDevelopperKeyFile)
+				signatureKey = re.sub('\n', '', signatureKey)
+				cmdLine  = 'codesign --force --sign '
+				# to get this key ; certtool y | grep "Developer"
+				cmdLine += ' "' + signatureKey + '" '
+				cmdLine += ' --entitlements ' + self.get_build_path(pkg_name) + '/worddown.xcent'
+				cmdLine += ' ' + self.get_staging_path(pkg_name)
+				multiprocess.run_command(cmdLine)
 	
 	def createRandomNumber(self, len):
 		out = ""

lutin/z_target/lutinTarget_Linux.py

@@ -1,4 +1,5 @@
 #!/usr/bin/python
+# -*- coding: utf-8 -*-
 ##
 ## @author Edouard DUPIN
 ##
@@ -10,6 +11,7 @@
 from lutin import debug
 from lutin import target
 from lutin import tools
+from lutin import env
 import os
 import stat
 import re
@@ -28,20 +30,22 @@ class Target(target.Target):
 		if self.config["bus-size"] == "64":
 			# 64 bits
 			if host.BUS_SIZE != 64:
-				self.global_flags_cc.append("-m64")
+				self.add_flag("c", "-m64")
 		else:
 			# 32 bits
 			if host.BUS_SIZE != 32:
-				self.global_flags_cc.append("-m32")
-		
-		self.global_flags_cc.append("-fpic")
-		self.global_flags_cc.append("-D__STDCPP_GNU__")
+				self.add_flag("c", "-m32")
 		
+		self.add_flag("c", "-fpic")
 		
 		self.pkg_path_data = "share"
 		self.pkg_path_bin = "bin"
 		self.pkg_path_lib = "lib"
 		self.pkg_path_license = "license"
+		# disable sysroot when generate build in isolated mode
+		if env.get_isolate_system() == True:
+			self.sysroot = "--sysroot=/aDirectoryThatDoesNotExist/"
+		
 	
 	"""
 	.local/application
@@ -73,242 +77,87 @@ class Target(target.Target):
 	        *    *--> YY
 	        *--> sources
 	"""
-	def make_package_generic_binary(self, pkg_name, pkg_properties, base_pkg_path, heritage_list, static):
+	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 : " + 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(self.get_staging_path(pkg_name) + "/" + pkg_name + ".app.tar.gz", self.get_final_path() + "/" + pkg_name + ".app.gpkg")
-	
-	
-	
-	
-	def make_package_debian(self, pkg_name, pkg_properties, base_pkg_path, heritage_list):
-		# http://alp.developpez.com/tutoriels/debian/creer-paquet/
-		debianpkg_name = re.sub("_", "-", pkg_name)
-		debug.debug("------------------------------------------------------------------------")
-		debug.info("Generate package '" + debianpkg_name + "' v"+pkg_properties["VERSION"])
-		debug.debug("------------------------------------------------------------------------")
-		self.get_staging_path(pkg_name)
-		target_outpathDebian = self.get_staging_path(pkg_name) + "/DEBIAN/"
-		finalFileControl = target_outpathDebian + "control"
-		finalFilepostRm = target_outpathDebian + "postrm"
-		# create the paths :
-		tools.create_directory_of_file(finalFileControl)
-		tools.create_directory_of_file(finalFilepostRm)
-		## Create the control file
-		tools.create_directory_of_file(finalFileControl)
-		tmpFile = open(finalFileControl, 'w')
-		tmpFile.write("Package: " + debianpkg_name + "\n")
-		tmpFile.write("Version: " + pkg_properties["VERSION"] + "\n")
-		tmpFile.write("Section: " + self.generate_list_separate_coma(pkg_properties["SECTION"]) + "\n")
-		tmpFile.write("Priority: " + pkg_properties["PRIORITY"] + "\n")
-		tmpFile.write("Architecture: all\n")
-		tmpFile.write("Depends: bash\n")
-		tmpFile.write("Maintainer: " + self.generate_list_separate_coma(pkg_properties["MAINTAINER"]) + "\n")
-		tmpFile.write("Description: " + pkg_properties["DESCRIPTION"] + "\n")
-		tmpFile.write("\n")
-		tmpFile.flush()
-		tmpFile.close()
-		## Create the PostRm
-		tmpFile = open(finalFilepostRm, 'w')
-		tmpFile.write("#!/bin/bash\n")
-		tmpFile.write("touch ~/." + pkg_name + "\n")
-		if pkg_name != "":
-			tmpFile.write("touch ~/.local/share/" + pkg_name + "\n")
-			tmpFile.write("rm -r ~/.local/share/" + pkg_name + "\n")
-		tmpFile.write("\n")
-		tmpFile.flush()
-		tmpFile.close()
-		## Enable Execution in script
-		os.chmod(finalFilepostRm, stat.S_IRWXU + stat.S_IRGRP + stat.S_IXGRP + stat.S_IROTH + stat.S_IXOTH);
-		## Readme donumentation
-		readmeFileDest = self.get_staging_path(pkg_name) + "/usr/share/doc/"+ debianpkg_name + "/README"
-		tools.create_directory_of_file(readmeFileDest)
-		if os.path.exists(base_pkg_path + "/os-Linux/README")==True:
-			tools.copy_file(base_pkg_path + "/os-Linux/README", readmeFileDest)
-		elif os.path.exists(base_pkg_path + "/README")==True:
-			tools.copy_file(base_pkg_path + "/README", readmeFileDest)
-		elif os.path.exists(base_pkg_path + "/README.md")==True:
-			tools.copy_file(base_pkg_path + "/README.md", readmeFileDest)
-		else:
-			debug.info("no file 'README', 'README.md' or 'os-Linux/README' ==> generate an empty one")
-			tmpFile = open(readmeFileDest, 'w')
-			tmpFile.write("No documentation for " + pkg_name + "\n")
-			tmpFile.flush()
-			tmpFile.close()
-		## licence file
-		license_file_dest = self.get_staging_path(pkg_name) + "/usr/share/doc/"+ debianpkg_name + "/copyright"
-		tools.create_directory_of_file(license_file_dest)
-		if os.path.exists(base_pkg_path + "/license.txt")==True:
-			tools.copy_file(base_pkg_path + "/license.txt", license_file_dest)
-		else:
-			debug.info("no file 'license.txt' ==> generate an empty one")
-			tmpFile = open(license_file_dest, 'w')
-			tmpFile.write("No license define by the developper for " + pkg_name + "\n")
-			tmpFile.flush()
-			tmpFile.close()
-		##changeLog file
-		change_log_file_dest = self.get_staging_path(pkg_name) + "/usr/share/doc/"+ debianpkg_name + "/changelog"
-		tools.create_directory_of_file(change_log_file_dest)
-		if os.path.exists(base_pkg_path + "/changelog")==True:
-			tools.copy_file(base_pkg_path + "/changelog", change_log_file_dest)
-		else:
-			debug.info("no file 'changelog' ==> generate an empty one")
-			tmpFile = open(change_log_file_dest, 'w')
-			tmpFile.write("No changelog data " + pkg_name + "\n")
-			tmpFile.flush()
-			tmpFile.close()
-		## create the package :
-		debug.debug("package : " + self.get_staging_path(pkg_name) + "/" + debianpkg_name + ".deb")
-		os.system("cd " + self.get_staging_path("") + " ; dpkg-deb --build " + pkg_name)
-		tools.create_directory_of_file(self.get_final_path())
-		tools.copy_file(self.get_staging_path("") + "/" + pkg_name + self.suffix_package, self.get_final_path() + "/" + pkg_name + self.suffix_package)
+		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("------------------------------------------------------------------------")
-		debug.info("Install package '" + pkg_name + "'")
+		debug.info("-- Install package '" + pkg_name + "'")
 		debug.debug("------------------------------------------------------------------------")
-		os.system("sudo dpkg -i " + self.get_final_path() + "/" + pkg_name + self.suffix_package)
+		# this is temporary ... Will call:
+		if False:
+			os.system("lutin-pkg -i " + os.path.join(self.get_final_path(), + pkg_name + ".app.gpkg"))
+		else:
+			#Copy directly from staging path:
+			appl_path = os.path.join(self.get_staging_path(pkg_name), pkg_name + ".app")
+			target_path = os.path.join(os.path.expanduser("~"), ".local", "application", pkg_name + ".app")
+			target_bin_path = os.path.join(os.path.expanduser("~"), ".local", "application", pkg_name + ".app", "bin", pkg_name)
+			target_bin_link = os.path.join(os.path.expanduser("~"), ".local", "application", pkg_name)
+			# remove output path:
+			tools.remove_path_and_sub_path(target_path)
+			# remove executable link version:
+			tools.remove_file(target_bin_link)
+			# copy result:
+			tools.copy_anything(appl_path, target_path, recursive=True)
+			# create synbolic link:
+			debug.info("kkk " + "ln -s " + target_bin_path + " " + target_bin_link)
+			os.symlink(target_bin_path, target_bin_link)
 	
 	def un_install_package(self, pkg_name):
 		debug.debug("------------------------------------------------------------------------")
-		debug.info("Un-Install package '" + pkg_name + "'")
+		debug.info("-- Un-Install package '" + pkg_name + "'")
 		debug.debug("------------------------------------------------------------------------")
-		os.system("sudo dpkg -r " + self.get_final_path() + "/" + pkg_name + self.suffix_package)
+		# this is temporary ... Will call:
+		if False:
+			os.system("lutin-pkg -r " + pkg_name)
+		else:
+			#Copy directly from staging path:
+			target_path = os.path.join(os.path.expanduser("~"), ".local", "application", pkg_name + ".app")
+			target_bin_link = os.path.join(os.path.expanduser("~"), ".local", "application", pkg_name)
+			# remove output path:
+			tools.remove_path_and_sub_path(target_path)
+			# remove executable link version:
+			tools.remove_file(target_bin_link)
 	
-	"""
-	.local/application
-	    *--> applName -> applName.app/bin/applName
-	    *--> applName.app
-	        *--> appl_description.txt
-	        *--> appl_name.txt
-	        *--> changelog.txt
-	        *--> copyright.txt
-	        *--> readme.txt
-	        *--> version.txt
-	        *--> website.txt
-	        *--> icon.png
-	        *--> bin
-	        *    *--> applName
-	        *--> doc
-	        *    *--> applName
-	        *--> lib
-	        *    *--> XX.so
-	        *    *--> YY.so
-	        *--> license
-	        *    *--> applName.txt
-	        *    *--> libXX.txt
-	        *    *--> libYY.txt
-	        *--> man
-	        *--> share
-	        *    *--> applName
-	        *    *--> XX
-	        *    *--> YY
-	        *--> sources
-	"""
-	def make_package_generic(self, pkg_name, pkg_properties, base_pkg_path, heritage_list):
-		debug.warning("heritage for " + str(pkg_name) + ":")
-		for heritage in heritage_list.list_heritage:
-			debug.warning("heritage .... " + str(heritage.name) + " : " + str(heritage.depends))
-		debianpkg_name = re.sub("_", "-", pkg_name)
+	def run(self, pkg_name, option_list):
 		debug.debug("------------------------------------------------------------------------")
-		debug.info("Generate generic '" + debianpkg_name + "' v"+pkg_properties["VERSION"])
+		debug.info("-- Run package '" + pkg_name + "' + option: " + str(option_list))
+		debug.debug("------------------------------------------------------------------------")
+		appl_path = os.path.join(self.get_staging_path(pkg_name), pkg_name + ".app", "bin", pkg_name)
+		cmd = appl_path + " "
+		for elem in option_list:
+			cmd += elem + " "
+		multiprocess.run_command_no_lock_out(cmd)
+		debug.debug("------------------------------------------------------------------------")
+		debug.info("-- Run package '" + pkg_name + "' Finished")
 		debug.debug("------------------------------------------------------------------------")
-		target_outpath = self.get_staging_path(pkg_name) + "/edn.app/"
-		tools.create_directory_of_file(target_outpath)
-		## Create version file
-		tmpFile = open(target_outpath + "/version.txt", 'w')
-		tmpFile.write(pkg_properties["VERSION"])
-		tmpFile.flush()
-		tmpFile.close()
-		## Create maintainer file
-		tmpFile = open(target_outpath + "/maintainer.txt", 'w')
-		tmpFile.write(self.generate_list_separate_coma(pkg_properties["MAINTAINER"]))
-		tmpFile.flush()
-		tmpFile.close()
-		## Create appl_name file
-		tmpFile = open(target_outpath + "/appl_name.txt", 'w')
-		tmpFile.write("en_EN:" + pkg_properties["NAME"])
-		tmpFile.flush()
-		tmpFile.close()
-		## Create appl_description file
-		tmpFile = open(target_outpath + "/appl_description.txt", 'w')
-		tmpFile.write("en_EN:" + pkg_properties["DESCRIPTION"])
-		tmpFile.flush()
-		tmpFile.close()
-		## Create Readme file
-		readmeFileDest = target_outpath + "/readme.txt"
-		if os.path.exists(base_pkg_path + "/os-Linux/README")==True:
-			tools.copy_file(base_pkg_path + "/os-Linux/README", readmeFileDest)
-		elif os.path.exists(base_pkg_path + "/README")==True:
-			tools.copy_file(base_pkg_path + "/README", readmeFileDest)
-		elif os.path.exists(base_pkg_path + "/README.md")==True:
-			tools.copy_file(base_pkg_path + "/README.md", readmeFileDest)
-		else:
-			debug.info("no file 'README', 'README.md' or 'os-Linux/README' ==> generate an empty one")
-			tmpFile = open(readmeFileDest, 'w')
-			tmpFile.write("No documentation for " + pkg_name + "\n")
-			tmpFile.flush()
-			tmpFile.close()
-		## Create licence file
-		license_file_dest = target_outpath + "/license/"+ debianpkg_name + ".txt"
-		tools.create_directory_of_file(license_file_dest)
-		if os.path.exists(base_pkg_path + "/license.txt")==True:
-			tools.copy_file(base_pkg_path + "/license.txt", license_file_dest)
-		else:
-			debug.info("no file 'license.txt' ==> generate an empty one")
-			tmpFile = open(license_file_dest, 'w')
-			tmpFile.write("No license define by the developper for " + pkg_name + "\n")
-			tmpFile.flush()
-			tmpFile.close()
-		## Create changeLog file
-		change_log_file_dest = target_outpath + "/changelog.txt"
-		if os.path.exists(base_pkg_path + "/changelog") == True:
-			tools.copy_file(base_pkg_path + "/changelog", change_log_file_dest)
-		else:
-			debug.info("no file 'changelog' ==> generate an empty one")
-			tmpFile = open(change_log_file_dest, 'w')
-			tmpFile.write("No changelog data " + pkg_name + "\n")
-			tmpFile.flush()
-			tmpFile.close()
-		## copy share path
-		#debug.info("plop:" + self.get_staging_path(pkg_name) + self.path_data)
-		if os.path.exists(self.get_staging_path(pkg_name) + self.path_data) == True:
-			tools.copy_anything(self.get_staging_path(pkg_name) + self.path_data + "/*", target_outpath + self.path_data, recursive=True)
-		
-		## Create binary path:
-		bin_path = target_outpath + self.path_bin
-		#tools.create_directory_of_file(bin_path)
-		tools.copy_anything(self.get_staging_path(pkg_name) + self.path_bin + "/*",
-		                    bin_path)
-		
-		## create the package:
-		debug.debug("package : " + self.get_staging_path(pkg_name) + "/" + debianpkg_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(self.get_staging_path(pkg_name) + "/" + pkg_name + ".app.tar.gz", self.get_final_path() + "/" + pkg_name + ".app.gpkg")
-		
 
 

lutin/z_target/lutinTarget_MacOs.py

@@ -1,4 +1,5 @@
 #!/usr/bin/python
+# -*- coding: utf-8 -*-
 ##
 ## @author Edouard DUPIN
 ##
@@ -38,8 +39,6 @@ class Target(target.Target):
 		#self.suffix_binary=''
 		#self.suffix_package=''
 		
-		self.global_flags_cc.append("-D__STDCPP_LLVM__")
-		
 		self.pkg_path_data = "Resources"
 		self.pkg_path_bin = "MacOS"
 		self.pkg_path_lib = "lib"
@@ -110,7 +109,6 @@ class Target(target.Target):
 		data_file  = "#!/bin/bash\n"
 		data_file += "# Simply open the real application in the correct way (a link does not work ...)\n"
 		data_file += "/Applications/" + pkg_name + ".app/Contents/MacOS/" + pkg_name + " $*\n"
-		#tmpFile.write("open -n /Applications/edn.app --args -AppCommandLineArg $*\n")
 		tools.file_write_data(os.path.join(target_outpath, "shell", pkg_name),
 		                      data_file,
 		                      only_if_new=True)
@@ -128,8 +126,8 @@ class Target(target.Target):
 		debug.info("disk image: " + output_file_name)
 		
 		## user information:
-		debug.info("You can have an shell interface by executing : ")
-		debug.info("    sudo cp " + shell_file_name + " /usr/local/bin")
+		#debug.info("You can have an shell interface by executing : ")
+		#debug.info("    sudo cp " + shell_file_name + " /usr/local/bin")
 	
 	def install_package(self, pkg_name):
 		debug.debug("------------------------------------------------------------------------")
@@ -139,7 +137,7 @@ class Target(target.Target):
 		if os.path.exists("/Applications/" + pkg_name + ".app") == True:
 			shutil.rmtree("/Applications/" + pkg_name + ".app")
 		# copy the application in the basic application path : /Applications/xxx.app
-		shutil.copytree(tools.get_run_path() + self.path_out + self.path_staging + "/" + pkg_name + ".app", "/Applications/" + pkg_name + ".app")
+		shutil.copytree(os.path.join(tools.get_run_path(),self.path_out,self.path_staging,pkg_name + ".app"), os.path.join("/Applications", pkg_name + ".app"))
 	
 	def un_install_package(self, pkg_name):
 		debug.debug("------------------------------------------------------------------------")
@@ -149,6 +147,21 @@ class Target(target.Target):
 		# Remove the application in the basic application path : /Applications/xxx.app
 		if os.path.exists("/Applications/" + pkg_name + ".app") == True:
 			shutil.rmtree("/Applications/" + pkg_name + ".app")
+	
+	def run(self, pkg_name, option_list):
+		debug.debug("------------------------------------------------------------------------")
+		debug.info("-- Run package '" + pkg_name + "'")
+		debug.debug("------------------------------------------------------------------------")
+		appl_path = os.path.join(tools.get_run_path(),self.path_out,self.path_staging,pkg_name + ".app", "bin", pkg_name)
+		cmd = appl_path + " "
+		for elem in option_list:
+			cmd += elem + " "
+		multiprocess.run_command_no_lock_out(cmd)
+		debug.debug("------------------------------------------------------------------------")
+		debug.info("-- Run package '" + pkg_name + "' Finished")
+		debug.debug("------------------------------------------------------------------------")
+
+
 
 
 

lutin/z_target/lutinTarget_Windows.py

@@ -1,4 +1,5 @@
 #!/usr/bin/python
+# -*- coding: utf-8 -*-
 ##
 ## @author Edouard DUPIN
 ##
@@ -45,15 +46,6 @@ class Target(target.Target):
 			else:
 				# 32 bits
 				self.set_cross_base("i686-w64-mingw32-")
-		# force static link to prenvent many errors ...
-		self.global_flags_ld.append(["-static-libgcc",
-		                             "-static-libstdc++",
-		                             "-static"])
-		
-		#self.path_bin=""
-		#self.path_lib="lib"
-		#self.path_data="data"
-		#self.path_doc="doc"
 		
 		self.pkg_path_data = "data"
 		self.pkg_path_bin = ""
@@ -64,32 +56,37 @@ class Target(target.Target):
 		self.suffix_lib_dynamic='.dll'
 		self.suffix_binary='.exe'
 		#self.suffix_package=''
-		self.global_flags_cc.append("-D__STDCPP_GNU__")
 	
 	
 	def get_staging_path_data(self, binary_name, heritage_list):
 		return self.get_staging_path(binary_name) + self.path_data
 	
-	def make_package_generic_binary(self, pkg_name, pkg_properties, base_pkg_path, heritage_list, static):
+	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("------------------------------------------------------------------------")

lutin/zip.py

@@ -1,4 +1,5 @@
 #!/usr/bin/python
+# -*- coding: utf-8 -*-
 ##
 ## @author Edouard DUPIN
 ##
@@ -6,6 +7,7 @@
 ##
 ## @license APACHE v2.0 (see license file)
 ##
+
 import platform
 import os
 import zipfile

setup.py

@@ -1,4 +1,13 @@
 #!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+
 from setuptools import setup
 
 def readme():
@@ -7,8 +16,8 @@ def readme():
 
 # https://pypi.python.org/pypi?%3Aaction=list_classifiers
 setup(name='lutin',
-      version='0.7.0',
-      description='Lutin generic builder',
+      version='1.2.6',
+      description='Lutin generic builder (might replace makefile, CMake ...)',
       long_description=readme(),
       url='http://github.com/HeeroYui/lutin',
       author='Edouard DUPIN',
@@ -19,19 +28,21 @@ setup(name='lutin',
                 'lutin/z_system',
                 'lutin/z_target'],
       classifiers=[
-        'Development Status :: 3 - Alpha',
+        'Development Status :: 4 - Beta',
         'License :: OSI Approved :: Apache Software License',
         'Programming Language :: Python',
         'Topic :: Software Development :: Compilers',
       ],
       keywords='builder c++ c android ios macos makefile cmake',
       scripts=['bin/lutin'],
-      data_file=[
-          ('/etc/bash_completion.d', ['bash-autocompletion/lutin']),
-      ],
+      # Does not work on MacOs
+      #data_file=[
+      #    ('/etc/bash_completion.d', ['bash-autocompletion/lutin']),
+      #],
       include_package_data = True,
       zip_safe=False)
 
-#To developp: ./setup.py install/develop
+#To developp: sudo ./setup.py install
+#             sudo ./setup.py develop
 #TO register all in pip: ./setup.py register sdist upload
 

test/test-c/lutin_test-c.py

@@ -0,0 +1,22 @@
+#!/usr/bin/python
+import lutin.module as module
+import lutin.tools as tools
+import lutin.debug as debug
+import os
+
+def get_type():
+	return "BINARY"
+
+def get_desc():
+	return "Text C compilation"
+
+def create(target, module_name):
+	my_module = module.Module(__file__, module_name, get_type())
+	my_module.add_extra_compile_flags()
+	my_module.add_src_file([
+		'test.c'
+		])
+	if target.name=="Android":
+		my_module.compile_version("c", 1999)
+	return my_module
+

test/test-c/test.c

@@ -0,0 +1,6 @@
+#include <stdio.h>
+
+int main(int _argc, char* _argv[]) {
+	printf("Hello World\n");
+	return 0;
+}