[RELEASE] new version 2.1.0

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

.gitignore

@@ -1 +1,9 @@
-*.pyc
+# Compiled python modules.
+*.pyc
+
+# Setuptools distribution folder.
+/dist/
+/build/
+
+# Python egg metadata, regenerated from source files by setuptools.
+/*.egg-info

.gitlab-ci.yml

@@ -0,0 +1,34 @@
+# This file is a template, and might need editing before it works on your project.
+# use the official gcc image, based on debian
+# can use verions as well, like gcc:5.2
+# see https://hub.docker.com/_/gcc/
+image: gcc
+
+before_script:
+  - pwd
+  - git clone --depth 1 --branch master https://gitlab.com/atria-soft/ci.git
+  - ls -l *
+  - ls -l ..
+  - apt-get update -qy
+  - apt-get install -y python-dev python-pip
+  #- pip install setuptools
+  - ./setup.py install
+  #- 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/
+#  - ./ci/build_send.py --tag=$TAG --status=START;
+  
+
+build:
+  stage: build
+  # instead of calling g++ directly you can also use some build toolkit like make
+  # install the necessary build tools when needed
+  # before_script: 
+  #   - apt update && apt -y install make autoconf 
+  script:
+    - export TARGET=-tLinux
+    - export CONF=-mdebug
+    - export BUILDER=-cgcc
+    - lutin -w -j4 -C -P $TARGET $BUILDER $COMPILATOR_OPTION $BUS $CONF $GCOV $DISABLE_PACKAGE test-c; STATUS=$?
+#    - ./ci/build_send.py --tag=$TAG --status="$STATUS";
+#  artifacts:
+#    paths:
+#      - mybinary

.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

MANIFEST.in

@@ -0,0 +1,2 @@
+include README.rst
+include bash-autocompletion/lutin

README.md

@@ -1,41 +0,0 @@
-build
-=====
-
-`lutin` is a generic package maker is a FREE software tool.
-
-Instructions
-============
-
-This is a tool to generate the binary, shared library, static library and package independently of the OS
-This tool can generate package for Linux, MacOs, Android
-
-
-Create a lutin module
-=====================
-
-Set the lutin module maker with the name :
-	lutin_xxxxx.py
-	xxx : represent the name of the module/binary/package and must be lower case and no special characters
-
-you can see exemple for some type in :
-	ewol : library
-	edn : package
-	glew : prebuild
-
-License (APACHE v2.0)
-=====================
-
-Copyright lutin Edouard DUPIN
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-

README.rst

@@ -0,0 +1,86 @@
+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
+
+
+
+Developement (dev)
+------------------
+
+.. image:: https://travis-ci.org/HeeroYui/lutin.svg?branch=dev
+    :target: https://travis-ci.org/HeeroYui/lutin
+
+
+Instructions
+------------
+
+This is a tool to generate the binary, shared library, static library and package independently of the OS
+
+This software builds C, C++, m, m++, to object file and generate associated libraries (.so & .a) end create final Executable file
+
+This tool can generate package for Linux, MacOs, Android
+
+
+Lutin is under a FREE license that can be found in the COPYING file.
+Any contribution is more than welcome ;)
+
+git repository
+--------------
+
+http://github.com/HeeroYui/lutin/
+
+Documentation
+-------------
+
+http://HeeroYui.github.io/lutin/
+
+Installation
+------------
+
+Requirements: ``Python >= 2.7`` and ``pip``
+
+Just run:
+
+  pip install lutin
+
+Install pip on debian/ubuntu:
+
+  sudo apt-get install pip
+
+Install pip on ARCH-linux:
+
+  sudo pacman -S pip
+
+Install pip on MacOs:
+
+  sudo easy_install pip
+
+
+License (APACHE v2.0)
+---------------------
+
+Copyright lutin Edouard DUPIN
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+

bash-autocompletion/lutin

@@ -61,7 +61,7 @@ _lutin()
 			return 0
 			;;
 		--target)
-			local names=`lutin.py --list-target`
+			local names=`lutin --list-target`
 			COMPREPLY=( $(compgen -W "${names}" -- ${cur}) )
 			return 0
 			;;
@@ -82,9 +82,9 @@ _lutin()
 		COMPREPLY=( $(compgen -W "${optshorts}" -- ${cur}) )
 		return 0
 	fi
-	listmodule=`lutin.py --list-module`
+	listmodule=`lutin --list-module`
 	COMPREPLY=( $(compgen -W "${listmodule}" -- ${cur}) )
 	return 0
 }
 
-complete -F _lutin lutin.py
+complete -F _lutin lutin

bash-autocompletion/readme

@@ -1,6 +1,6 @@
 
 to install autocompletion for lutin :
 
-sudo cp bash-autocompletion/lutin.py /etc/bash_completion.d
+sudo cp bash-autocompletion/lutin /etc/bash_completion.d
 
 ==> and restart bash ...

bin/lutin

@@ -0,0 +1,425 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+
+# 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
+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("h", "help", desc="Display this help")
+myArgs.add("H", "HELP", desc="Display this help (with all compleate information)")
+myArgs.add_section("option", "Can be set one time in all case")
+myArgs.add("v", "verbose", list=[["0","None"],["1","error"],["2","warning"],["3","info"],["4","debug"],["5","verbose"],["6","extreme_verbose"]], desc="display makefile debug level (verbose) default =2")
+myArgs.add("C", "color", desc="Display makefile output in color")
+myArgs.add("B", "force-build", desc="Force the rebuild without checking the dependency")
+myArgs.add("P", "pretty", desc="Print the debug has pretty display")
+myArgs.add("j", "jobs", haveParam=True, desc="Specifies the number of jobs (commands) to run simultaneously")
+myArgs.add("d", "depth", haveParam=True, desc="Depth of the search of sub element lutin_*.py (default=" + str(env.get_parse_depth()) + ")")
+myArgs.add("s", "force-strip", desc="Force the stripping of the compile elements")
+myArgs.add("o", "force-optimisation", desc="Force optimisation of the build")
+myArgs.add("w", "warning", desc="Store warning in a file build file")
+myArgs.add("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("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'")
+myArgs.add("c", "compilator", list=[["clang",""],["gcc",""]], desc="Compile with clang or Gcc mode (by default gcc will be used)")
+myArgs.add("", "compilator-version", haveParam=True, desc="With travis we need to specify the name of the version if we want to compile with gcc 4.9 ==> --compilator-version=4.9")
+myArgs.add("m", "mode", list=[["debug",""],["release",""]], desc="Compile in release or debug mode (default release)")
+myArgs.add("a", "arch", list=[["auto","Automatic choice"],["arm","Arm processer"],["x86","Generic PC : AMD/Intel"],["ppc","Power PC"]], desc="Architecture to compile")
+myArgs.add("b", "bus", list=[["auto","Automatic choice"],["32","32 bits"],["64","64 bits"]], desc="Adressing size (Bus size)")
+myArgs.add("p", "package", desc="Disable the package generation (usefull when just compile for test on linux ...)")
+myArgs.add("g", "gcov", desc="Enable code coverage intrusion in code")
+myArgs.add("", "simulation", desc="Simulater mode (availlable only for IOS)")
+myArgs.add("", "list-target", desc="List all availlables targets ==> for auto completion")
+myArgs.add("", "list-module", desc="List all availlables module ==> for auto completion")
+
+myArgs.add_section("cible", "generate in order set")
+localArgument = myArgs.parse()
+
+"""
+	display the help of this makefile
+"""
+def usage(full=False):
+	color = debug.get_color_set()
+	# generic argument displayed : 
+	myArgs.display()
+	print("		All target can finish with '?clean' '?dump' '?gcov' ... ?action (@ can replace ?)" )
+	print("		" + color['green'] + "all" + color['default'])
+	print("			build all (only for the current selected board) (bynary and packages)")
+	print("		" + color['green'] + "clean" + color['default'])
+	print("			clean all (same as previous)")
+	print("		" + color['green'] + "dump" + color['default'])
+	print("			Dump all the module dependency and properties")
+	print("		" + color['green'] + "gcov" + color['default'])
+	print("			Parse all the code of the library with the gcov resolution")
+	listOfAllModule = module.list_all_module_with_desc()
+	for mod in listOfAllModule:
+		data_print = "		"
+		if full == False:
+			if     mod["type"] != None \
+			   and mod["type"][:6] == "BINARY":
+				data_print += color['blue']
+				if mod["sub-type"] == "":
+					data_print += "* "
+				elif mod["sub-type"] == "TEST":
+					data_print += "T "
+				elif mod["sub-type"] == "TOOLS":
+					data_print += "U "
+				elif mod["sub-type"] == "SAMPLE":
+					data_print += "S "
+				else:
+					data_print += "  "
+			elif     mod["type"] != None \
+			     and mod["type"] == "PACKAGE":
+				data_print += color['red'] + "# "
+			elif     mod["type"] != None \
+			     and mod["type"][:7] == "LIBRARY":
+				data_print += color['yellow'] + "  "
+			else:
+				data_print += color['default'] + "  "
+		else:
+			data_print += color['green']
+		data_print += mod["name"] + color['default']
+		if full == False:
+			data_print += "\r\t\t\t\t\t\t\t"
+			if     mod["license"] != None \
+			   and mod["license"] != "":
+				data_print += color['yellow'] + " [" + mod["license"] + "]" + color['default']
+			if     mod["version"] != None \
+			   and mod["version"] != []:
+				version_ID = tools.version_to_string(mod["version"])
+				data_print += color['blue'] + " (" + version_ID + ")" + color['default']
+			"""
+			if     mod["compagny-type"] != "" \
+			   and mod["compagny-name"] != "":
+				data_print += color['purple'] + " " + mod["compagny-type"] + "/" + mod["compagny-name"] + color['default']
+			elif mod["compagny-name"] != "":
+				data_print += color['purple'] + " " + mod["compagny-name"] + color['default']
+			"""
+		
+		print(data_print)
+		if mod["description"] != "":
+			print("			" + mod["description"])
+		if full == True:
+			if     mod["type"] != None \
+			   and mod["type"] != "":
+				print("				Type:     " + mod["type"])
+			if     mod["sub-type"] != None \
+			   and mod["sub-type"] != "":
+				print("				Sub-Type: " + mod["sub-type"])
+			if     mod["version"] != None \
+			   and mod["version"] != []:
+				version_ID = ""
+				for id in mod["version"]:
+					if len(version_ID) != 0:
+						if type(id) == str:
+							version_ID+="-"
+						else:
+							version_ID+="."
+					version_ID += str(id)
+				print("				version:  " + color['blue'] + version_ID + color['default'])
+			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"] != None \
+			     and mod["compagny-name"] != "":
+				print("				compagny: " + color['purple'] + mod["compagny-name"] + color['default'])
+			if     mod["license"] != None \
+			   and mod["license"] != "":
+				print("				license:  " + color['yellow'] + mod["license"] + color['default'])
+			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()
+		return True
+	if argument.get_option_name() == "HELP":
+		if active==False:
+			usage(True)
+		return True
+	if argument.get_option_name() == "list-module":
+		if active==False:
+			listOfModule = module.list_all_module()
+			retValue = ""
+			for moduleName in listOfModule:
+				if retValue != "":
+					retValue += " "
+				retValue += moduleName
+			print(retValue)
+			exit(0)
+		return True
+	if argument.get_option_name() == "list-target":
+		if active==False:
+			listOfTarget = target.list_all_target()
+			retValue = ""
+			for targetName in listOfTarget:
+				if retValue != "":
+					retValue += " "
+				retValue += targetName
+			print(retValue)
+			exit(0)
+		return True
+	elif argument.get_option_name()=="jobs":
+		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:
+			if check_boolean(argument.get_arg()) == True:
+				debug.enable_color()
+			else:
+				debug.disable_color()
+		return True
+	elif argument.get_option_name() == "force-build":
+		if active==True:
+			if check_boolean(argument.get_arg()) == True:
+				env.set_force_mode(True)
+			else:
+				env.set_force_mode(False)
+		return True
+	elif argument.get_option_name() == "pretty":
+		if active==True:
+			if 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:
+			if check_boolean(argument.get_arg()) == True:
+				env.set_force_strip_mode(True)
+			else:
+				env.set_force_strip_mode(False)
+		return True
+	elif argument.get_option_name() == "warning":
+		if active==True:
+			if 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)
+
+# initialize the system ...
+lutin.init()
+
+#available target : Linux / MacOs / Windows / Android ...
+targetName = host.OS
+config = {
+	"compilator":"gcc",
+	"mode":"release",
+	"bus-size":"auto",
+	"arch":"auto",
+	"generate-package":True,
+	"simulation":False,
+	"gcov":False,
+	"compilator-version":""
+	}
+# load the default target :
+my_target = None
+actionDone=False
+# parse all argument
+for argument in localArgument:
+	if parseGenericArg(argument, False) == True:
+		continue
+	elif argument.get_option_name() == "compilator-version":
+		config["compilator-version"] = argument.get_arg()
+	elif argument.get_option_name() == "package":
+		config["generate-package"]=False
+	elif argument.get_option_name() == "simulation":
+		config["simulation"]=True
+	elif argument.get_option_name() == "gcov":
+		config["gcov"]=True
+	elif argument.get_option_name() == "bus":
+		config["bus-size"]=argument.get_arg()
+	elif argument.get_option_name() == "arch":
+		config["arch"]=argument.get_arg()
+	elif argument.get_option_name() == "compilator":
+		if config["compilator"] != argument.get_arg():
+			debug.debug("change compilator ==> " + argument.get_arg())
+			config["compilator"] = argument.get_arg()
+			#remove previous target
+			my_target = None
+	elif argument.get_option_name() == "target":
+		# No check input ==> this will be verify automaticly chen the target will be loaded
+		if targetName != argument.get_arg():
+			targetName = argument.get_arg()
+			debug.debug("change target ==> '" + targetName + "' & reset mode : gcc&release")
+			#reset properties by defauult:
+			config = {
+			             "compilator":"gcc",
+			             "mode":"release",
+			             "bus-size":"auto",
+			             "arch":"auto",
+			             "generate-package":True,
+			             "simulation":False,
+			             "gcov":False,
+			             "compilator-version":""
+			          }
+			#remove previous target
+			my_target = None
+	elif argument.get_option_name() == "mode":
+		if config["mode"] != argument.get_arg():
+			config["mode"] = argument.get_arg()
+			debug.debug("change mode ==> " + config["mode"])
+			#remove previous target
+			my_target = None
+	else:
+		argument_value = argument.get_arg()
+		debug.debug("something request : '" + argument_value + "'")
+		if argument.get_option_name() != "":
+			debug.warning("Can not understand argument : '" + argument.get_option_name() + "'")
+			usage()
+			break;
+		name2 = argument_value.replace("@", "?")
+		gettedElement = name2.split("?")
+		module_name = gettedElement[0]
+		action_list = gettedElement[1:]
+		if len(action_list) == 0:
+			action_list = "build"
+		debug.debug("requested: '" + module_name + "' ? actions:'" + str(action_list) + "'")
+		multiple_module_list = []
+		if module_name[-1] == "*":
+			base_name = module_name[:-1]
+			for mod in module.list_all_module():
+				if mod[:len(base_name)] == base_name:
+					debug.verbose("need do it for: " + mod);
+					multiple_module_list.append(mod)
+		else:
+			multiple_module_list.append(module_name)
+		debug.debug("Will do: '" + str(multiple_module_list) + "' ? actions:'" + str(action_list) + "'")
+		for module_name in multiple_module_list:
+			#load the target if needed :
+			if my_target == None:
+				my_target = target.load_target(targetName, copy.deepcopy(config))
+			my_target.build(module_name, actions=action_list)
+			actionDone=True
+
+# if no action done : we do "all" ...
+if actionDone==False:
+	#load the target if needed :
+	if my_target == None:
+		my_target = target.load_target(targetName, config)
+	my_target.build("all")
+
+# stop all started threads;
+multiprocess.un_init()
+
+

doc/010_basic_concept.md

@@ -0,0 +1,80 @@
+Basic concept                               {#lutin_concept}
+=============
+
+@tableofcontents
+
+Lutin is a compleate builder system. It is designed to answers all the application problems.
+The library and the distribution problem are partially manage (no real use-case)
+
+Technologie:
+============
+
+Lutin is designed in Python 2.X or 3.X to answers at the multiplatform problems.
+On Linux or MacOs, it is really easy to compile with Makefile, cmake, but on Windows it is an other problem.
+The first version of Lutin has been designed in Makefile, but we need to wait 20 minutes before the first build on Windows. In Python it is fast as Linux.
+
+Lutin is not based over an other builder, but compile code itself.
+
+Features:
+=========
+
+Lutin is designed to:
+  - support many hardware platform (X86/X64/ARM...);
+  - support many operation system (windows, Ios, Android ...);
+  - support complex worktree and depedency;
+  - build only when needed;
+  - create platform specific packages (application bundle);
+
+
+global overview:
+================
+
+Every build system is based on multiple concept depending of their own designed.
+
+For lutin we can différentiate 4 basics concepts:
+  - Mudule: Interface to create a part of an application, that contain binary, scipt, datas ...
+  - Target: methode to creata an application or a library (may be internal: medium level)
+  - Builder: Methode to transform element in other, for example: compile a cpp in object file, or object files in binary.
+  - System: Many OS manage basic element contain in the OS, This part permit to find generic module availlable in the system.
+
+Module:
+=======
+
+When you use lutin, you migth first create a module, This is the basis of the framework. It permit to describe your "module", all it contain, and the deendency.
+
+We can separate a module in some part:
+  - Binary:
+    * A binary is an end point element.
+    * It can be transform in a complete standalone bundle, or in an part installable.
+  - Library:
+    * This represent an element that is used by other application
+
+
+Target:
+=======
+
+A target represent the "board" to build the module, we can separate MacOs, IOs, Linux ... and all platform that exist
+
+You can generate a new one or use satandard that are provided
+
+
+Builder:
+========
+
+By default lustin manage many methode to build element like cpp, java, asm files ...
+
+
+System:
+=======
+
+This element provide all elements availlable in the Linux distribution.
+
+
+
+
+**Index:**
+  - @ref mainpage
+  - @ref lutin_concept
+  - @ref lutin_use
+  - @ref lutin_module
+

doc/020_Compile_a_module.md

@@ -0,0 +1,229 @@
+How to use lutin                               {#lutin_use}
+================
+
+@tableofcontents
+
+Lutin permit simply to compile applications and library.
+
+To simply understand the use, we will use a simple library:
+
+```bash
+	git clone http://github.con/atria-soft/etk.git
+```
+
+
+compile a module:                               {#lutin_use_compile}
+=================
+
+It is really simple:
+
+```bash
+	lutin yourModuleName
+	#example:
+	lutin etk
+```
+
+
+
+Option working:                               {#lutin_use_options}
+===============
+
+Lutin have a complex option methodologie. We can consider 3 part of the option:
+  - global option
+  - target option
+  - modules
+
+
+Global options:                               {#lutin_use_options_global}
+---------------
+
+Globals option is parse first and manage global setting of the build (not specific of a target)
+
+this keep the last value config set
+
+
+Display help:                               {#lutin_use_options_help}
+-------------
+
+Availlable everywhere ...
+
+```bash
+	lutin -h
+	lutin --help
+```
+
+You can see in this help that it take a litle time to react.
+The first time you run lutin, it parse all the file in your sub-directory.
+But the system(OS) keep the data in cash, then the next time it is faster.
+
+At the end of the help you an see an help about the etk librery with the associated help.
+
+Build in color:                               {#lutin_use_options_color}
+---------------
+
+```bash
+	lutin -C
+	lutin --color
+```
+
+Display build line in pretty print mode:                               {#lutin_use_options_pretty}
+----------------------------------------
+
+when an error apear, the gcc or clang compile line can be really unreadable:
+```bash
+	g++ -o /home/heero/dev/plop/out/Linux_x86_64/release/build/gcc/etk/obj/etk/Color.cpp.o -I/home/heero/dev/plop/etk -std=c++11 -D__CPP_VERSION__=2011 -D__TARGET_OS__Linux -D__TARGET_ARCH__x86 -D__TARGET_ADDR__64BITS -D_REENTRANT -DNDEBUG -O3 -fpic -D__STDCPP_GNU__ -Wall -Wsign-compare -Wreturn-type -Wno-write-strings -Woverloaded-virtual -Wnon-virtual-dtor -Wno-unused-variable -DMODE_RELEASE -c -MMD -MP /home/heero/dev/plop/etk/etk/Color.cpp
+```
+
+whith this option you can transform this not obvious line in a readable line:
+
+```bash
+	lutin -P
+	lutin --pretty
+```
+
+result:
+```bash
+	g++ \
+		-o /home/XXX/dev/out/Linux_x86_64/release/build/gcc/etk/obj/etk/Color.cpp.o \
+		-I/home/XXX/dev/etk \
+		-std=c++11 \
+		-D__CPP_VERSION__=2011 \
+		-D__TARGET_OS__Linux \
+		-D__TARGET_ARCH__x86 \
+		-D__TARGET_ADDR__64BITS \
+		-D_REENTRANT \
+		-DNDEBUG \
+		-O3 \
+		-fpic \
+		-D__STDCPP_GNU__ \
+		-Wall \
+		-Wsign-compare \
+		-Wreturn-type \
+		-Wno-write-strings \
+		-Woverloaded-virtual \
+		-Wnon-virtual-dtor \
+		-Wno-unused-variable \
+		-DMODE_RELEASE \
+		-c \
+		-MMD \
+		-MP \
+		/home/XXX/dev/etk/etk/Color.cpp
+```
+
+lutin log:                               {#lutin_use_options_log}
+----------
+
+Lutin have an internal log system. To enable or disable it just select your debug level with the option:
+
+```bash
+	lutin -v4
+	lutin --verbose 4
+```
+
+The level availlables are:
+  - 0: None
+  - 1: error
+  - 2: warning (default)
+  - 3: info
+  - 4: debug
+  - 5: verbose
+  - 6: extreme_verbose
+
+Select the number of CPU core used:                               {#lutin_use_options_cpu}
+-----------------------------------
+
+By default lutin manage only 1 CPU core (faster to debug) but for speed requirement you can use use multiple core:
+
+```bash
+	#for 5 core
+	lutin -j5
+	lutin --jobs 5
+```
+
+Force rebuild all:                               {#lutin_use_options_rebuild_force}
+------------------
+
+Sometime it is needed to rebuild all the program, just do:
+
+```bash
+	lutin -B
+	lutin --force-build
+	# or remove the build directory
+	rm -rf out/
+```
+
+Force strip all library and programs:                               {#lutin_use_options_strip}
+-------------------------------------
+
+Force strip of output binary (remove symboles)
+
+```bash
+	lutin -s
+	lutin --force-strip
+```
+
+Manage Cross compilation:                               {#lutin_use_options_cross_compile}
+=========================
+
+The main objective of lutin is managing the cross compilation to build from linux to other platform:
+
+For android you can use:
+
+```bash
+	lutin -t Android your-module
+	lutin -t Windows your-module
+```
+
+Build in debug mode:                               {#lutin_use_options_debug_release}
+====================
+
+To developp it is fasted with debug tools
+
+```bash
+	lutin -m debug your-module
+	lutin -m release your-module
+```
+
+You can desire to have compilation optimisation when you build in debug mode:
+
+```bash
+	lutin -m debug --force-optimisation your-module
+```
+
+Execute your program after building it:                               {#lutin_use_options_execute}
+=======================================
+
+You can execute some action in a single line for a module:
+
+```bash
+	lutin -m debug your-module?clean?build?run:--run-option1:--run-option2
+```
+
+Why use ```?run``` istead of direct calling the binary?
+
+This is simple: you does nok knoww where the binary is installed... when you build for linux in debug it will be set in ```out/Linux_x86_64/debug/staging/clang/edn/edn.app/``` for edn application. 
+Note that the path is distinct for gcc/clang, debug/release, Linux/windows/Android/..., 64/32 bits, and for every applications ...
+
+Then it is really easy to run the wrong binary.
+
+
+Install your program after building it:                               {#lutin_use_options_install}
+=======================================
+
+You can install your build module:
+
+```bash
+	lutin -m debug your-module?build?install
+```
+
+This option is not availlablke on all platform ...
+
+
+
+
+**Index:**
+  - @ref mainpage
+  - @ref lutin_concept
+  - @ref lutin_use
+  - @ref lutin_module
+

doc/030_Create_a_new_module.md

@@ -0,0 +1,497 @@
+Create a new Module:                                   {#lutin_module}
+====================
+
+@tableofcontents
+
+
+Base of the module file:                               {#lutin_module_base_file}
+========================
+
+To create a new module you will use a generic naming:
+
+```
+	lutin_module-name.py
+```
+
+Replace your ``module-name`` with the delivery you want. The name can contain [a-zA-Z0-9\-_] values.
+
+In the module name you must define some values:
+
+```python
+#!/usr/bin/python
+import lutin.module as module
+import lutin.tools as tools
+
+# A simple list of type:
+#    - BINARY
+#    - BINARY_SHARED
+#    - BINARY_STAND_ALONE
+#    - LIBRARY
+#    - LIBRARY_DYNAMIC
+#    - LIBRARY_STATIC
+#    - PACKAGE
+#    - PREBUILD
+#    - DATA
+def get_type():
+	return "LIBRARY"
+
+# simple description of the module that appear in the 'lutin -h'
+# Note: this fucntion is optionnal.
+def get_desc():
+	return "Ewol tool kit"
+
+# type of licence:
+#    "APACHE-2"
+#    "BSD-1" / "BSD-2" / "BSD-3" / "BSD-4"
+#    "GPL-1" / "GPL-2" / "GPL-3"
+#    "LGPL-1" / "LGPL-2" / "LGPL-3"
+#    PROPRIETARY
+#    ...
+# Note: this fucntion is optionnal.
+def get_licence():
+	return "APACHE-2"
+
+# type of compagny that provide the software:
+#    com : Commercial
+#    net : Network??
+#    org : Organisation
+#    gov : Governement
+#    mil : Military
+#    edu : Education
+#    pri : Private
+#    museum : ...
+#    ...
+# Note: this fucntion is optionnal.
+def get_compagny_type():
+	return "com"
+
+# Name of the compagny
+# Note: this fucntion is optionnal.
+def get_compagny_name():
+	return "hello-compagny"
+
+# People to contact if a problem appear in the build system / library
+# Note: this fucntion is optionnal.
+def get_maintainer():
+	return ["Mr NAME SurName <my-email@group.com>"]
+
+# Version of the library
+# Note: this fucntion is optionnal.
+def get_version():
+	return [0,9,"dev"]
+
+# create the module
+# @param[in] target reference on the Target that is currently build
+# @param[in] module_name Name of the module that is extract from the file name (to be generic)
+def create(target, module_name):
+	my_module = module.Module(__file__, module_name, get_type())
+	...
+	return my_module
+```
+
+Thes it is simple to specify build for:
+
+Create a new Module (LIBRARY):                               {#lutin_module_library}
+==============================
+
+What to change:
+```python
+def get_type():
+	return "LIBRARY"
+```
+
+By default the library is compile in shared and static. The binary select the mode it prefer...
+
+You can force the library to be compile as a dll/so: ```LIBRARY_DYNAMIC``` or a basic include lib: .a ```LIBRARY_STATIC```
+
+
+Create a new Module (BINARY):                               {#lutin_module_binary}
+=============================
+
+Generic Binary:                                             {#lutin_module_binary_base}
+---------------
+
+What to change:
+```python
+def get_type():
+	return "BINARY"
+```
+The Binay is compile by default target mode (note that the IOs target generate a single .so with all the library inside)
+
+You can force the Binary to be use dynamic library when possible: ```BINARY_SHARED``` or create a single binary with no .so depenency: ```BINARY_STAND_ALONE```
+
+Create a new Module (TEST-BINARY / TOOL-BINARY):            {#lutin_module_binary_tools}
+------------------------------------------------
+
+Two binary are really usefull in developpement, the tools and the test-unit, This is the reason why we specify for this 2 cases.
+
+Add the subElement description:
+```python
+def get_type():
+	return "BINARY"
+
+def get_sub_type():
+	return "TEST"
+```
+or:
+```python
+def get_type():
+	return "BINARY"
+
+def get_sub_type():
+	return "TOOL"
+```
+
+
+Create a new Module (DATA):                                  {#lutin_module_data}
+===========================
+
+This pode permit to only copy data and no dependency with compilling system
+
+What to change:
+```python
+def get_type():
+	return "DATA"
+```
+
+
+Module internal specifications:                               {#lutin_module_internal}
+===============================
+
+Add file to compile:                                          {#lutin_module_internal_compile}
+--------------------
+
+This is simple: (you just need to specify all the file to compile)
+
+```python
+def create(target, module_name):
+	...
+	
+	# add the file to compile:
+	my_module.add_src_file([
+	    'module-name/file1.cpp',
+	    'module-name/file2.cpp',
+	    'module-name/file3.S'
+	    ])
+	
+	...
+```
+
+Include directory & install header:                           {#lutin_module_internal_header}
+-----------------------------------
+
+A big point to understand is that your library will be used by an other module, then it need to use headers.
+
+The developper must isolate the external include and internal include, then lutin "install" the header and add the "install" header path to build the local library.
+This permit to check error inclusion directly in developpement and separate the ```#include "XXX.h"``` and the ```#include <lib-xxx/XXX.h>```
+
+Add file to external include:
+```python
+def create(target, module_name):
+	...
+	
+	my_module.add_header_file([
+	    'module-name/file1.h',
+	    'module-name/file2.h'
+	    ])
+	
+	...
+```
+
+You can add a path to your local include:
+```python
+def create(target, module_name):
+	...
+	
+	my_module.add_path(os.path.join(tools.get_current_path(__file__), "lib-name"))
+	
+	...
+```
+
+
+Add Sub-dependency:                                           {#lutin_module_internal_depend}
+-------------------
+
+All library need to add at minimum of a simple library (C lib) and other if needed. To do it jus call:
+```python
+def create(target, module_name):
+	...
+	
+	# add dependency of the generic C library:
+	my_module.add_module_depend('c')
+	# add dependency of the generic C++ library:
+	my_module.add_module_depend('cxx')
+	# add dependency of the generic math library:
+	my_module.add_module_depend('m')
+	# or other user lib:
+	my_module.add_module_depend('lib-name')
+	
+	...
+```
+
+The system can have optinnal sub-library, then if you just want to add an optionnal dependency:
+```python
+def create(target, module_name):
+	...
+	
+	# Add an optionnal dependency (set flag in CPP build if the subLib exist) ==> flag is locally set
+	my_module.add_optionnal_module_depend('z', ["c++", "-DLIB_NAME_BUILD_ZLIB"])
+	
+	# Add an optionnal dependency (set flag in CPP build if the subLib exist) ==> flag is exported in external upper build
+	my_module.add_optionnal_module_depend('z', ["c++", "-DLIB_NAME_BUILD_ZLIB"], export=True)
+	
+	...
+```
+
+Compilation adn link flags/libs:                              {#lutin_module_internal_flag}
+--------------------------------
+
+It is possible to define local and external flags (external are set internal too):
+```python
+def create(target, module_name):
+	...
+	# external flags:
+	my_module.add_flag('link-lib', "pthread", export=True)
+	my_module.add_flag('c++', "-DHELLO_FLAG=\"kljlkj\"", export=True)
+	# internal flags:
+	my_module.add_flag('c', "-DMODE_RELEASE")
+	
+	...
+```
+
+build mode (release/debug):                                   {#lutin_module_internal_target_mode}
+---------------------------
+
+To add somes element dependent of the build mode:
+```python
+def create(target, module_name):
+	...
+	
+	if target.get_mode() == "release":
+		pass
+	else:
+		pass
+	
+	...
+```
+
+build type target:                                            {#lutin_module_internal_target_type}
+------------------
+
+To add somes element dependent of the target type:
+
+```python
+def create(target, module_name):
+	...
+	
+	if "Windows" in target.get_type():
+		pass
+	elif "MacOs" in target.get_type():
+		pass
+	elif "IOs" in target.get_type():
+		pass
+	elif "Linux" in target.get_type():
+		pass
+	elif "Android" in target.get_type():
+		pass
+	...
+```
+
+The target get_type return a list of type that represent the hiararchy dependency, a simple example:
+
+A "Debian" herited of a "Linux" then it will return ["Linux", "Debian"]
+
+
+
+Add some data in the install path (share path):                {#lutin_module_internal_data}
+-----------------------------------------------
+
+You can install a simple file:
+
+```python
+def create(target, module_name):
+	...
+	
+	# copy file in the share/binanyName/ path (no sub path)
+	my_module.copy_path('data/icon.svg')
+	
+	...
+```
+
+Copy multiple files (change path)
+
+```python
+def create(target, module_name):
+	...
+	
+	my_module.copy_path('data/*', 'destinationPath')
+	
+	...
+```
+
+display some debug to help writing code:                       {#lutin_module_internal_write_log}
+----------------------------------------
+
+
+```python
+import lutin.debug as debug
+
+def function(...):
+	
+	debug.error("comment that stop the build")
+	debug.warning("comment that print a simple warning")
+	debug.info("comment that print a simple information")
+	debug.debug("comment that print a simple debug")
+	debug.verbose("comment that print a simple verbose")
+	
+```
+
+A Full template:                                               {#lutin_module_full_template}
+================
+
+Create the file:
+```
+	lutin_module-name.py
+```
+
+With:
+```python
+#!/usr/bin/python
+import lutin.module as module
+import lutin.tools as tools
+import lutin.debug as debug
+import os
+
+# A simple list of type:
+#    - BINARY
+#    - BINARY_SHARED
+#    - BINARY_STAND_ALONE
+#    - LIBRARY
+#    - LIBRARY_DYNAMIC
+#    - LIBRARY_STATIC
+#    - PACKAGE
+#    - PREBUILD
+#    - DATA
+def get_type():
+	return "LIBRARY"
+
+# simple description of the module that appear in the 'lutin -h'
+# Note: this fucntion is optionnal.
+def get_desc():
+	return "Descriptiuon of the PROGRAMM"
+
+# type of licence:
+#    "APACHE-2"
+#    "BSD-1" / "BSD-2" / "BSD-3" / "BSD-4"
+#    "GPL-1" / "GPL-2" / "GPL-3"
+#    "LGPL-1" / "LGPL-2" / "LGPL-3"
+#    PROPRIETARY
+#    ...
+# Note: this fucntion is optionnal.
+def get_licence():
+	return "PROPRIETARY"
+
+# type of compagny that provide the software:
+#    com : Commercial
+#    net : Network??
+#    org : Organisation
+#    gov : Governement
+#    mil : Military
+#    edu : Education
+#    pri : Private
+#    museum : ...
+#    ...
+# Note: this fucntion is optionnal.
+def get_compagny_type():
+	return "com"
+
+# Name of the compagny
+# Note: this fucntion is optionnal.
+def get_compagny_name():
+	return "hello-compagny"
+
+# People to contact if a problem appear in the build system / library
+# Note: this fucntion is optionnal.
+def get_maintainer():
+	return ["Mr NAME SurName <my-email@group.com>"]
+
+# Version of the library
+# Note: this fucntion is optionnal.
+def get_version():
+	return [0,1,"dev"]
+
+# create the module
+# @param[in] target reference on the Target that is currently build
+# @param[in] module_name Name of the module that is extract from the file name (to be generic)
+def create(target, module_name):
+	my_module = module.Module(__file__, module_name, get_type())
+	
+	# add the file to compile:
+	my_module.add_src_file([
+	    'module-name/file1.cpp',
+	    'module-name/file2.cpp',
+	    'module-name/file3.S'
+	    ])
+	
+	my_module.add_header_file([
+	    'module-name/file1.h',
+	    'module-name/file2.h'
+	    ])
+	
+	my_module.add_path(os.path.join(tools.get_current_path(__file__), "lib-name"))
+	
+	# add dependency of the generic C library:
+	my_module.add_module_depend('c')
+	# add dependency of the generic C++ library:
+	my_module.add_module_depend('cxx')
+	# add dependency of the generic math library:
+	my_module.add_module_depend('m')
+	# or other user lib:
+	my_module.add_module_depend([
+	    'lib-name1',
+	    'lib-name2'
+	    ])
+	
+	# Add an optionnal dependency (set flag in CPP build if the subLib exist) ==> flag is locally set
+	my_module.add_optionnal_module_depend('z', ["c++", "-DLIB_NAME_BUILD_ZLIB"])
+	
+	# Add an optionnal dependency (set flag in CPP build if the subLib exist) ==> flag is exported in external upper build
+	my_module.add_optionnal_module_depend('z', ["c++", "-DLIB_NAME_BUILD_ZLIB"], export=True)
+	
+	# external flags:
+	my_module.add_flag('link-lib', "pthread", export=True)
+	my_module.add_flag('c++', "-DHELLO_FLAG=\"kljlkj\"", export=True)
+	# internal flags:
+	my_module.add_flags('c', "-DMODE_RELEASE")
+	
+	if target.get_mode() == "release":
+		pass
+	else:
+		pass
+	
+	if "Windows" in target.get_type():
+		pass
+	elif "MacOs" in target.get_type():
+		pass
+	elif "IOs" in target.get_type():
+		pass
+	elif "Linux" in target.get_type():
+		pass
+	elif "Android" in target.get_type():
+		pass
+	
+	# copy file in the share/binanyName/ path (no sub path)
+	my_module.copy_path('data/icon.svg')
+	
+	my_module.copy_path('data/*', 'destinationPath')
+	
+	return my_module
+```
+
+
+**Index:**
+  - @ref mainpage
+  - @ref lutin_concept
+  - @ref lutin_use
+  - @ref lutin_module
+

doc/mainpage.md

@@ -0,0 +1,140 @@
+Lutin Build system                               {#mainpage}
+==================
+
+@tableofcontents
+
+`lutin` is a generic builder and package maker is a FREE software tool.
+
+
+![Py package](https://badge.fury.io/py/lutin.png) https://pypi.python.org/pypi/lutin
+
+
+Release (master)                                 {#lutin_mainpage_build_master}
+================
+
+![Build Status](https://travis-ci.org/HeeroYui/lutin.svg?branch=master) https://travis-ci.org/HeeroYui/lutin
+
+
+Developement (dev)                               {#lutin_mainpage_build_dev}
+==================
+
+![Build Status](https://travis-ci.org/HeeroYui/lutin.svg?branch=dev) https://travis-ci.org/HeeroYui/lutin
+
+
+What is Lutin?                                   {#lutin_mainpage_intro}
+==============
+
+Lutin is an application/library builder, it is designed to concurence CMake, Makefile, Ant, graddle ...
+
+Lutin is deveopped in Python 2.x and 3.x to permit many user to play with it.
+
+Python permit to Lutin to be used in many environement in a fast way.
+
+Lutin support can compile every thing you want, just add a builder that you need (not in the common way). Basicly Lutin support languages:
+  - C (ainsi/89/99) ==> .o;
+  - C++ (98/99/03/11/14/...) ==> .o;
+  - .S (assembleur) ==> .o;
+  - .java ==> .class;
+  - .class ==> jar;
+  - .o ==> .a;
+  - .o ==> .so;
+  - .o/.a ==> binary.
+
+Some packege can be generate for some platform:
+  - debian package;
+  - windows application zip;
+  - MacOs application .app;
+  - iOs package;
+  - Android Package .apk.
+
+Compilation is availlable for:
+  - gcc/g++;
+  - clang/clang++.
+
+Manage **workspace build** (in oposition of CMake/make/...)
+
+
+Install:                                         {#lutin_mainpage_installation}
+========
+
+Requirements: ``Python >= 2.7`` and ``pip``
+
+Install lutin:
+--------------
+
+Just run:
+```bash
+	pip install lutin
+```
+
+Install pip:
+------------
+
+Install pip on debian/ubuntu:
+```bash
+	sudo apt-get install pip
+```
+
+Install pip on ARCH-linux:
+```bash
+	sudo pacman -S pip
+```
+
+Install pip on MacOs:
+```bash
+	sudo easy_install pip
+```
+
+Install from sources:
+---------------------
+
+```bash
+	git clone http://github.com/HeeroYui/lutin.git
+	cd lutin
+	sudo ./setup.py install
+```
+
+git repository                                   {#lutin_mainpage_repository}
+==============
+
+http://github.com/HeeroYui/lutin/
+
+Tutorals:                                        {#lutin_mainpage_tutorial}
+=========
+
+  - @ref lutin_concept
+  - @ref lutin_use
+  - @ref lutin_module
+
+
+License (APACHE v2.0)                            {#lutin_mainpage_licence}
+=====================
+
+Copyright lutin Edouard DUPIN
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+
+History:                                         {#lutin_mainpage_history}
+========
+
+I work with some builder, Every one have theire own adventages, and their problems.
+The main point I see, is that the polimorphisme of the worktree is really hard.
+The second point is the generation on different platforms is hard too.
+
+Some other problem example:
+  - Makefile is too slow on windows mingw;
+  - Cmake does not create end point package;
+  - none is really simple to write.
+
+Then I create a simple interface that manage all I need. and written in python to permit to be faster on every platform.

doxy_lutin.py

@@ -0,0 +1,35 @@
+#!/usr/bin/python
+import os
+import doxy.module as module
+import doxy.debug as debug
+import doxy.tools as tools
+
+def create(target, module_name):
+	my_module = module.Module(__file__, module_name)
+	my_module.set_version([2,0,0])
+	my_module.set_title("lutin: build system and packager")
+	my_module.set_website("http://HeeroYui.github.io/" + module_name)
+	my_module.set_website_sources("http://github.com/HeeroYui/" + module_name)
+	my_module.add_path([
+	    module_name,
+	    "doc"
+	    ])
+	my_module.add_exclude_symbols([
+	    '_*',
+	    'lutinTarget_*',
+	    'lutinSystem_*',
+	    'lutinBuilder_*',
+	    ])
+	my_module.add_file_patterns([
+	    #'*.py',
+	    'builder.py',
+	    'debug.py',
+	    'env.py',
+	    'host.py',
+	    'module.py',
+	    'system.py',
+	    'target.py',
+	    '*.md',
+	    ])
+	
+	return my_module

lutin.py

@@ -1,238 +0,0 @@
-#!/usr/bin/python
-##
-## @author Edouard DUPIN
-##
-## @copyright 2012, Edouard DUPIN, all right reserved
-##
-## @license APACHE v2.0 (see license file)
-##
-
-# for path inspection:
-import sys
-import os
-import inspect
-import fnmatch
-import lutinDebug as debug
-import lutinEnv
-import lutinModule
-import lutinMultiprocess
-import lutinArg
-
-myLutinArg = lutinArg.LutinArg()
-myLutinArg.add(lutinArg.ArgDefine("h", "help", desc="display this help"))
-myLutinArg.add_section("option", "Can be set one time in all case")
-myLutinArg.add(lutinArg.ArgDefine("v", "verbose", list=[["0","None"],["1","error"],["2","warning"],["3","info"],["4","debug"],["5","verbose"],["6","extreme_verbose"]], desc="display makefile debug level (verbose) default =2"))
-myLutinArg.add(lutinArg.ArgDefine("C", "color", desc="display makefile output in color"))
-myLutinArg.add(lutinArg.ArgDefine("f", "force", desc="Force the rebuild without checking the dependency"))
-myLutinArg.add(lutinArg.ArgDefine("P", "pretty", desc="print the debug has pretty display"))
-myLutinArg.add(lutinArg.ArgDefine("j", "jobs", haveParam=True, desc="Specifies the number of jobs (commands) to run simultaneously"))
-myLutinArg.add(lutinArg.ArgDefine("s", "force-strip", desc="Force the stripping of the compile elements"))
-
-myLutinArg.add_section("properties", "keep in the sequency of the cible")
-myLutinArg.add(lutinArg.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'"))
-myLutinArg.add(lutinArg.ArgDefine("c", "compilator", list=[["clang",""],["gcc",""]], desc="Compile with clang or Gcc mode (by default gcc will be used)"))
-myLutinArg.add(lutinArg.ArgDefine("m", "mode", list=[["debug",""],["release",""]], desc="Compile in release or debug mode (default release)"))
-myLutinArg.add(lutinArg.ArgDefine("a", "arch", list=[["auto","Automatic choice"],["arm","Arm processer"],["x86","Generic PC : AMD/Intel"],["ppc","Power PC"]], desc="Architecture to compile"))
-myLutinArg.add(lutinArg.ArgDefine("b", "bus", list=[["auto","Automatic choice"],["32","32 bits"],["64","64 bits"]], desc="Adressing size (Bus size)"))
-myLutinArg.add(lutinArg.ArgDefine("p", "package", desc="Disable the package generation (usefull when just compile for test on linux ...)"))
-myLutinArg.add(lutinArg.ArgDefine("g", "gcov", desc="Enable code coverage intrusion in code"))
-myLutinArg.add(lutinArg.ArgDefine("", "simulation", desc="simulater mode (availlable only for IOS)"))
-myLutinArg.add(lutinArg.ArgDefine("", "list-target", desc="list all availlables targets ==> for auto completion"))
-myLutinArg.add(lutinArg.ArgDefine("", "list-module", desc="list all availlables module ==> for auto completion"))
-
-myLutinArg.add_section("cible", "generate in order set")
-localArgument = myLutinArg.parse()
-
-"""
-	display the help of this makefile
-"""
-def usage():
-	# generic argument displayed : 
-	myLutinArg.display()
-	print "		All target can finish with '-clean' '-dump' ..."
-	print "		all"
-	print "			build all (only for the current selected board) (bynary and packages)"
-	print "		clean"
-	print "			clean all (same as previous)"
-	print "		dump"
-	print "			Dump all the module dependency and properties"
-	listOfAllModule = lutinModule.list_all_module_with_desc()
-	for mod in listOfAllModule:
-		print "		" + mod[0]
-		if mod[1] != "":
-			print "			" + mod[1]
-	print "	ex: " + sys.argv[0] + " all --target=Android all -t Windows -m debug all"
-	exit(0)
-
-# preparse the argument to get the verbose element for debug mode
-def parseGenericArg(argument,active):
-	if argument.get_option_nName() == "help":
-		#display help
-		if active==False:
-			usage()
-		return True
-	if argument.get_option_nName() == "list-module":
-		if active==False:
-			listOfModule = lutinModule.list_all_module()
-			retValue = ""
-			for moduleName in listOfModule:
-				if retValue != "":
-					retValue += " "
-				retValue += moduleName
-			print retValue
-			exit(0)
-		return True
-	if argument.get_option_nName() == "list-target":
-		if active==False:
-			listOfTarget = lutinTarget.list_all_target()
-			retValue = ""
-			for targetName in listOfTarget:
-				if retValue != "":
-					retValue += " "
-				retValue += targetName
-			print retValue
-			exit(0)
-		return True
-	elif argument.get_option_nName()=="jobs":
-		if active==True:
-			lutinMultiprocess.set_core_number(int(argument.get_arg()))
-		return True
-	elif argument.get_option_nName() == "verbose":
-		if active==True:
-			debug.set_level(int(argument.get_arg()))
-		return True
-	elif argument.get_option_nName() == "color":
-		if active==True:
-			debug.enable_color()
-		return True
-	elif argument.get_option_nName() == "force":
-		if active==True:
-			lutinEnv.set_force_mode(True)
-		return True
-	elif argument.get_option_nName() == "pretty":
-		if active==True:
-			lutinEnv.set_print_pretty_mode(True)
-		return True
-	elif argument.get_option_nName() == "force-strip":
-		if active==True:
-			lutinEnv.set_force_strip_mode(True)
-		return True
-	return False
-
-# parse default unique argument:
-if __name__ == "__main__":
-	for argument in localArgument:
-		parseGenericArg(argument, True)
-
-# now import other standard module (must be done here and not before ...
-import lutinTarget
-import lutinSystem
-import lutinHost
-import lutinTools
-
-"""
-	Run everything that is needed in the system
-"""
-def Start():
-	#available target : Linux / MacOs / Windows / Android ...
-	targetName=lutinHost.OS
-	config = {
-	             "compilator":"gcc",
-	             "mode":"release",
-	             "bus-size":"auto",
-	             "arch":"auto",
-	             "generate-package":True,
-	             "simulation":False,
-	             "gcov":False
-	          }
-	# load the default target :
-	target = None
-	actionDone=False
-	# parse all argument
-	for argument in localArgument:
-		if True==parseGenericArg(argument, False):
-			continue
-		elif argument.get_option_nName() == "package":
-			config["generate-package"]=False
-		elif argument.get_option_nName() == "simulation":
-			config["simulation"]=True
-		elif argument.get_option_nName() == "gcov":
-			config["gcov"]=True
-		elif argument.get_option_nName() == "bus":
-			config["bus-size"]=argument.get_arg()
-		elif argument.get_option_nName() == "arch":
-			config["arch"]=argument.get_arg()
-		elif argument.get_option_nName() == "compilator":
-			if config["compilator"] != argument.get_arg():
-				debug.debug("change compilator ==> " + argument.get_arg())
-				config["compilator"] = argument.get_arg()
-				#remove previous target
-				target = None
-		elif argument.get_option_nName() == "target":
-			# No check input ==> this will be verify automaticly chen the target will be loaded
-			if targetName!=argument.get_arg():
-				targetName=argument.get_arg()
-				debug.debug("change target ==> '" + targetName + "' & reset mode : gcc&release")
-				#reset properties by defauult:
-				config = {
-				             "compilator":"gcc",
-				             "mode":"release",
-				             "bus-size":"auto",
-				             "arch":"auto",
-				             "generate-package":True,
-				             "simulation":False,
-				             "gcov":False
-				          }
-				#remove previous target
-				target = None
-		elif argument.get_option_nName() == "mode":
-			if config["mode"]!=argument.get_arg():
-				config["mode"] = argument.get_arg()
-				debug.debug("change mode ==> " + config["mode"])
-				#remove previous target
-				target = None
-		else:
-			if argument.get_option_nName() != "":
-				debug.warning("Can not understand argument : '" + argument.get_option_nName() + "'")
-				usage()
-			else:
-				#load the target if needed :
-				if target == None:
-					target = lutinTarget.load_target(targetName, config)
-				target.build(argument.get_arg())
-				actionDone=True
-	# if no action done : we do "all" ...
-	if actionDone==False:
-		#load the target if needed :
-		if target == None:
-			target = lutinTarget.load_target(targetName, config)
-		target.build("all")
-	# stop all started threads 
-	lutinMultiprocess.un_init()
-
-"""
-	When the user use with make.py we initialise ourself
-"""
-if __name__ == '__main__':
-	debug.verbose("Use Make as a make stadard")
-	sys.path.append(lutinTools.get_run_folder())
-	debug.verbose(" try to impoert module 'lutinBase.py'")
-	if os.path.exists("lutinBase.py" )==True:
-		__import__("lutinBase")
-	else:
-		debug.debug("missing file lutinBase.py ==> loading subPath...");
-		# Import all sub path without out and archive
-		for folder in os.listdir("."):
-			if os.path.isdir(folder)==True:
-				if     folder.lower()!="android" \
-				   and folder.lower()!="archive" \
-				   and folder.lower()!="out" :
-					debug.debug("Automatic load path: '" + folder + "'")
-					lutinModule.import_path(folder)
-					lutinSystem.import_path(folder)
-					lutinTarget.import_path(folder)
-		#lutinSystem.display()
-	Start()
-
-
-

lutin/__init__.py

@@ -0,0 +1,155 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+import os
+import sys
+import fnmatch
+# Local import
+from . import target
+from . import builder
+from . import system
+from . import host
+from . import tools
+from . import debug
+from . import module
+from . import env
+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())
+	# 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 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

@@ -0,0 +1,378 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+import sys
+from . import debug
+
+##
+## @brief Single argument class. It permit to define the getted argument.
+##
+class ArgElement:
+	##
+	## @brief Contructor.
+	## @param[in] self Class handle
+	## @param[in] option (string) Option name (write in fullmode ex: '--verbose' even if user write '-v')
+	## @param[in] value (string) Writed value by the user (defult '')
+	##
+	def __init__(self, option, value=""):
+		self.option = option;
+		self.arg = value;
+	
+	##
+	## @brief Get the name of the argument: (write in fullmode ex: '--verbose' even if user write '-v')
+	## @param[in] self Class handle
+	## @return (string) The argument name
+	##
+	def get_option_name(self):
+		return self.option
+	
+	##
+	## @brief Get argument data set by the user
+	## @param[in] self Class handle
+	## @return (string) The argument value
+	##
+	def get_arg(self):
+		return self.arg
+	
+	##
+	## @brief Display the Argument property
+	## @param[in] self Class handle
+	##
+	def display(self):
+		if len(self.arg) == 0:
+			debug.info("option : " + self.option)
+		elif len(self.option) == 0:
+			debug.info("element :       " + self.arg)
+		else:
+			debug.info("option : " + self.option + ":" + self.arg)
+
+##
+## @brief Declare a possibility of an argument value
+##
+class ArgDefine:
+	##
+	## @brief Contructor.
+	## @param[in] self Class handle
+	## @param[in] smallOption (char) Value for the small option ex: '-v' '-k' ... 1 single char element (no need of '-')
+	## @param[in] bigOption (string) Value of the big option name ex: '--verbose' '--kill' ... stated with -- and with the full name (no need of '--')
+	## @param[in] list ([[string,string],...]) Optionnal list of availlable option: '--mode=debug' ==> [['debug', 'debug mode'],['release', 'release the software']]
+	## @param[in] desc (string) user friendly description with this parameter (default "")
+	## @param[in] haveParam (bool) The option must have a parameter (default False)
+	##
+	def __init__(self,
+	             smallOption="", # like v for -v
+	             bigOption="", # like verbose for --verbose
+	             list=[], # ["val", "description"]
+	             desc="",
+	             haveParam=False):
+		self.option_small = smallOption;
+		self.option_big = bigOption;
+		self.list = list;
+		if len(self.list)!=0:
+			self.have_param = True
+		else:
+			if True==haveParam:
+				self.have_param = True
+			else:
+				self.have_param = False
+		self.description = desc;
+	
+	##
+	## @brief Get the small name of the option ex: '-v'
+	## @param[in] self Class handle
+	## @return (string) Small name value
+	##
+	def get_option_small(self):
+		return self.option_small
+	
+	##
+	## @brief Get the big name of the option ex: '--verbose'
+	## @param[in] self Class handle
+	## @return (string) Big name value
+	##
+	def get_option_big(self):
+		return self.option_big
+	
+	##
+	## @brief Get the status of getting user parameter value
+	## @param[in] self Class handle
+	## @return True The user must write a value
+	## @return False The user must NOT write a value
+	##
+	def need_parameters(self):
+		return self.have_param
+	
+	##
+	## @brief Compatibility with @ref ArgSection class
+	## @param[in] self Class handle
+	## @return (string) empty string
+	##
+	def get_porperties(self):
+		return ""
+	
+	##
+	## @brief Check if the user added value is correct or not with the list of availlable value
+	## @param[in] self Class handle
+	## @param[in] argument (string) User parameter value (string)
+	## @return True The parameter is OK
+	## @return False The parameter is NOT Availlable
+	##
+	def check_availlable(self, argument):
+		if len(self.list)==0:
+			return True
+		for element,desc in self.list:
+			if element == argument:
+				return True
+		return False
+	
+	##
+	## @brief Display the argument property when user request help
+	## @param[in] self Class handle
+	##
+	def display(self):
+		color = debug.get_color_set()
+		if self.option_small != "" and self.option_big != "":
+			print("		" + color['red'] + "-" + self.option_small + "" + color['default'] + " / " + color['red'] + "--" + self.option_big + color['default'])
+		elif self.option_small != "":
+			print("		" + color['red'] + "-" + self.option_small + color['default'])
+		elif self.option_big != "":
+			print("		" + color['red'] + "--" + self.option_big + color['default'])
+		else:
+			print("		???? ==> internal error ...")
+		if self.description != "":
+			print("			" + self.description)
+		if len(self.list)!=0:
+			hasDescriptiveElement=False
+			for val,desc in self.list:
+				if desc!="":
+					hasDescriptiveElement=True
+					break;
+			if hasDescriptiveElement==True:
+				for val,desc in self.list:
+					print("				" + val + " : " + desc)
+			else:
+				tmpElementPrint = ""
+				for val,desc in self.list:
+					if len(tmpElementPrint)!=0:
+						tmpElementPrint += " / "
+					tmpElementPrint += val
+				print("				{ " + tmpElementPrint + " }")
+
+
+##
+## @brief Section Class definition (permit to add a comment when requesting help
+##
+class ArgSection:
+	##
+	## @brief Constructor
+	## @param[in] self Class handle
+	## @param[in] sectionName (string) Name of the cestion ex: "option" is displayed [option]
+	## @param[in] desc (string) Comment assiciated with the group
+	##
+	def __init__(self,
+	             sectionName="",
+	             desc=""):
+		self.section = sectionName;
+		self.description = desc;
+	
+	##
+	## @brief Compatibility with @ref ArgDefine class
+	## @param[in] self Class handle
+	## @return empty string
+	##
+	def get_option_small(self):
+		return ""
+	
+	##
+	## @brief Compatibility with @ref ArgDefine class
+	## @param[in] self Class handle
+	## @return empty string
+	##
+	def get_option_big(self):
+		return ""
+	
+	##
+	## @brief get property print value with the correct writing mode
+	## @param[in] self Class handle
+	## @return String to display in the short line help
+	##
+	def get_porperties(self):
+		color = debug.get_color_set()
+		return " [" + color['blue'] + self.section + color['default'] + "]"
+	
+	##
+	## @brief Display the argument property when user request help
+	## @param[in] self Class handle
+	##
+	def display(self):
+		color = debug.get_color_set()
+		print("	[" + color['blue'] + self.section + color['default'] + "] : " + self.description)
+
+
+##
+## @brief Class to define the agmument list availlable for a program
+##
+class LutinArg:
+	##
+	## @brief Constructor.
+	## @param[in] self Class handle
+	##
+	def __init__(self):
+		self.list_properties = []
+	
+	##
+	## @brief Add a new argument possibilities...
+	## @param[in] self Class handle
+	## @param[in] smallOption (char) Value for the small option ex: '-v' '-k' ... 1 single char element (no need of '-')
+	## @param[in] bigOption (string) Value of the big option name ex: '--verbose' '--kill' ... stated with -- and with the full name (no need of '--')
+	## @param[in] list ([[string,string],...]) Optionnal list of availlable option: '--mode=debug' ==> [['debug', 'debug mode'],['release', 'release the software']]
+	## @param[in] desc (string) user friendly description with this parameter (default "")
+	## @param[in] haveParam (bool) The option must have a parameter (default False)
+	##
+	def add(self, smallOption="", bigOption="", list=[], desc="", haveParam=False):
+		self.list_properties.append(ArgDefine(smallOption, bigOption, list, desc, haveParam))
+	
+	##
+	## @brief Add section on argument list
+	## @param[in] self Class handle
+	## @param[in] sectionName (string) Name of the cestion ex: "option" is displayed [option]
+	## @param[in] sectionDesc (string) Comment assiciated with the group
+	##
+	def add_section(self, sectionName, sectionDesc):
+		self.list_properties.append(ArgSection(sectionName, sectionDesc))
+	
+	##
+	## @brief Parse the argument set in the command line
+	## @param[in] self Class handle
+	##
+	def parse(self):
+		listArgument = [] # composed of list element
+		NotparseNextElement=False
+		for iii in range(1, len(sys.argv)):
+			# special case of parameter in some elements
+			if NotparseNextElement==True:
+				NotparseNextElement = False
+				continue
+			debug.verbose("parse [" + str(iii) + "]=" + sys.argv[iii])
+			argument = sys.argv[iii]
+			optionList = argument.split("=")
+			debug.verbose(str(optionList))
+			if type(optionList) == type(str()):
+				option = optionList
+			else:
+				option = optionList[0]
+			optionParam = argument[len(option)+1:]
+			debug.verbose(option)
+			argumentFound=False;
+			if option[:2]=="--":
+				# big argument
+				for prop in self.list_properties:
+					if prop.get_option_big()=="":
+						continue
+					if prop.get_option_big() == option[2:]:
+						# find it
+						debug.verbose("find argument 2 : " + option[2:])
+						if prop.need_parameters()==True:
+							internalSub = option[2+len(prop.get_option_big()):]
+							if len(internalSub)!=0:
+								if len(optionParam)!=0:
+									# wrong argument ...
+									debug.warning("maybe wrong argument for : '" + prop.get_option_big() + "' cmdLine='" + argument + "'")
+									prop.display()
+									continue
+								optionParam = internalSub
+							if len(optionParam)==0:
+								#Get the next parameters 
+								if len(sys.argv) > iii+1:
+									optionParam = sys.argv[iii+1]
+									NotparseNextElement=True
+								else :
+									# missing arguments
+									debug.warning("parsing argument error : '" + prop.get_option_big() + "' Missing : subParameters ... cmdLine='" + argument + "'")
+									prop.display()
+									exit(-1)
+							if prop.check_availlable(optionParam)==False:
+								debug.warning("argument error : '" + prop.get_option_big() + "' SubParameters not availlable ... cmdLine='" + argument + "' option='" + optionParam + "'")
+								prop.display()
+								exit(-1)
+							listArgument.append(ArgElement(prop.get_option_big(),optionParam))
+							argumentFound = True
+						else:
+							if len(optionParam)!=0:
+								debug.warning("parsing argument error : '" + prop.get_option_big() + "' need no subParameters : '" + optionParam + "'   cmdLine='" + argument + "'")
+								prop.display()
+							listArgument.append(ArgElement(prop.get_option_big()))
+							argumentFound = True
+						break;
+				if False==argumentFound:
+					debug.error("UNKNOW argument : '" + argument + "'")
+			elif option[:1]=="-":
+				# small argument
+				for prop in self.list_properties:
+					if prop.get_option_small()=="":
+						continue
+					if prop.get_option_small() == option[1:1+len(prop.get_option_small())]:
+						# find it
+						debug.verbose("find argument 1 : " + option[1:1+len(prop.get_option_small())])
+						if prop.need_parameters()==True:
+							internalSub = option[1+len(prop.get_option_small()):]
+							if len(internalSub)!=0:
+								if len(optionParam)!=0:
+									# wrong argument ...
+									debug.warning("maybe wrong argument for : '" + prop.get_option_big() + "' cmdLine='" + argument + "'")
+									prop.display()
+									continue
+								optionParam = internalSub
+							if len(optionParam)==0:
+								#Get the next parameters 
+								if len(sys.argv) > iii+1:
+									optionParam = sys.argv[iii+1]
+									NotparseNextElement=True
+								else :
+									# missing arguments
+									debug.warning("parsing argument error : '" + prop.get_option_big() + "' Missing : subParameters  cmdLine='" + argument + "'")
+									prop.display()
+									exit(-1)
+							if prop.check_availlable(optionParam)==False:
+								debug.warning("argument error : '" + prop.get_option_big() + "' SubParameters not availlable ... cmdLine='" + argument + "' option='" + optionParam + "'")
+								prop.display()
+								exit(-1)
+							listArgument.append(ArgElement(prop.get_option_big(),optionParam))
+							argumentFound = True
+						else:
+							if len(optionParam)!=0:
+								debug.warning("parsing argument error : '" + prop.get_option_big() + "' need no subParameters : '" + optionParam + "'  cmdLine='" + argument + "'")
+								prop.display()
+							listArgument.append(ArgElement(prop.get_option_big()))
+							argumentFound = True
+						break;
+			
+			if argumentFound==False:
+				#unknow element ... ==> just add in the list ...
+				debug.verbose("unknow argument : " + argument)
+				listArgument.append(ArgElement("", argument))
+			
+		#for argument in listArgument:
+		#	argument.display()
+		#exit(0)
+		return listArgument;
+	
+	##
+	## @brief Display help on console output
+	## @param[in] self Class handle
+	##
+	def display(self):
+		print("usage:")
+		listOfPropertiesArg = "";
+		for element in self.list_properties :
+			listOfPropertiesArg += element.get_porperties()
+		print("	" + sys.argv[0] + listOfPropertiesArg + " ...")
+		for element in self.list_properties :
+			element.display()
+

lutin/builder.py

@@ -0,0 +1,100 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+import sys
+import os
+import inspect
+import fnmatch
+import datetime
+# Local import
+from . import debug
+from . import heritage
+from . import env
+
+##
+## constitution of dictionnary:
+##     - "type": "compiler", "linker"
+##     - "in": input type file
+##     - "out": extention of the files
+##     - "builder": pointer on the element
+##
+builder_list=[]
+__start_builder_name="Builder_"
+
+##
+## @brief Import all File that start with env.get_build_system_base_name() + __start_builder_name + XXX and register in the list of Builder
+## @param[in] path_list ([string,...]) List of file that start with env.get_build_system_base_name() in the running worktree (Parse one time ==> faster)
+##
+def import_path(path_list):
+	global builder_list
+	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"]))
+
+
+##
+## @brief All builder are common (no target or comilator dependency). We need to load all of them when start lutin
+##
+def init():
+	global builder_list
+	debug.debug('BUILDER: Initialize all ...')
+	for element in builder_list:
+		if element["element"] != None:
+			element["element"].init()
+
+##
+## @brief Get a builder tool with specifiying the input type (like cpp, S ...)
+## @param[in] input_type (string) extention file that can be compile
+##
+def get_builder(input_type):
+	global builder_list
+	for element in builder_list:
+		if element["element"] != None:
+			if input_type in element["element"].get_input_type():
+				return element["element"]
+	# we can not find the builder ...
+	debug.error("Can not find builder for type : '" + str(input_type) + "'")
+	raise ValueError('type error :' + str(input_type))
+
+##
+## @brief Get a builder tool with specifiying the output type (like .exe, .jar ...)
+## @param[in] input_type (string) extention file that can be generated
+##
+def get_builder_with_output(output_type):
+	global builder_list
+	for element in builder_list:
+		if element["element"] != None:
+			if output_type in element["element"].get_output_type():
+				return element["element"]
+	# we can not find the builder ...
+	debug.error("Can not find builder for type : '" + str(output_type) + "'")
+	raise ValueError('type error :' + str(output_type))

lutin/debug.py

@@ -0,0 +1,262 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+
+import os
+import threading
+import re
+
+debug_level=3
+debug_color=False
+
+color_default= ""
+color_red    = ""
+color_green  = ""
+color_yellow = ""
+color_blue   = ""
+color_purple = ""
+color_cyan   = ""
+
+
+debug_lock = threading.Lock()
+
+##
+## @brief Set log level of the console log system
+## @param[in] id (int) Value of the log level:
+##              0: None
+##              1: error
+##              2: warning
+##              3: info
+##              4: debug
+##              5: verbose
+##              6: extreme_verbose
+##
+def set_level(id):
+	global debug_level
+	debug_level = id
+	#print "SetDebug level at " + str(debug_level)
+
+##
+## @brief Get the current debug leval
+## @return The value of the log level. Show: @ref set_level
+##
+def get_level():
+	global debug_level
+	return debug_level
+
+##
+## @brief Enable color of the console Log system
+##
+def enable_color():
+	global debug_color
+	debug_color = True
+	global color_default
+	color_default= "\033[00m"
+	global color_red
+	color_red    = "\033[31m"
+	global color_green
+	color_green  = "\033[32m"
+	global color_yellow
+	color_yellow = "\033[33m"
+	global color_blue
+	color_blue   = "\033[01;34m"
+	global color_purple
+	color_purple = "\033[35m"
+	global color_cyan
+	color_cyan   = "\033[36m"
+
+##
+## @brief Disable color of the console Log system
+##
+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   = ""
+
+##
+## @brief Print a extreme verbose log
+## @param[in] input (string) Value to print if level is enough
+## @param[in] force (bool) force display (no check of log level)
+##
+def extreme_verbose(input, force=False):
+	global debug_lock
+	global debug_level
+	if    debug_level >= 6 \
+	   or force == True:
+		debug_lock.acquire()
+		print(color_blue + input + color_default)
+		debug_lock.release()
+
+##
+## @brief Print a verbose log
+## @param[in] input (string) Value to print if level is enough
+## @param[in] force (bool) force display (no check of log level)
+##
+def verbose(input, force=False):
+	global debug_lock
+	global debug_level
+	if    debug_level >= 5 \
+	   or force == True:
+		debug_lock.acquire()
+		print(color_blue + input + color_default)
+		debug_lock.release()
+
+##
+## @brief Print a debug log
+## @param[in] input (string) Value to print if level is enough
+## @param[in] force (bool) force display (no check of log level)
+##
+def debug(input, force=False):
+	global debug_lock
+	global debug_level
+	if    debug_level >= 4 \
+	   or force == True:
+		debug_lock.acquire()
+		print(color_green + input + color_default)
+		debug_lock.release()
+
+##
+## @brief Print an info log
+## @param[in] input (string) Value to print if level is enough
+## @param[in] force (bool) force display (no check of log level)
+##
+def info(input, force=False):
+	global debug_lock
+	global debug_level
+	if    debug_level >= 3 \
+	   or force == True:
+		debug_lock.acquire()
+		print(input + color_default)
+		debug_lock.release()
+
+##
+## @brief Print a warning log
+## @param[in] input (string) Value to print if level is enough
+## @param[in] force (bool) force display (no check of log level)
+##
+def warning(input, force=False):
+	global debug_lock
+	global debug_level
+	if    debug_level >= 2 \
+	   or force == True:
+		debug_lock.acquire()
+		print(color_purple + "[WARNING] " + input + color_default)
+		debug_lock.release()
+
+##
+## @brief Print a todo log
+## @param[in] input (string) Value to print if level is enough
+## @param[in] force (bool) force display (no check of log level)
+##
+def todo(input, force=False):
+	global debug_lock
+	global debug_level
+	if    debug_level >= 3 \
+	   or force == True:
+		debug_lock.acquire()
+		print(color_purple + "[TODO] " + input + color_default)
+		debug_lock.release()
+
+##
+## @brief Print an error log
+## @param[in] input (string) Value to print if level is enough
+## @param[in] thread_id (int) Current thead ID of the builder thread
+## @param[in] force (bool) force display (no check of log level)
+## @param[in] crash (bool) build error has appear ==> request stop of all builds
+##
+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)
+		debug_lock.release()
+	if crash == True:
+		from . import multiprocess
+		multiprocess.set_error_occured()
+		if thread_id != -1:
+			threading.interrupt_main()
+		exit(-1)
+		#os_exit(-1)
+		#raise "error happend"
+
+
+##
+## @brief Print a log for a specific element action like generateing .so or binary ...
+## @param[in] type (string) type of action. Like: "copy file", "StaticLib", "Prebuild", "Library" ...
+## @param[in] lib (string) Name of the library/binary/package that action is done
+## @param[in] dir (string) build direction. ex: "<==", "==>" ...
+## @param[in] name (string) Destination of the data
+## @param[in] force (bool) force display (no check of log level)
+##
+def print_element(type, lib, dir, name, force=False):
+	global debug_lock
+	global debug_level
+	if    debug_level >= 3 \
+	   or force == True:
+		debug_lock.acquire()
+		print(color_cyan + type + color_default + " : " + color_yellow + lib + color_default + " " + dir + " " + color_blue + name + color_default)
+		debug_lock.release()
+
+##
+## @brief Print a compilation return (output)
+## @param[in] my_string (string) Std-error/std-info that is generate by the build system
+##
+def print_compilator(my_string):
+	global debug_color
+	global debug_lock
+	if debug_color == True:
+		my_string = my_string.replace('\\n', '\n')
+		my_string = my_string.replace('\\t', '\t')
+		my_string = my_string.replace('error:', color_red+'error:'+color_default)
+		my_string = my_string.replace('warning:', color_purple+'warning:'+color_default)
+		my_string = my_string.replace('note:', color_green+'note:'+color_default)
+		my_string = re.sub(r'([/\w_-]+\.\w+):', r'-COLORIN-\1-COLOROUT-:', my_string)
+		my_string = my_string.replace('-COLORIN-', color_yellow)
+		my_string = my_string.replace('-COLOROUT-', color_default)
+	
+	debug_lock.acquire()
+	print(my_string)
+	debug_lock.release()
+
+##
+## @brief Get the list of default color
+## @return A map with keys: "default","red","green","yellow","blue","purple","cyan"
+##
+def get_color_set() :
+	global color_default
+	global color_red
+	global color_green
+	global color_yellow
+	global color_blue
+	global color_purple
+	global color_cyan
+	return {
+	    "default": color_default,
+	    "red": color_red,
+	    "green": color_green,
+	    "yellow": color_yellow,
+	    "blue": color_blue,
+	    "purple": color_purple,
+	    "cyan": color_cyan,
+	    }

lutin/depend.py

@@ -0,0 +1,245 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+import os
+# Local import
+from . import debug
+from . import env
+
+def _create_directory_of_file(file):
+	path = os.path.dirname(file)
+	try:
+		os.stat(path)
+	except:
+		os.makedirs(path)
+
+def _file_write_data(path, data):
+	file = open(path, "w")
+	file.write(data)
+	file.close()
+
+def _file_size(path):
+	if not os.path.isfile(path):
+		return 0
+	statinfo = os.stat(path)
+	return statinfo.st_size
+
+def _file_read_data(path, binary=False):
+	if not os.path.isfile(path):
+		return ""
+	if binary == True:
+		file = open(path, "rb")
+	else:
+		file = open(path, "r")
+	data_file = file.read()
+	file.close()
+	return data_file
+
+##
+## @brief Creata a dependency file with a list of files
+## @param[in] depend_file (string) filename to store a dependency data
+## @param[in] list_files ([string,...]) List of file that depend the current element
+##
+def create_dependency_file(depend_file, list_files):
+	data = ""
+	for elem in list_files:
+		data += elem + "\n"
+	_create_directory_of_file(depend_file)
+	_file_write_data(depend_file, data)
+
+##
+## @brief Check if all dependency of a file and dependency file is correct or not
+## @param[in] dst (string) File that will be generated
+## @param[in] src (string) Source File needed to generate the 'dst'
+## @param[in] depend_file (string) Dependency file that contain all file that the src depending
+## @param[in] file_cmd (string) Filename of where is store the cmdline to generate the 'dst'
+## @param[in] cmd_line (string) Command line that will be use to generate the 'dst'
+## @param[in] force_identical (string) for copy file this check if the src and dst are identical
+## @return (bool) True: something change ==> need to rebuild, False otherwise
+##
+def need_re_build(dst, src, depend_file=None, file_cmd="", cmd_line="", force_identical=False):
+	debug.extreme_verbose("Request check of dependency of :")
+	debug.extreme_verbose("		dst='" + str(dst) + "'")
+	debug.extreme_verbose("		src='" + str(src) + "'")
+	debug.extreme_verbose("		dept='" + str(depend_file) + "'")
+	debug.extreme_verbose("		cmd='" + str(file_cmd) + "'")
+	debug.extreme_verbose("		force_identical='" + str(force_identical) + "'")
+	# if force mode selected ==> just force rebuild ...
+	if env.get_force_mode():
+		debug.extreme_verbose("			==> must rebuild (force mode)")
+		return True
+	
+	# check if the destination existed:
+	if     dst != "" \
+	   and dst != None \
+	   and os.path.exists(dst) == False:
+		debug.extreme_verbose("			==> must rebuild (dst does not exist)")
+		return True
+	if     src != "" \
+	   and src != None \
+	   and os.path.exists(src) == False:
+		debug.warning("			==> unexistant file :'" + src + "'")
+		return True
+	# Check the basic date if the 2 files
+	if     dst != "" \
+	   and dst != None \
+	   and src != "" \
+	   and src != None \
+	   and os.path.getmtime(src) > os.path.getmtime(dst):
+		debug.extreme_verbose("			==> must rebuild (source time greater)")
+		return True
+	
+	if     depend_file != "" \
+	   and depend_file != None \
+	   and os.path.exists(depend_file) == False:
+		debug.extreme_verbose("			==> must rebuild (no depending file)")
+		return True
+	
+	if     file_cmd != "" \
+	   and file_cmd != None:
+		if os.path.exists(file_cmd) == False:
+			debug.extreme_verbose("			==> must rebuild (no commandLine file)")
+			return True
+		# check if the 2 cmd_line are similar :
+		file2 = open(file_cmd, "r")
+		first_and_unique_line = file2.read()
+		if first_and_unique_line != cmd_line:
+			debug.extreme_verbose("			==> must rebuild (cmd_lines are not identical)")
+			debug.extreme_verbose("				==> '" + cmd_line + "'")
+			debug.extreme_verbose("				==> '" + first_and_unique_line + "'")
+			file2.close()
+			return True
+		# the cmdfile is correct ...
+		file2.close()
+	
+	if     depend_file != "" \
+	   and depend_file != None:
+		debug.extreme_verbose("			start parsing dependency file : '" + depend_file + "'")
+		file = open(depend_file, "r")
+		for cur_line in file.readlines():
+			# normal file : end with : ": \\n"
+			cur_line = cur_line[:len(cur_line)-1]
+			# removing last \ ...
+			if cur_line[len(cur_line)-1:] == '\\' :
+				cur_line = cur_line[:len(cur_line)-1]
+			# remove white space : 
+			#debug.verbose("				Line (read) : '" + cur_line + "'");
+			cur_line = cur_line.strip()
+			#debug.verbose("				Line (strip) : '" + cur_line + "'");
+			
+			test_file=""
+			if cur_line[len(cur_line)-1:] == ':':
+				debug.extreme_verbose("				Line (no check (already done) : '" + cur_line + "'");
+			elif    len(cur_line) == 0 \
+			     or cur_line == '\\':
+				debug.extreme_verbose("				Line (Not parsed) : '" + cur_line + "'");
+			else:
+				test_file = cur_line
+				debug.extreme_verbose("				Line (might check) : '" + test_file + "'");
+			# really check files:
+			if test_file != "":
+				debug.extreme_verbose("					==> test");
+				if False==os.path.exists(test_file):
+					debug.extreme_verbose("			==> must rebuild (a dependency file does not exist)")
+					file.close()
+					return True
+				if os.path.getmtime(test_file) > os.path.getmtime(dst):
+					debug.extreme_verbose("			==> must rebuild (a dependency file time is newer)")
+					file.close()
+					return True
+		# close the current file :
+		file.close()
+	# check the 2 files are identical:
+	if force_identical == True:
+		# check if the 2 cmd_line are similar:
+		size_src = _file_size(src)
+		size_dst = _file_size(dst)
+		if size_src != size_dst:
+			debug.extreme_verbose("			Force Rewrite not the same size     size_src=" + str(size_src) + " != size_dest=" + str(size_dst))
+			return True
+		data_src = _file_read_data(src, binary=True)
+		data_dst = _file_read_data(dst, binary=True)
+		if data_src != data_dst:
+			debug.extreme_verbose("			Force Rewrite not the same data")
+			return True
+	
+	debug.extreme_verbose("			==> Not rebuild (all dependency is OK)")
+	return False
+
+##
+## @brief 
+## @param[in] dst (string) File that will be generated
+## @param[in] src_list ([string,...]) Source file list needed to generate the 'dst'
+## @param[in] must_have_src (bool) All sources must be present
+## @param[in] file_cmd (string) Filename of where is store the cmdline to generate the 'dst'
+## @param[in] cmd_line (string) Command line that will be use to generate the 'dst'
+## @return (bool) True: Need to regenerate the package, False otherwise
+##
+def need_re_package(dst, src_list, must_have_src, file_cmd="", cmd_line=""):
+	debug.extreme_verbose("Request check of dependency of :")
+	debug.extreme_verbose("		dst='" + str(dst) + "'")
+	compleate_list = []
+	debug.extreme_verbose("		src:")
+	if type(src_list) == str:
+		compleate_list.append(src_list)
+		debug.extreme_verbose("			'" + src_list + "'")
+	elif type(src_list) == list:
+		for src in src_list:
+			compleate_list.append(src)
+			debug.extreme_verbose("			'" + str(src) + "'")
+	elif type(src_list) == dict:
+		for key in src_list:
+			debug.extreme_verbose("			'" + str(key) + "'")
+			for src in src_list[key]:
+				compleate_list.append(src)
+				debug.extreme_verbose("				'" + str(src) + "'")
+	
+	if     must_have_src == False \
+	   and len(compleate_list) == 0:
+		return False
+	
+	# if force mode selected ==> just force rebuild ...
+	if env.get_force_mode():
+		debug.extreme_verbose("			==> must re-package (force mode)")
+		return True
+	
+	# check if the destination existed:
+	if os.path.exists(dst) == False:
+		debug.extreme_verbose("			==> must re-package (dst does not exist)")
+		return True
+	# chek the basic date if the 2 files
+	if len(compleate_list) == 0:
+		debug.extreme_verbose("			==> must re-package (no source ???)")
+		return True
+	for src in compleate_list:
+		if os.path.getmtime(src) > os.path.getmtime(dst):
+			debug.extreme_verbose("			==> must re-package (source time greater) : '" + src + "'")
+			return True
+	
+	if ""!=file_cmd:
+		if False==os.path.exists(file_cmd):
+			debug.extreme_verbose("			==> must rebuild (no commandLine file)")
+			return True
+		# check if the 2 cmd_line are similar :
+		file2 = open(file_cmd, "r")
+		first_and_unique_line = file2.read()
+		if first_and_unique_line != cmd_line:
+			debug.extreme_verbose("			==> must rebuild (cmd_lines are not identical)")
+			debug.extreme_verbose("				==> '" + cmd_line + "'")
+			debug.extreme_verbose("				==> '" + first_and_unique_line + "'")
+			file2.close()
+			return True
+		# the cmdfile is correct ...
+		file2.close()
+	
+	debug.extreme_verbose("			==> Not re-package (all dependency is OK)")
+	return False
+
+
+

lutin/env.py

@@ -0,0 +1,211 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+
+# Local import
+from . import debug
+
+
+
+force_mode=False
+
+def set_force_mode(val):
+	global force_mode
+	if val==1:
+		force_mode = 1
+	else:
+		force_mode = 0
+
+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
+
+def set_print_pretty_mode(val):
+	global print_pretty_mode
+	if val == True:
+		print_pretty_mode = True
+	else:
+		print_pretty_mode = False
+
+def get_print_pretty_mode():
+	global print_pretty_mode
+	return print_pretty_mode
+
+store_warning=False
+def set_warning_mode(val):
+	global store_warning
+	if val == True:
+		store_warning = True
+	else:
+		store_warning = False
+
+def get_warning_mode():
+	global store_warning
+	return store_warning
+
+
+def end_with(name, list):
+	for appl in list:
+		#debug.info("pppppppp : " + str([name[-len(appl):], appl]))
+		if name[-len(appl):] == appl:
+			return True
+	return False
+
+
+def print_pretty(my_string, force=False):
+	global print_pretty_mode
+	if    print_pretty_mode == True \
+	   or force == True:
+		if my_string[len(my_string)-1] == ' ':
+			tmpcmdLine = my_string[:len(my_string)-1]
+		else:
+			tmpcmdLine = my_string
+		cmdApplication = tmpcmdLine.split(' ')[0]
+		tmpcmdLine = tmpcmdLine.replace(' ', '\n\t')
+		tmpcmdLine = tmpcmdLine.replace('\n\t\n\t', '\n\t')
+		tmpcmdLine = tmpcmdLine.replace('\n\t\n\t', '\n\t')
+		tmpcmdLine = tmpcmdLine.replace('\n\t\n\t', '\n\t')
+		baseElementList = []
+		if end_with(cmdApplication, ["javac"]) == True:
+			baseElementList = [
+			    "-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"
+			    ]
+		elif end_with(cmdApplication, ["aapt"]) == True:
+			baseElementList = [
+			    "-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",
+			    "-current_version",
+			    "-compatibility_version"
+			    ]
+
+		for element in baseElementList:
+			tmpcmdLine = tmpcmdLine.replace(element+'\n\t', element+' ')
+		for element in ["<", "<<", ">", ">>"]:
+			tmpcmdLine = tmpcmdLine.replace(element+'\n\t', element+' ')
+		tmpcmdLine = tmpcmdLine.replace('\n\t', ' \\\n\t')
+		
+		return tmpcmdLine
+	else:
+		return my_string
+
+force_strip_mode=False
+
+def set_force_strip_mode(val):
+	global force_strip_mode
+	if val == True:
+		force_strip_mode = True
+	else:
+		force_strip_mode = False
+
+def get_force_strip_mode():
+	global force_strip_mode
+	return force_strip_mode
+

lutin/heritage.py

@@ -0,0 +1,263 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+import sys
+import copy
+# Local import
+from . import debug
+
+
+def append_to_list(list_out, elem):
+	if type(elem) == str:
+		if elem not in list_out:
+			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(copy.deepcopy(element))
+
+
+
+class HeritageList:
+	def __init__(self, heritage = None):
+		self.flags = {}
+		# sources list:
+		self.src = { 'src':[],
+		             'dynamic':[],
+		             'static':[]
+		           }
+		self.path = {}
+		self.list_heritage = []
+		if heritage != None:
+			self.add_heritage(heritage)
+	
+	def add_heritage(self, heritage):
+		if    type(heritage) == type(None) \
+		   or heritage.name == "":
+			return
+		for element in self.list_heritage:
+			if element.name == heritage.name:
+				return
+		self.list_heritage.append(heritage)
+		self.regenerate_tree()
+		
+	def add_heritage_list(self, heritage_list):
+		if type(heritage_list) == type(None):
+			return
+		for herit in heritage_list.list_heritage:
+			find = False
+			for element in self.list_heritage:
+				if element.name == herit.name:
+					find = True
+			if find == False:
+				self.list_heritage.append(herit)
+		self.regenerate_tree()
+	
+	def regenerate_tree(self):
+		debug.verbose("Regenerate heritage list:")
+		self.flags = {}
+		# sources list:
+		self.src = { 'src':[],
+		             'dynamic':[],
+		             'static':[]
+		           }
+		self.path = {}
+		# reorder heritage list :
+		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:
+				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.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(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(copy.deepcopy(herit))
+				listHeritage = []
+				debug.warning("new heritage list:")
+				for element in self.list_heritage:
+					debug.warning("	" + element.name + " " + str(element.depends))
+		debug.extreme_verbose("new heritage list:")
+		for element in self.list_heritage:
+			debug.extreme_verbose("	" + element.name + " " + str(element.depends))
+		for element in reversed(self.list_heritage):
+			for flags in element.flags:
+				# get value
+				value = element.flags[flags]
+				# 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 = copy.deepcopy(element.path[ppp])
+				if ppp not in self.path:
+					self.path[ppp] = value
+				else:
+					append_to_list(self.path[ppp], value)
+			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))
+	
+	##
+	## @brief Generate a string representing the class (for str(xxx))
+	## @param[in] self (handle) Class handle
+	## @return (string) string of str() convertion
+	##
+	def __repr__(self):
+		return "{HeritageList:" + str(self.list_heritage) + "}"
+
+class heritage:
+	def __init__(self, module, target):
+		self.name = ""
+		self.depends = []
+		## Remove all variable to prevent error of multiple definition
+		# all the parameter that the upper classe need when build
+		self.flags = {}
+		# sources list:
+		self.src = { 'src':[],
+		             'dynamic':[],
+		             'static':[]
+		           }
+		self.path = {}
+		self.include = ""
+		# update is set at true when data are newly created ==> force upper element to update
+		self.has_been_updated=False
+		
+		if type(module) != type(None):
+			# all the parameter that the upper classe need when build
+			self.name = module.get_name()
+			self.depends = copy.deepcopy(module.get_depends())
+			# keep reference because the flags can change in time
+			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:
+					self.include = target.get_build_path_include(module.get_name())
+	
+	def add_depends(self, elements):
+		self.depends.append(elements)
+	
+	def add_import_path(self, list):
+		append_to_list(self.path, list)
+	
+	def add_sources(self, elements):
+		if type(elements) == type(None):
+			debug.error("try add element none in a list ...")
+		append_to_list(self.src['src'], elements)
+	
+	def add_lib_static(self, elements):
+		if type(elements) == type(None):
+			debug.error("try add element none in a list ...")
+		append_to_list(self.src['static'], elements)
+	
+	def add_lib_dynamic(self, elements):
+		if type(elements) == type(None):
+			debug.error("try add element none in a list ...")
+		append_to_list(self.src['dynamic'], elements)
+	
+	def add_lib_interpreted(self, type_interpretation, elements):
+		# TODO : Think at a better methodologie ...
+		if type(elements) == type(None):
+			debug.error("try add element none in a list ...")
+		append_to_list(self.src['src'], elements)
+	
+	def auto_add_build_header(self):
+		if self.include != "":
+			# TODO :Set it better :
+			if 'c' not in self.path:
+				self.path['c'] = []
+			self.path['c'].append(self.include)
+	
+	def need_update(self, list):
+		self.has_been_updated=True
+	
+	def add_sub(self, other):
+		if type(other) == type(None):
+			debug.verbose("input of the heriatege class is None !!!")
+			return
+		if other.has_been_updated == True:
+			self.has_been_updated = True
+		for flags in other.flags:
+			value = other.flags[flags]
+			if flags not in self.flags:
+				self.flags[flags] = copy.deepcopy(value)
+			else:
+				append_to_list(self.flags[flags], value)
+		self.add_import_path(other.path)
+		self.add_sources(other.src)
+		if "c-version" in module.flags["export"]:
+			ver = module.flags["export"]["c-version"]
+			if "c-version" in self.flags:
+				if self.flags["c-version"] > ver:
+					ver = self.flags["c-version"]
+			self.flags["c-version"] = ver
+		if "c++-version" in module.flags["export"]:
+			ver = module.flags["export"]["c++-version"]
+			if "c++-version" in self.flags:
+				if self.flags["c++-version"] > ver:
+					ver = self.flags["c++-version"]
+			self.flags["c++-version"] = ver
+	
+	##
+	## @brief Generate a string representing the class (for str(xxx))
+	## @param[in] self (handle) Class handle
+	## @return (string) string of str() convertion
+	##
+	def __repr__(self):
+		return "{Heritage:" + str(self.name) + " ... }"
+
+

lutin/host.py

@@ -1,4 +1,5 @@
 #!/usr/bin/python
+# -*- coding: utf-8 -*-
 ##
 ## @author Edouard DUPIN
 ##
@@ -6,10 +7,10 @@
 ##
 ## @license APACHE v2.0 (see license file)
 ##
-
 import platform
 import sys
-import lutinDebug as debug
+# Local import
+from . import debug
 
 # print os.name # ==> 'posix'
 if platform.system() == "Linux":

lutin/image.py

@@ -1,4 +1,5 @@
 #!/usr/bin/python
+# -*- coding: utf-8 -*-
 ##
 ## @author Edouard DUPIN
 ##
@@ -6,58 +7,75 @@
 ##
 ## @license APACHE v2.0 (see license file)
 ##
-
-import lutinDebug as debug
-import lutinTools as tools
 import platform
 import os
-import lutinMultiprocess
-import lutinDepend as dependency
-enableResizeImage = True
+# Local import
+from . import debug
+from . import tools
+from . import multiprocess
+from . import depend
+
+enable_resize_image = True
 try:
 	if platform.system() == "Darwin":
 		import CoreGraphics
 	else:
 		from PIL import Image
 except:
-	enableResizeImage = False
+	enable_resize_image = False
 	debug.warning("Missing python tools : CoreGraphics (MacOs) or PIL") 
 
+##
+## @brief Generate the upper pow 2 of the size in parameter
+## @param[in] size (int) Size that might heve the upper pow(2)
+## @return the new size in pow(2)
+##
 def get_pow_2_multiple(size):
 	base = 2
 	while size>base:
 		base = base * 2
 	return base
 
+##
+## @brief Resize an image
+## @param[in] src_file (string) Path of the source image file
+## @param[in] dest_file (string) Path out the destination image file
+## @param[in] x (int) Width of the image
+## @param[in] y (int) Height of the image
+## @param[in] cmd_file (string) Filename of where is store the cmdline to generate the 'dst'
+##
 # TODO : 3 things to do :
 #        check if force requested
 #        check if time change
 #        check if command line change
-def resize(srcFile, destFile, x, y, cmd_file=None):
-	if enableResizeImage == False:
+def resize(src_file, dest_file, x, y, cmd_file=None):
+	if os.path.exists(src_file) == False:
+		debug.error("Request a resize an image that does not existed : '" + src_file + "'")
 		return
-	if os.path.exists(srcFile) == False:
-		debug.error("Request a resize an image that does not existed : '" + srcFile + "'")
-	cmd_line = "resize Image : " + srcFile + " ==> " + destFile + " newSize=(" + str(x) + "x" + str(y) + ")"
-	if False==dependency.need_re_build(destFile, srcFile, file_cmd=cmd_file , cmdLine=cmd_line):
+	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 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)
-	extension = destFile[destFile.rfind('.'):]
+	extension = dest_file[dest_file.rfind('.'):]
 	if platform.system() == "Darwin":
-		source_image = CoreGraphics.CGImageImport(CoreGraphics.CGDataProviderCreateWithFilename(srcFile))
+		source_image = CoreGraphics.CGImageImport(CoreGraphics.CGDataProviderCreateWithFilename(src_file))
 		source_width = source_image.getWidth()
 		source_height = source_image.getHeight()
 		if source_width <= x:
 			# for small image just copy:
-			tools.copy_file(srcFile, destFile)
+			tools.copy_file(src_file, dest_file)
 		else:
 			if y <= 0:
 				# keep ratio :
 				y = int(float(x) * float(source_height) / float(source_width))
 			y = get_pow_2_multiple(y)
-			debug.print_element("resize Image (" + str(x) + "x" + str(y) + ")", srcFile, "==>", destFile)
-			debug.debug("Resize image: " + srcFile + " size=(" + str(source_width) + "x" + str(source_height) + ") -> (" + str(x) + "x" + str(y) + ")")
+			debug.print_element("resize Image (" + str(x) + "x" + str(y) + ")", src_file, "==>", dest_file)
+			debug.debug("Resize image: " + src_file + " size=(" + str(source_width) + "x" + str(source_height) + ") -> (" + str(x) + "x" + str(y) + ")")
 			source_image_rect = CoreGraphics.CGRectMake(0, 0, source_width, source_height)
 			new_image = source_image.createWithImageInRect(source_image_rect)
 			colors_space = CoreGraphics.CGColorSpaceCreateDeviceRGB()
@@ -66,27 +84,27 @@ def resize(srcFile, destFile, x, y, cmd_file=None):
 			context.setInterpolationQuality(CoreGraphics.kCGInterpolationHigh)
 			new_image_rect = CoreGraphics.CGRectMake(0, 0, x, y)
 			context.drawImage(new_image_rect, new_image)
-			tools.create_directory_of_file(destFile)
+			tools.create_directory_of_file(dest_file)
 			if extension == ".jpeg":
-				context.writeToFile(destFile, CoreGraphics.kCGImageFormatJPEG)
+				context.writeToFile(dest_file, CoreGraphics.kCGImageFormatJPEG)
 			elif extension == ".png":
-				context.writeToFile(destFile, CoreGraphics.kCGImageFormatPNG)
+				context.writeToFile(dest_file, CoreGraphics.kCGImageFormatPNG)
 			else:
-				debug.error(" can not manage extention ... : " + destFile)
+				debug.error(" can not manage extention ... : " + dest_file)
 	else:
-		# open an image file (.bmp,.jpg,.png,.gif) you have in the working folder
-		im1 = Image.open(srcFile)
+		# open an image file (.bmp,.jpg,.png,.gif) you have in the working path
+		im1 = Image.open(src_file)
 		if im1.size[0] <= x:
 			# for small image just copy:
-			tools.copy_file(srcFile, destFile)
+			tools.copy_file(src_file, dest_file)
 		else:
 			if y <= 0:
 				# keep ratio :
 				y = int(float(x) * float(im1.size[1]) / float(im1.size[0]))
 			y = get_pow_2_multiple(y)
-			debug.print_element("resize Image (" + str(x) + "x" + str(y) + ")", srcFile, "==>", destFile)
+			debug.print_element("resize Image (" + str(x) + "x" + str(y) + ")", src_file, "==>", dest_file)
 			# use one of these filter options to resize the image
 			tmpImage = im1.resize((x, y), Image.ANTIALIAS)
-			tools.create_directory_of_file(destFile)
-			tmpImage.save(destFile)
-	lutinMultiprocess.store_command(cmd_line, cmd_file)
+			tools.create_directory_of_file(dest_file)
+			tmpImage.save(dest_file)
+	tools.store_command(cmd_line, cmd_file)

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

@@ -0,0 +1,302 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+
+import sys
+import threading
+import time
+import sys
+if sys.version_info >= (3, 0):
+	import queue
+else:
+	import Queue as queue
+import os
+import subprocess
+import shlex
+# Local import
+from . import debug
+from . import tools
+from . import env
+from . import depend
+
+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
+current_id_execution = 0
+error_execution = {
+	"id":-1,
+	"cmd":"",
+	"return":0,
+	"err":"",
+	"out":"",
+}
+
+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
+##
+def run_command_direct(cmd_line):
+	# prepare command line:
+	args = shlex.split(cmd_line)
+	debug.verbose("cmd = " + str(args))
+	try:
+		# create the subprocess
+		p = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+	except subprocess.CalledProcessError as e:
+		debug.error("subprocess.CalledProcessError : " + str(args))
+	except:
+		debug.error("Exception on : " + str(args))
+	# launch the subprocess:
+	output, err = p.communicate()
+	if sys.version_info >= (3, 0):
+		output = output.decode("utf-8")
+		err = err.decode("utf-8")
+	# Check error :
+	if p.returncode == 0:
+		if output == None:
+			return err[:-1];
+		return output[:-1];
+	else:
+		return False
+
+
+def run_command(cmd_line, store_cmd_line="", build_id=-1, file="", store_output_file="", depend_data=None):
+	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))
+	try:
+		# create the subprocess
+		p = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+	except subprocess.CalledProcessError as e:
+		debug.error("subprocess.CalledProcessError : TODO ...")
+	except:
+		debug.error("Exception on : " + str(args))
+	# launch the subprocess:
+	output, err = p.communicate()
+	if sys.version_info >= (3, 0):
+		output = output.decode("utf-8")
+		err = err.decode("utf-8")
+	# store error if needed:
+	tools.store_warning(store_output_file, output, err)
+	# Check error :
+	if p.returncode == 0:
+		debug.debug(env.print_pretty(cmd_line))
+		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 ...
+		if build_id >= 0 and (output != "" or err != ""):
+			debug.warning("output in subprocess compiling: '" + file + "'")
+		if output != "":
+			debug.print_compilator(output)
+		if err != "":
+			debug.print_compilator(err)
+		queue_lock.release()
+	else:
+		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)
+			debug.print_compilator(output)
+			debug.print_compilator(err)
+			if p.returncode == 2:
+				debug.error("can not compile file ... [keyboard interrrupt]")
+			else:
+				debug.error("can not compile file ... ret : " + str(p.returncode))
+		else:
+			# in multiprocess interface
+			queue_lock.acquire()
+			# if an other write an error before, check if the current process is started before ==> then is the first error
+			if error_execution["id"] >= build_id:
+				# nothing to do ...
+				queue_lock.release()
+				return;
+			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")
+	# write cmd line only after to prevent errors ...
+	tools.store_command(cmd_line, store_cmd_line)
+
+
+
+class myThread(threading.Thread):
+	def __init__(self, thread_id, lock, queue):
+		threading.Thread.__init__(self)
+		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 exit_flag
+		global current_thread_working
+		working_set = False
+		while exit_flag == False:
+			self.lock.acquire()
+			if not self.queue.empty():
+				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]=="cmd_line":
+					comment = data[2]
+					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 working_set==True:
+					current_thread_working -= 1
+					working_set=False
+				# no element to parse, just wait ...
+				self.lock.release()
+				time.sleep(0.2)
+		# kill requested ...
+		debug.verbose("Exiting " + self.name)
+
+
+def set_error_occured():
+	global exit_flag
+	exit_flag = True
+
+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 error_occured
+	global exit_flag
+	global is_init
+	if is_init == False:
+		is_init = True
+		error_occured = False
+		global threads
+		global queue_lock
+		global work_queue
+		# Create all the new threads
+		thread_id = 0
+		while thread_id < processor_availlable:
+			thread = myThread(thread_id, queue_lock, work_queue)
+			thread.start()
+			threads.append(thread)
+			thread_id += 1
+		
+
+
+def un_init():
+	global exit_flag
+	# Notify threads it's time to exit
+	exit_flag = True
+	if processor_availlable > 1:
+		# Wait for all threads to complete
+		for tmp in threads:
+			debug.verbose("join thread ...")
+			tmp.join()
+		debug.verbose("Exiting ALL Threads")
+
+
+
+def run_in_pool(cmd_line, comment, store_cmd_line="", store_output_file="", depend_data=None):
+	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
+	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 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 work_queue.empty() \
+	      and error_occured == False:
+		time.sleep(0.2)
+		pass
+	# Wait all thread have ended their current process
+	while current_thread_working != 0 \
+	      and error_occured == False:
+		time.sleep(0.2)
+		pass
+	if error_occured == False:
+		debug.verbose("queue is empty")
+	else:
+		un_init()
+		debug.debug("Thread return with error ... ==> stop all the pool")
+		if error_execution["id"] == -1:
+			debug.error("Pool error occured ... (No return information on Pool)")
+			return
+		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(error_execution["return"]))
+	

lutin/system.py

@@ -0,0 +1,301 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+
+import sys
+import os
+import inspect
+import fnmatch
+import datetime
+# Local import
+from . import debug
+from . import module
+from . import tools
+from . import env
+##
+## @brief System class represent the pre-build Module that are already install and accessible in the system environment
+##
+class System:
+	##
+	## @brief Constructor
+	## @param[in] self (handle) Class handle
+	## @return None
+	##
+	def __init__(self):
+		self._valid=False;
+		self._help="";
+		self._export_depends=[]
+		self._export_flags={}
+		self._export_src=[]
+		self._export_path=[]
+		self._action_on_state={}
+		self._headers=[]
+		self._version=None
+	
+	##
+	## @brief Set the help of this system Module
+	## @param[in] self (handle) Class handle
+	## @param[in] help (string) Help for the user
+	## @return None
+	##
+	def set_help(self, help):
+		self._help = help;
+	
+	##
+	## @brief Get the help of this system Module
+	## @param[in] self (handle) Class handle
+	## @return (string) Help for the user
+	##
+	def get_help(self):
+		return self._help;
+	
+	##
+	## @brief Set validity state of the system Module
+	## @param[in] self (handle) Class handle
+	## @param[in] state (bool) New valididty state of the system module
+	## @return None
+	##
+	def set_valid(self, state):
+		self._valid = state
+	
+	##
+	## @brief Get validity state of the system Module
+	## @param[in] self (handle) Class handle
+	## @return (bool) New valididty state of the system module
+	##
+	def get_valid(self):
+		return self._valid
+	
+	##
+	## @brief Add source element
+	## @param[in] self (handle) Class handle
+	## @param[in] list ([string,...]) List of all Files to add. ex: *.a, *.so ...
+	## @return None
+	##
+	def add_sources(self, list):
+		tools.list_append_to(self._export_src, list)
+	
+	##
+	## @brief Add include path of the sources
+	## @param[in] self (handle) Class handle
+	## @param[in] list ([string,...]) List of all path to add in the -I include element
+	## @return None
+	##
+	# todo : add other than C ...
+	def add_path(self, list):
+		tools.list_append_to(self._export_path, list)
+	
+	##
+	## @brief Add a dependency on this module
+	## @param[in] self (handle) Class handle
+	## @param[in] list ([string,...] or string) Name(s) of the modules dependency
+	## @return None
+	##
+	def add_depend(self, list):
+		tools.list_append_to(self._export_depends, list, True)
+	
+	##
+	## @brief Add compilation flags
+	## @param[in] self (handle) Class handle
+	## @param[in] type (string) inclusion group name 'c', 'c++', 'java' ...
+	## @param[in] list ([string,...] or string) List of path to include
+	## @return None
+	##
+	def add_flag(self, type, list):
+		tools.list_append_to_2(self._export_flags, type, list)
+	
+	##
+	## @brief Set version of the module
+	## @param[in] self (handle) Class handle
+	## @param[in] version_list ([int,...]) Ids of the version. ex: [1,2,5] or [0,8,"dev"]
+	## @return None
+	##
+	def set_version(self, version_list):
+		self._version = version_list
+	
+	## @copydoc lutin.module.Target.add_action
+	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:
+			self._action_on_state[name_of_state] = [[level, name, action]]
+		else:
+			self._action_on_state[name_of_state].append([level, name, action])
+	
+	## @copydoc lutin.module.Module.add_header_file
+	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
+		  })
+	##
+	## @brief Generate a string representing the class (for str(xxx))
+	## @param[in] self (handle) Class handle
+	## @return (string) string of str() convertion
+	##
+	def __repr__(self):
+		return "{lutin.System}"
+	
+	##
+	## @brief Configure a module with internal datas
+	## @param[in] self (handle) Class handle
+	## @param[in] target (handle) @ref lutin.module.Target handle
+	## @param[in] module (handle) @ref lutin.module.Module handle
+	## @return None
+	##
+	def configure_module(self, target, module):
+		# add element flags to export
+		for elem in self._export_flags:
+			debug.verbose("add element :" + str(elem) + " elems=" + str(self._export_flags[elem]))
+			module.add_flag(elem, self._export_flags[elem], export=True)
+		# add module dependency
+		module.add_depend(self._export_depends)
+		# add exporting sources
+		module.add_src_file(self._export_src)
+		# add export path
+		module.add_path(self._export_path, export=True)
+		# Export all actions ...
+		for elem in self._action_on_state:
+			level, name, action = self._action_on_state[elem]
+			target.add_action(elem, level, name, action)
+		for elem in self._headers:
+			module.add_header_file(
+			    elem["list"],
+			    destination_path=elem["dst"],
+			    clip_path=elem["clip"],
+			    recursive=elem["recursive"])
+		if self._version != None:
+			module.set_pkg("VERSION", self._version);
+		
+
+
+##
+## @brief Create a @ref lutin.module.Module for the system list elements
+## @param[in] target (handle) @ref lutin.target.Target handle
+## @param[in] name (string) Name of the system module
+##
+def create_module_from_system(target, dict):
+	my_module = module.Module(dict["path"], dict["name"], 'PREBUILD')
+	dict["system"].configure_module(target, my_module)
+	return my_module
+
+
+
+
+# Dictionnaire of Target name
+#   inside table of ["Name of the lib", "path of the lib", boolean loaded, module loaded]
+__system_list={}
+__start_system_name="System_"
+
+##
+## @brief Import all File that start with env.get_build_system_base_name() + __start_system_name + XXX and register in the list of System
+## @param[in] path_list ([string,...]) List of file that start with env.get_build_system_base_name() in the running worktree (Parse one time ==> faster)
+##
+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"]))
+
+##
+## @brief Display all the system binary that can be used
+##
+def display():
+	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"])
+
+##
+## @brief Check if a system Module is availlable for a specific target
+## @param[in] lib_name (string) Name of the Library
+## @param[in] target_name (string) Name of the target
+## @param[in] target (handle) Handle on the @ref Target build engine
+## @return (bool) find the system lib or not
+##
+def exist(lib_name, target_name, target) :
+	global __system_list
+	debug.verbose("exist= " + lib_name + " in " + target_name)
+	if target_name not in __system_list:
+		return False
+	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"] + "'")
+				the_system = __import__(env.get_build_system_base_name() + __start_system_name + target_name + "_" + data["name"])
+				#create the system module
+				debug.verbose("SYSTEM: request: " + str(data["name"]))
+				if "System" in dir(the_system):
+					data["system"] = the_system.System(target)
+					data["exist"] = data["system"].get_valid()
+				else:
+					debug.warning("Not find: '" + data["name"] + "' ==> get exception")
+			return data["exist"]
+	return False
+
+##
+## @brief Load a system Module for a specific target
+## @param[in] target (handle) Handle on the @ref Target build engine
+## @param[in] lib_name (string) Name of the Library
+## @param[in] target_name (string) Name of the target
+## @return None
+##
+def load(target, lib_name, target_name):
+	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 __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"] = create_module_from_system(target, data)
+				data["loaded"] = True
+			target.add_module(data["module"])
+			return
+

lutin/tools.py

@@ -0,0 +1,413 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+
+import os
+import shutil
+import errno
+import fnmatch
+import stat
+# Local import
+from . import debug
+from . import depend
+from . import env
+
+"""
+	
+"""
+def get_run_path():
+	return os.getcwd()
+
+"""
+	
+"""
+def get_current_path(file):
+	return os.path.dirname(os.path.realpath(file))
+
+def create_directory_of_file(file):
+	path = os.path.dirname(file)
+	try:
+		os.stat(path)
+	except:
+		os.makedirs(path)
+
+def get_list_sub_path(path):
+	# TODO : os.listdir(path)
+	for dirname, dirnames, filenames in os.walk(path):
+		return dirnames
+	return []
+
+def remove_path_and_sub_path(path):
+	if os.path.isdir(path):
+		debug.verbose("remove path : '" + path + "'")
+		shutil.rmtree(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):
+		return 0
+	statinfo = os.stat(path)
+	return statinfo.st_size
+
+def file_read_data(path, binary=False):
+	if not os.path.isfile(path):
+		return ""
+	if binary == True:
+		file = open(path, "rb")
+	else:
+		file = open(path, "r")
+	data_file = file.read()
+	file.close()
+	return data_file
+
+def version_to_string(version):
+	version_ID = ""
+	for id in version:
+		if len(version_ID) != 0:
+			if type(id) == str:
+				version_ID += "-"
+			else:
+				version_ID += "."
+		version_ID += str(id)
+	return version_ID
+
+##
+## @brief Write data in a specific path.
+## @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 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()):
+		return list + " "
+	else:
+		result = ""
+		# mulyiple imput in the list ...
+		for elem in list:
+			result += list_to_str(elem)
+		return result
+
+def add_prefix(prefix,list):
+	if type(list) == type(None):
+		return ""
+	if type(list) == type(str()):
+		return prefix+list
+	else:
+		if len(list)==0:
+			return ''
+		else:
+			result=[]
+			for elem in list:
+				result.append(prefix+elem)
+			return result
+
+##
+## @brief Copy a specific file in a specific directory
+## @param[in] src Input file path
+## @param[in] dst Output file path
+## @param[in] cmd_file (default None) Path of file to store the command line used
+## @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:
+		debug.error("Request a copy a file that does not existed : '" + src + "'")
+	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 ...")
+		if in_list != None:
+			if dst in in_list:
+				debug.verbose("replace copy file " + os.path.relpath(src) + " ==> " + os.path.relpath(dst))
+			else:
+				debug.verbose("append copy file " + os.path.relpath(src) + " ==> " + os.path.relpath(dst))
+			# update element in dictionnary:
+			in_list[dst] = {"src":src,
+			                "cmd_file":cmd_file,
+			                "need_copy":False}
+		return False
+	if in_list == None:
+		debug.print_element("copy file ", os.path.relpath(src), "==>", os.path.relpath(dst))
+		create_directory_of_file(dst)
+		shutil.copyfile(src, dst)
+		# copy property of the permition of the file ... 
+		stat_info = os.stat(src)
+		os.chmod(dst, stat_info.st_mode)
+		store_command(cmd_line, cmd_file)
+	else:
+		debug.verbose("append copy file " + os.path.relpath(src) + " ==> " + os.path.relpath(dst))
+		# update element in dictionnary:
+		in_list[dst] = {"src":src,
+		                "cmd_file":cmd_file,
+		                "need_copy":True}
+	return True
+
+##
+## @brief Copy a compleate directory in a specific folder
+## @param[in] src Input folder path
+## @param[in] dst Output folder path
+## @param[in] recursive (default False) Copy folder with all his dependency
+## @param[in] force (default False) Force copy of the file
+## @param[in,out] in_list (default None) Not real copy: set the request copy in the input list
+##
+def copy_anything(src, dst, recursive = False, force_identical=False, in_list=None):
+	debug.verbose(" copy anything : '" + str(src) + "'")
+	debug.verbose("            to : '" + str(dst) + "'")
+	if os.path.isdir(os.path.realpath(src)):
+		tmp_path = os.path.realpath(src)
+		tmp_rule = ""
+	else:
+		tmp_path = os.path.dirname(os.path.realpath(src))
+		tmp_rule = os.path.basename(src)
+	
+	debug.verbose("    " + str(tmp_path) + ":")
+	for root, dirnames, filenames in os.walk(tmp_path):
+		deltaRoot = root[len(tmp_path):]
+		while     len(deltaRoot) > 0 \
+		      and (    deltaRoot[0] == '/' \
+		            or deltaRoot[0] == '\\' ):
+			deltaRoot = deltaRoot[1:]
+		if     recursive == False \
+		   and deltaRoot != "":
+			return
+		debug.verbose("     root='" + str(deltaRoot) + "'")
+		debug.verbose("         files=" + str(filenames))
+		tmpList = filenames
+		if len(tmp_rule) > 0:
+			tmpList = fnmatch.filter(filenames, tmp_rule)
+		# Import the module :
+		for cycleFile in tmpList:
+			#for cycleFile in filenames:
+			debug.verbose("        '" + cycleFile + "'")
+			debug.extreme_verbose("Might copy : '" + tmp_path + "  " + deltaRoot + "  " + cycleFile + "' ==> '" + dst + "'")
+			copy_file(os.path.join(tmp_path, deltaRoot, cycleFile),
+			          os.path.join(dst, deltaRoot, cycleFile),
+			          force_identical=force_identical,
+			          in_list=in_list)
+
+##
+## @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:
+			file_name = os.path.join(root, file)
+			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 = []
+	for file in list_files:
+		in_list = False
+		for ext in extentions:
+			if file[-len(ext):] == ext:
+				in_list = True
+		if     in_list == True \
+		   and invert == False:
+			out.append(file)
+		elif     in_list == False \
+		     and invert == True:
+			out.append(file)
+	return out
+
+
+def move_if_needed(src, dst):
+	if not os.path.isfile(src):
+		debug.error("request move if needed, but file does not exist: '" + str(src) + "' to '" + str(dst) + "'")
+		return
+	src_data = file_read_data(src)
+	if os.path.isfile(dst):
+		# file exist ==> must check ...
+		dst_data = file_read_data(dst)
+		if src_data == dst_data:
+			# nothing to do ...
+			return
+	file_write_data(dst, src_data)
+	remove_file(src)
+
+def store_command(cmd_line, file):
+	# write cmd line only after to prevent errors ...
+	if    file == "" \
+	   or file == None:
+		return;
+	debug.verbose("create cmd file: " + file)
+	# Create directory:
+	create_directory_of_file(file)
+	# Store the command Line:
+	file2 = open(file, "w")
+	file2.write(cmd_line)
+	file2.flush()
+	file2.close()
+
+def store_warning(file, output, err):
+	# write warning line only after to prevent errors ...
+	if    file == "" \
+	   or file == None:
+		return;
+	if env.get_warning_mode() == False:
+		debug.verbose("remove warning file: " + file)
+		# remove file if exist...
+		remove_file(file);
+		return;
+	debug.verbose("create warning file: " + file)
+	# Create directory:
+	create_directory_of_file(file)
+	# Store the command Line:
+	file2 = open(file, "w")
+	file2.write("===== output =====\n")
+	file2.write(output)
+	file2.write("\n\n")
+	file2.write("===== error =====\n")
+	file2.write(err)
+	file2.write("\n\n")
+	file2.flush()
+	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)
+
+
+##
+## @brief The vertion number can be set in an external file to permit to have a singe position to change when create a vew version
+## @param[in] path_module (string) Path of the module position
+## @param[in] filename_or_version (string or list) Path of the version or the real version lint parameter
+## @return (list) List of version number
+##
+def get_version_from_file_or_direct(path_module, filename_or_version):
+	# check case of iser set the version directly
+	if type(filename_or_version) == list:
+		return filename_or_version
+	# this use a version file
+	file_data = file_read_data(os.path.join(path_module, filename_or_version))
+	if len(file_data) == 0:
+		debug.warning("not enought data in the file version size=0 " + path_module + " / " + filename_or_version)
+		return [0,0,0]
+	lines = file_data.split("\n")
+	if len(lines) != 1:
+		debug.warning("More thatn one line in the file version ==> bas case use mode: 'XX', XX.YYY', 'XX.Y.ZZZ' or 'XX.Y-dev' : " + path_module + " / " + filename_or_version)
+		return [0,0,0]
+	line = lines[0]
+	debug.debug("Parse line: '" + line + "'")
+	#check if we have "-dev"
+	dev_mode = False
+	if line[-4:] == "-dev":
+		dev_mode = True
+		line = line[:-4]
+	out = []
+	list_elem = line.split('.')
+	for elem in list_elem:
+		out.append(int(elem))
+	if dev_mode == True:
+		out.append("dev")
+	debug.debug("    ==> " + str(out))
+	return out
+
+##
+## @brief Get the list of the authors frim an input list or a file
+## @param[in] path_module (string) Path of the module position
+## @param[in] filename_or_version (string or list) Path of the author file or the real list of authors
+## @return (list) List of authors
+##
+def get_maintainer_from_file_or_direct(path_module, filename_or_author):
+	# check case of iser set the version directly
+	if type(filename_or_author) == list:
+		return filename_or_author
+	# this use a version file
+	file_data = file_read_data(os.path.join(path_module, filename_or_author))
+	if len(file_data) == 0:
+		debug.warning("not enought data in the file author size=0 " + path_module + " / " + filename_or_author)
+		return []
+	# One user by line and # for comment line
+	out = []
+	for elem in file_data.split('\n'):
+		if len(elem) == 0:
+			continue
+		if elem[0] == "#":
+			# comment ...
+			continue
+		out.append(elem)
+	return out

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

@@ -0,0 +1,187 @@
+#!/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
+##
+from lutin import multiprocess
+from lutin import tools
+from lutin import debug
+from lutin import depend
+from lutin import env
+import os
+
+##
+## Initialize the builder, if needed ... to get dependency between builder (for example)
+##
+def init():
+	pass
+
+##
+## Get the current builder type.
+## Return the type of builder
+##
+def get_type():
+	return "linker"
+
+
+##
+## @brief Get builder input file type
+## @return List of extention supported
+##
+def get_input_type():
+	return ["o"]
+
+##
+## @brief Get builder output file type
+## @return List of extention supported
+##
+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, flags, name, basic_path, static = False):
+	file_src = file
+	file_dst = target.get_build_file_bin(binary)
+	file_depend = file_dst + target.suffix_dependence
+	file_cmd = file_dst + target.suffix_cmd_line
+	file_warning = file_dst + target.suffix_warning
+	
+	debug.extreme_verbose("list files = " + str(depancy.src))
+	list_static = []
+	list_dynamic = []
+	if static == True:
+		#get all parent static libs
+		list_static = depancy.src['static']
+		# get only parent shared that is not static
+		for elem in depancy.src['dynamic']:
+			lib_name = elem[:-len(target.suffix_lib_dynamic)] + target.suffix_lib_static
+			if lib_name not in depancy.src['static']:
+				list_dynamic.append(elem)
+	else:
+		#get all parent dynamic libs
+		list_dynamic = depancy.src['dynamic']
+		# get only parent shared that is not static
+		for elem in depancy.src['static']:
+			lib_name = elem[:-len(target.suffix_lib_static)] + target.suffix_lib_dynamic
+			if lib_name not in depancy.src['dynamic']:
+				list_static.append(elem)
+	#create comand line:
+	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:
+		pass
+	try:
+		cmd.append(target.sysroot)
+	except:
+		pass
+	try:
+		cmd.append(["-o", file_dst])
+	except:
+		pass
+	try:
+		cmd.append(file_src)
+	except:
+		pass
+	try:
+		cmd.append(depancy.src['src'])
+	except:
+		pass
+	try:
+		cmd.append(list_static)
+	except:
+		pass
+	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.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:
+		pass
+	try:
+		cmd.append(depancy.flags["link"])
+	except:
+		pass
+	try:
+		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 \
+	   and depend.need_re_package(file_dst, depancy.src, False, file_cmd=file_cmd, cmd_line=cmd_line) == False:
+		return file_dst
+	tools.create_directory_of_file(file_dst)
+	debug.print_element("Executable", name, "==>", os.path.relpath(file_dst))
+	
+	multiprocess.run_command(cmd_line, store_output_file=file_warning)
+	if    target.config["mode"] == "release"\
+	   or env.get_force_strip_mode() == True:
+		# get the file size of the non strip file
+		originSize = tools.file_size(file_dst);
+		debug.print_element("Executable(strip)", name, "", "")
+		cmd_lineStrip=tools.list_to_str([
+			target.strip,
+			file_dst])
+		multiprocess.run_command(cmd_lineStrip, store_output_file=file_warning)
+		# get the stip size of the binary
+		strip_size = tools.file_size(file_dst)
+		debug.debug("file reduce size : " + str(originSize/1024) + "ko ==> " + str(strip_size/1024) + "ko")
+	# write cmd line only after to prevent errors ...
+	tools.store_command(cmd_line, file_cmd)
+	

lutin/z_builder/lutinBuilder_c.py

@@ -0,0 +1,152 @@
+#!/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
+##
+from lutin import multiprocess
+from lutin import tools
+from lutin import debug
+from lutin import depend
+
+# C version:
+default_version = 1989
+default_version_gnu = False
+
+##
+## Initialize the builder, if needed ... to get dependency between builder (for example)
+##
+def init():
+	pass
+
+##
+## Get the current builder type.
+## Return the type of builder
+##
+def get_type():
+	return "compiler"
+
+##
+## @brief Get builder input file type
+## @return List of extention supported
+##
+def get_input_type():
+	return ["c", "C"]
+
+##
+## @brief Get builder output file type
+## @return List of extention supported
+##
+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(get_version_compilation_flags(flags, depancy.flags))
+	except:
+		pass
+	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 = ["c", name, "<==", file]
+	# process element
+	multiprocess.run_in_pool(cmdLine, comment, file_cmd, store_output_file=file_warning)
+	return {"action":"add", "file":file_dst}
+
+
+def get_version_compilation_flags(flags, dependency_flags):
+	try:
+		version_local = flags["local"]["c-version"]["version"]
+	except:
+		version_local = default_version
+	try:
+		dependency_version = dependency_flags["c-version"]
+	except:
+		dependency_version = default_version
+	try:
+		is_gnu = flags["local"]["c-version"]["gnu"]
+	except:
+		is_gnu = default_version_gnu
+	
+	version = max(version_local, dependency_version)
+	if version == 2011:
+		if is_gnu ==True:
+			out = ["-std=gnu11", "-D__C_VERSION__=2011"]
+		else:
+			out = ["-std=c11", "-D__C_VERSION__=1989"]
+	elif version == 1999:
+		if is_gnu ==True:
+			out = ["-std=gnu99", "-D__C_VERSION__=1999"]
+		else:
+			out = ["-std=c99", "-D__C_VERSION__=1989"]
+	elif version == 1990:
+		if is_gnu ==True:
+			out = ["-std=gnu90", "-D__C_VERSION__=1990"]
+		else:
+			out = ["-std=c90", "-D__C_VERSION__=1989"]
+	else:
+		if is_gnu ==True:
+			out = ["-std=gnu89", "-D__C_VERSION__=1989"]
+		else:
+			out = ["-std=c89", "-D__C_VERSION__=1989"]
+	return out

lutin/z_builder/lutinBuilder_cpp.py

@@ -0,0 +1,193 @@
+#!/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
+##
+from lutin import multiprocess
+from lutin import tools
+from lutin import debug
+from lutin import depend
+# C++ default version:
+default_version = 1999
+default_version_gnu = False
+
+##
+## Initialize the builder, if needed ... to get dependency between builder (for example)
+##
+def init():
+	pass
+
+##
+## Get the current builder type.
+## Return the type of builder
+##
+def get_type():
+	return "compiler"
+
+##
+## @brief Get builder input file type
+## @return List of extention supported
+##
+def get_input_type():
+	return ["cpp", "CPP", "cxx", "CXX", "xx", "XX", "CC", "cc"]
+
+##
+## @brief Get builder output file type
+## @return List of extention supported
+##
+def 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.
+##
+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.xx,
+		"-o", file_dst,
+		target.arch,
+		target.sysroot
+		]
+	for view in ["export", "local"]:
+		for type in ["c", "c++"]:
+			try:
+				cmd.append(tools.add_prefix("-I",path[view][type]))
+			except:
+				pass
+	for type in ["c", "c++"]:
+		try:
+			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:
+		list_flags.append(target.global_flags["c"])
+	except:
+		pass
+	try:
+		list_flags.append(target.global_flags["c++"])
+	except:
+		pass
+	for type in ["c", "c++"]:
+		try:
+			list_flags.append(depancy.flags[type])
+		except:
+			pass
+	for view in ["local", "export"]:
+		for type in ["c", "c++"]:
+			try:
+				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)
+	# 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 = ["c++", name, "<==", file]
+	#process element
+	multiprocess.run_in_pool(cmdLine, comment, file_cmd, store_output_file=file_warning)
+	return {"action":"add", "file":file_dst}
+
+def get_version_compilation_flags(flags, dependency_flags):
+	try:
+		version_local = flags["local"]["c++-version"]["version"]
+	except:
+		version_local = default_version
+	try:
+		dependency_version = dependency_flags["c++-version"]
+	except:
+		dependency_version = default_version
+	try:
+		is_gnu = flags["local"]["c++-version"]["gnu"]
+	except:
+		is_gnu = default_version_gnu
+	
+	version = max(version_local, dependency_version)
+	if version == 2017:
+		debug.error("not supported flags for X17 ...");
+		if is_gnu == True:
+			out = ["-std=gnu++17", "-D__CPP_VERSION__=2017"]
+		else:
+			out = ["-std=c++17", "-D__CPP_VERSION__=2017"]
+	if version == 2014:
+		if is_gnu == True:
+			out = ["-std=gnu++14", "-D__CPP_VERSION__=2014"]
+		else:
+			out = ["-std=c++14", "-D__CPP_VERSION__=2014"]
+	elif version == 2011:
+		if is_gnu == True:
+			out = ["-std=gnu++11", "-D__CPP_VERSION__=2011"]
+		else:
+			out = ["-std=c++11", "-D__CPP_VERSION__=2011"]
+	elif version == 2003:
+		if is_gnu == True:
+			out = ["-std=gnu++03", "-D__CPP_VERSION__=2003"]
+		else:
+			out = ["-std=c++03", "-D__CPP_VERSION__=2003"]
+	else:
+		if is_gnu == True:
+			out = ["-std=gnu++98", "-D__CPP_VERSION__=1999"]
+		else:
+			out = ["-std=c++98", "-D__CPP_VERSION__=1999"]
+	return out

lutin/z_builder/lutinBuilder_jar.py

@@ -0,0 +1,96 @@
+#!/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
+##
+from lutin import multiprocess
+from lutin import tools
+from lutin import debug
+from lutin import depend
+from lutin import env
+import os
+
+##
+## Initialize the builder, if needed ... to get dependency between builder (for example)
+##
+def init():
+	pass
+
+##
+## Get the current builder type.
+## Return the type of builder
+##
+def get_type():
+	return "linker"
+
+##
+## @brief Get builder input file type
+## @return List of extention supported
+##
+def get_input_type():
+	return ["class"]
+
+##
+## @brief Get builder output file type
+## @return List of extention supported
+##
+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, flags, name, basic_path):
+	file_src = file
+	file_dst = os.path.join(target.get_build_path(name), name + ".jar")
+	file_depend = file_dst + target.suffix_dependence
+	file_cmd = file_dst + target.suffix_cmd_line
+	file_warning = file_dst + target.suffix_warning
+	
+	#create command Line
+	cmd = [
+		target.jar,
+		"cf", file_dst,
+		]
+	for file in file_src:
+		path = ""
+		for elem in ["org/", "com/"]:
+			pos = file.find(elem);
+			if pos > 0:
+				path = file[:pos]
+				file = file[pos:]
+		cmd.append("-C")
+		cmd.append(path)
+		cmd.append(file)
+	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:
+		return tmpList[1]
+	"""
+	tools.create_directory_of_file(file_dst)
+	debug.print_element("jar", name, "==>", file_dst)
+	multiprocess.run_command(cmdLine, store_output_file=file_warning)
+	# write cmd line only after to prevent errors ...
+	tools.store_command(cmdLine, file_cmd)
+	#debug.print_element("SharedLib", self.name, "==>", tmpList[1])
+	return file_dst
+
+
+

lutin/z_builder/lutinBuilder_java.py

@@ -0,0 +1,141 @@
+#!/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
+##
+from lutin import multiprocess
+from lutin import tools
+from lutin import debug
+from lutin import depend
+
+##
+## Initialize the builder, if needed ... to get dependency between builder (for example)
+##
+def init():
+	pass
+
+##
+## Get the current builder type.
+## Return the type of builder
+##
+def get_type():
+	return "compiler"
+
+##
+## @brief Get builder input file type
+## @return List of extention supported
+##
+def get_input_type():
+	return ["java"]
+
+##
+## @brief Get builder output file type
+## @return List of extention supported
+##
+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:
+		extention = elem.split('.')[-1]
+		if    extention == 'jar' \
+		   or extention == 'java':
+			debug.extreme_verbose("add java depedence ... " + elem)
+			depend.append(target.get_full_name_source(basic_path, elem))
+	
+	for elem in heritage_src:
+		extention = elem.split('.')[-1]
+		if    extention == 'jar' \
+		   or extention == 'java':
+			debug.extreme_verbose("add java depedence ... " + elem)
+			depend.append(elem)
+	return depend
+
+##
+## @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(), remove_suffix=True)
+	file_depend = target.get_full_dependency(name, basic_path, file)
+	file_warning = target.get_full_name_warning(name, basic_path, file)
+	depend_files = create_dependency_files(target, module_src, depancy.src['src'], basic_path)
+	"""
+	debug.warning("file_src     = " + file_src)
+	debug.warning("file_cmd     = " + file_cmd)
+	debug.warning("file_dst     = " + file_dst)
+	debug.warning("file_depend  = " + file_depend)
+	debug.warning("file_warning = " + file_warning)
+	"""
+	# create the command line befor requesting start:
+	cmd = [
+		target.java,
+		"-d", target.get_build_path_object(name)
+		]
+	# add source dependency:
+	list_sources_path = []
+	for view in ["export", "local"]:
+		try:
+			list = path[view]["java"]
+			for elem in list:
+				list_sources_path.append(elem)
+		except:
+			pass
+	if len(list_sources_path) > 0:
+		cmd.append("-sourcepath")
+		out = ""
+		for elem in list_sources_path:
+			if len(out) > 0:
+				out += ":"
+			out += elem
+		cmd.append(out)
+	class_extern = []
+	upper_jar = tools.filter_extention(depancy.src['src'], ["jar"])
+	#debug.warning("ploppppp = " + str(upper_jar))
+	for elem in upper_jar:
+		class_extern.append(elem)
+	if len(class_extern) > 0:
+		cmd.append("-classpath")
+		out = ""
+		for elem in class_extern:
+			if len(out) > 0:
+				out += ":"
+			out += elem
+		cmd.append(out)
+	
+	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 = ["java", name, "<==", file]
+	#process element
+	multiprocess.run_in_pool(cmdLine,
+	                         comment,
+	                         file_cmd,
+	                         store_output_file = file_warning,
+	                         depend_data = {"file":file_depend,
+	                                        "data":depend_files})
+	return {"action":"add", "file":file_dst}
+

lutin/z_builder/lutinBuilder_javah.py

@@ -0,0 +1,113 @@
+#!/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
+##
+from lutin import multiprocess
+from lutin import tools
+from lutin import debug
+from lutin import depend
+
+##
+## Initialize the builder, if needed ... to get dependency between builder (for example)
+##
+def init():
+	pass
+
+##
+## Get the current builder type.
+## Return the type of builder
+##
+def get_type():
+	return "compiler"
+
+##
+## @brief Get builder input file type
+## @return List of extention supported
+##
+def get_input_type():
+	return ["javah"]
+
+##
+## @brief Get builder output file type
+## @return List of extention supported
+##
+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:
+		extention = elem.split('.')[-1]
+		if    extention == 'jar' \
+		   or extention == 'java':
+			debug.extreme_verbose("add java depedence ... " + elem)
+			depend.append(target.get_full_name_source(basic_path, elem))
+	
+	for elem in heritage_src:
+		extention = elem.split('.')[-1]
+		if    extention == 'jar' \
+		   or extention == 'java':
+			debug.extreme_verbose("add java depedence ... " + elem)
+			depend.append(elem)
+	return depend
+
+##
+## @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)
+	depend_files = create_dependency_files(target, module_src, depancy.src['src'], basic_path)
+	# create the command line befor requesting start:
+	cmd = [
+		target.javah,
+		"-d", target.get_build_path(name) + target.path_generate_code
+		]
+	
+	if debug.get_level() >= 5:
+		cmd.append("-verbose")
+	
+	cmd.append("-classpath")
+	cmd.append(target.get_build_path_object(name))
+	class_to_build = file[:-6]
+	cmd.append(class_to_build)
+	# Create cmd line
+	cmd_line = tools.list_to_str(cmd)
+	
+	file_dst = target.get_build_path(name) + "/generate_header/" + class_to_build.replace(".", "_") + ".h"
+	# check the dependency for this file :
+	if depend.need_re_build(file_dst, None, file_depend, file_cmd, cmd_line) == False:
+		return {"action":"path", "path":target.get_build_path(name) + target.path_generate_code}
+	#tools.create_directory_of_file(file_dst)
+	comment = ["javah", class_to_build.replace(".", "_") + ".h", "<==", class_to_build]
+	#process element
+	multiprocess.run_in_pool(cmd_line,
+	                         comment,
+	                         file_cmd,
+	                         store_output_file = file_warning,
+	                         depend_data = {"file":file_depend,
+	                                        "data":depend_files})
+	debug.verbose("file= " + file_dst)
+	#return file_dst
+	return {"action":"path", "path":target.get_build_path(name) + target.path_generate_code}
+

lutin/z_builder/lutinBuilder_libraryDynamic.py

@@ -0,0 +1,184 @@
+#!/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
+##
+from lutin import multiprocess
+from lutin import tools
+from lutin import debug
+from lutin import depend
+from lutin import env
+import os
+
+##
+## Initialize the builder, if needed ... to get dependency between builder (for example)
+##
+def init():
+	pass
+
+##
+## Get the current builder type.
+## Return the type of builder
+##
+def get_type():
+	return "linker"
+
+##
+## @brief Get builder input file type
+## @return List of extention supported
+##
+def get_input_type():
+	return ["o", "a"]
+
+##
+## @brief Get builder output file type
+## @return List of extention supported
+##
+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, flags, name, basic_path, static=False):
+	file_src = file
+	file_dst = target.get_build_file_dynamic(name)
+	file_depend = file_dst + target.suffix_dependence
+	file_cmd = file_dst + target.suffix_cmd_line
+	file_warning = file_dst + target.suffix_warning
+	
+	debug.extreme_verbose("file_dst     = " + file_dst)
+	debug.extreme_verbose("file_depend  = " + file_depend)
+	debug.extreme_verbose("file_cmd     = " + file_cmd)
+	debug.extreme_verbose("file_warning = " + file_warning)
+	
+	list_static = []
+	list_dynamic = []
+	if static == True:
+		#get all parent static libs
+		list_static = depancy.src['static']
+		# get only parent shared that is not static
+		for elem in depancy.src['dynamic']:
+			lib_name = elem[:-len(target.suffix_lib_dynamic)] + target.suffix_lib_static
+			if lib_name not in depancy.src['static']:
+				list_dynamic.append(elem)
+	else:
+		#get all parent dynamic libs
+		list_dynamic = depancy.src['dynamic']
+		# get only parent shared that is not static
+		for elem in depancy.src['static']:
+			lib_name = elem[:-len(target.suffix_lib_static)] + target.suffix_lib_dynamic
+			if lib_name not in depancy.src['dynamic']:
+				list_static.append(elem)
+	#create command Line
+	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.sysroot)
+	except:
+		pass
+	try:
+		cmd.append(target.arch)
+	except:
+		pass
+	cmd.append("-shared")
+	try:
+		cmd.append(file_src)
+	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.name != "MacOs" \
+		   and target.name != "Android":
+			if len(list_dynamic) > 0:
+				cmd.append("-Wl,-R$ORIGIN/../lib/")
+	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 \
+	   and depend.need_re_package(file_dst, depancy.src, False, file_cmd, cmdLine) == False:
+		return file_dst
+	tools.create_directory_of_file(file_dst)
+	debug.print_element("SharedLib", name, "==>", os.path.relpath(file_dst))
+	multiprocess.run_command(cmdLine, store_output_file=file_warning)
+	# strip the output file:
+	if    target.config["mode"] == "release" \
+	   or env.get_force_strip_mode() == True:
+		# get the file size of the non strip file
+		originSize = tools.file_size(file_dst);
+		debug.print_element("SharedLib(strip)", name, "", "")
+		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)
+		debug.debug("file reduce size : " + str(originSize/1024) + "ko ==> " + str(stripSize/1024) + "ko")
+	# write cmd line only after to prevent errors ...
+	tools.store_command(cmdLine, file_cmd)
+	#debug.print_element("SharedLib", self.name, "==>", tmpList[1])
+	return file_dst

lutin/z_builder/lutinBuilder_libraryStatic.py

@@ -0,0 +1,110 @@
+#!/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
+##
+from lutin import multiprocess
+from lutin import tools
+from lutin import debug
+from lutin import depend
+from lutin import env
+import os
+
+##
+## Initialize the builder, if needed ... to get dependency between builder (for example)
+##
+def init():
+	pass
+
+##
+## Get the current builder type.
+## Return the type of builder
+##
+def get_type():
+	return "linker"
+
+##
+## @brief Get builder input file type
+## @return List of extention supported
+##
+def get_input_type():
+	return ["o", "a"]
+
+##
+## @brief Get builder output file type
+## @return List of extention supported
+##
+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, flags, name, basic_path):
+	file_src = file
+	file_dst = target.get_build_file_static(name)
+	file_depend = file_dst + target.suffix_dependence
+	file_cmd = file_dst + target.suffix_cmd_line
+	file_warning = file_dst + target.suffix_warning
+	
+	debug.extreme_verbose("file_dst     = " + file_dst)
+	debug.extreme_verbose("file_depend  = " + file_depend)
+	debug.extreme_verbose("file_cmd     = " + file_cmd)
+	debug.extreme_verbose("file_warning = " + file_warning)
+	
+	cmd = [
+		target.ar
+		]
+	try:
+		cmd.append(target.global_flags["ar"])
+	except:
+		pass
+	try:
+		cmd.append(flags["local"]["link"])
+	except:
+		pass
+	try:
+		cmd.append(file_dst)
+	except:
+		pass
+	try:
+		cmd.append(file_src)
+	except:
+		pass
+	cmdLine=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 \
+	   and depend.need_re_package(file_dst, depancy.src, False, file_cmd, cmdLine) == False:
+		return file_dst
+	
+	tools.create_directory_of_file(file_dst)
+	debug.print_element("StaticLib", name, "==>", os.path.relpath(file_dst))
+	# explicitly remove the destination to prevent error ...
+	if os.path.exists(file_dst) and os.path.isfile(file_dst):
+		os.remove(file_dst)
+	multiprocess.run_command(cmdLine, store_output_file=file_warning)
+	#$(Q)$(TARGET_RANLIB) $@
+	if target.ranlib != "":
+		cmdLineRanLib=tools.list_to_str([
+			target.ranlib,
+			file_dst ])
+		multiprocess.run_command(cmdLineRanLib, store_output_file=file_warning)
+	# write cmd line only after to prevent errors ...
+	tools.store_command(cmdLine, file_cmd)
+	return file_dst

lutin/z_builder/lutinBuilder_m.py

@@ -0,0 +1,122 @@
+#!/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
+##
+from lutin import multiprocess
+from lutin import tools
+from lutin import builder
+from lutin import debug
+from lutin import depend
+
+local_ref_on_builder_c = None
+
+##
+## Initialize the builder, if needed ... to get dependency between builder (for example)
+##
+def init():
+	global local_ref_on_builder_c
+	debug.debug("m builder get dependency on the C builder")
+	local_ref_on_builder_c = builder.get_builder("c")
+
+##
+## Get the current builder type.
+## Return the type of builder
+##
+def get_type():
+	return "compiler"
+
+##
+## @brief Get builder input file type
+## @return List of extention supported
+##
+def get_input_type():
+	return ["m", "M"]
+
+##
+## @brief Get builder output file type
+## @return List of extention supported
+##
+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.
+##
+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,
+		target.global_include_cc]
+	for view in ["export", "local"]:
+		for type in ["c", "m"]:
+			try:
+				cmd.append(tools.add_prefix("-I",path[view][type]))
+			except:
+				pass
+	for type in ["c", "m"]:
+		try:
+			cmd.append(tools.add_prefix("-I",depancy.path[type]))
+		except:
+			pass
+	try:
+		cmd.append(local_ref_on_builder_c.get_version_compilation_flags(flags, depancy.flags))
+	except:
+		pass
+	try:
+		cmd.append(target.global_flags["c"])
+	except:
+		pass
+	try:
+		cmd.append(target.global_flags["m"])
+	except:
+		pass
+	for type in ["c", "m"]:
+		try:
+			cmd.append(depancy.flags[type])
+		except:
+			pass
+	for view in ["local", "export"]:
+		for type in ["c", "m"]:
+			try:
+				cmd.append(flags[view][type])
+			except:
+				pass
+	cmd.append("-c -MMD -MP")
+	cmd.append("-x objective-c")
+	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 = ["m", 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_builder/lutinBuilder_mm.py

@@ -0,0 +1,118 @@
+#!/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
+##
+from lutin import multiprocess
+from lutin import tools
+from lutin import builder
+from lutin import debug
+from lutin import depend
+
+local_ref_on_builder_cpp = None
+
+##
+## Initialize the builder, if needed ... to get dependency between builder (for example)
+##
+def init():
+	global local_ref_on_builder_cpp
+	debug.debug("mm builder get dependency on the CPP builder")
+	local_ref_on_builder_cpp = builder.get_builder("cpp")
+
+##
+## Get the current builder type.
+## Return the type of builder
+##
+def get_type():
+	return "compiler"
+
+##
+## @brief Get builder input file type
+## @return List of extention supported
+##
+def get_input_type():
+	return ["mm", "MM"]
+
+##
+## @brief Get builder output file type
+## @return List of extention supported
+##
+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.
+##
+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.xx,
+		"-o", file_dst,
+		target.arch,
+		target.sysroot,
+		target.global_include_cc]
+	for view in ["export", "local"]:
+		for type in ["c", "c++", "m", "mm"]:
+			try:
+				cmd.append(tools.add_prefix("-I",path[view][type]))
+			except:
+				pass
+	for type in ["c", "c++", "m", "mm"]:
+		try:
+			cmd.append(tools.add_prefix("-I",depancy.path[type]))
+		except:
+			pass
+	try:
+		cmd.append(local_ref_on_builder_cpp.get_version_compilation_flags(flags, depancy.flags))
+	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])
+		except:
+			pass
+	for view in ["export", "local"]:
+		for type in ["c", "c++", "m", "mm"]:
+			try:
+				cmd.append(flags[view][type])
+			except:
+				pass
+	cmd.append("-c -MMD -MP")
+	cmd.append("-x objective-c++")
+	cmd.append(file_src)
+	# 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):
+		return {"action":"add", "file":file_dst}
+	tools.create_directory_of_file(file_dst)
+	comment = ["m++", 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_builder/lutinBuilder_s.py

@@ -0,0 +1,105 @@
+#!/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
+##
+from lutin import multiprocess
+from lutin import tools
+from lutin import depend
+
+##
+## Initialize the builder, if needed ... to get dependency between builder (for example)
+##
+def init():
+	pass
+
+##
+## Get the current builder type.
+## Return the type of builder
+##
+def get_type():
+	return "compiler"
+
+##
+## @brief Get builder input file type
+## @return List of extention supported
+##
+def get_input_type():
+	return ["s", "S"]
+
+##
+## @brief Get builder output file type
+## @return List of extention supported
+##
+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

@@ -0,0 +1,117 @@
+#!/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.set_help("ADMOD: Android SDK ad-mod interface (auto-create interface for admod)\n")
+		# todo : Check if present ...
+		self.set_valid(True)
+		# todo : create a searcher of the presence of the library:
+		self.add_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)
+
+
+
+##################################################################
+##
+## Android specific section
+##
+##################################################################
+def tool_generate_main_java_class(target, module, package_name):
+	if "ADMOD_ID" not in module.package_prop:
+		debug.warning("Missing parameter ADMOD_ID wen you resuested dependency of ADMOD")
+		return
+	
+	module.package_prop["RIGHT"].append("INTERNET")
+	module.package_prop["RIGHT"].append("ACCESS_NETWORK_STATE")
+	
+	module.pkg_add("GENERATE_SECTION__IMPORT", [
+		"import com.google.android.gms.ads.AdRequest;",
+		"import com.google.android.gms.ads.AdSize;",
+		"import com.google.android.gms.ads.AdView;",
+		"import android.widget.LinearLayout;",
+		"import android.widget.Button;"
+		])
+	module.pkg_add("GENERATE_SECTION__DECLARE", [
+		"/** The view to show the ad. */",
+		"private AdView adView;",
+		"private LinearLayout mLayout = null;"
+		])
+	list_create = [
+		"mLayout = new LinearLayout(this);"
+		"mLayout.setOrientation(android.widget.LinearLayout.VERTICAL);",
+		"LinearLayout.LayoutParams paramsWindows = new LinearLayout.LayoutParams(",
+		"	LinearLayout.LayoutParams.FILL_PARENT,",
+		"	LinearLayout.LayoutParams.FILL_PARENT);",
+		"",
+		"setContentView(mLayout, paramsWindows);",
+		"",
+		"LinearLayout.LayoutParams paramsAdds = new LinearLayout.LayoutParams(",
+		"	LinearLayout.LayoutParams.FILL_PARENT,",
+		"	LinearLayout.LayoutParams.WRAP_CONTENT);",
+		"paramsAdds.weight = 0;",
+		"",
+		"LinearLayout.LayoutParams paramsGLView = new LinearLayout.LayoutParams(",
+		"	LinearLayout.LayoutParams.FILL_PARENT,",
+		"	LinearLayout.LayoutParams.FILL_PARENT);",
+		"paramsGLView.weight = 1;",
+		"paramsGLView.height = 0;",
+		"",
+		"mLayout.setGravity(android.view.Gravity.TOP);",
+		"",
+		"// Create an adds.",
+		"adView = new AdView(this);",
+		"adView.setAdSize(AdSize.SMART_BANNER);",
+		"adView.setAdUnitId(\"" + module.package_prop["ADMOD_ID"] + "\");",
+		"",
+		"// Create an ad request. Check logcat output for the hashed device ID to get test ads on a physical device.",
+		"AdRequest adRequest = new AdRequest.Builder()",
+		"	.addTestDevice(AdRequest.DEVICE_ID_EMULATOR)",
+		"	.build();",
+		"",
+		"// Add the AdView to the view hierarchy. The view will have no size until the ad is loaded."]
+		if     "ADMOD_POSITION" in module.package_prop \
+		   and module.package_prop["ADMOD_POSITION"] == "top":
+			list_create.append("mLayout.addView(adView, paramsAdds);")
+			list_create.append("mLayout.addView(mGLView, paramsGLView);")
+		else:
+			list_create.append("mLayout.addView(mGLView, paramsGLView);")
+			list_create.append("mLayout.addView(adView, paramsAdds);")
+		list_create.append("")
+		list_create.append("// Start loading the ad in the background.")
+		list_create.append("adView.loadAd(adRequest);")
+	module.pkg_add("GENERATE_SECTION__ON_CREATE", list_create)
+	module.pkg_add("GENERATE_SECTION__ON_RESUME", [
+		"if (adView != null) {",
+		"	adView.resume();",
+		"}"
+		])
+	module.pkg_add("GENERATE_SECTION__ON_PAUSE", [
+		"if (adView != null) {",
+		"	adView.pause();",
+		"}"
+		])
+	module.pkg_add("GENERATE_SECTION__ON_DESTROY", [
+		"// Destroy the AdView.",
+		"if (adView != null) {",
+		"	adView.destroy();",
+		"}"
+		])
+	
+
+

lutin/z_system/lutinSystem_Android_SDK.py

@@ -0,0 +1,32 @@
+#!/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.set_help("SDK: Android SDK basic interface java")
+		# 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.set_valid(True)
+		# todo : create a searcher of the presence of the library:
+		self.add_sources(jar_file_path)
+		self.add_flag("link-lib", "dl")
+		self.add_flag("link-lib", "log")
+		self.add_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.set_help("C: Generic C library")
+		self.set_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.set_help("CXX: Generic C++ library")
+		self.set_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_flag("c++", "-D__STDCPP_LLVM__")
+			# llvm is BSD-like licence
+			self.add_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_path(        os.path.join(stdCppBasePath, "include"))
+				self.add_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_path(        os.path.join(stdCppBasePath + "include"))
+				self.add_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_path(        os.path.join(stdCppBasePath + "include"))
+				self.add_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_path(        os.path.join(stdCppBasePath, "include"))
+				self.add_flag("link", os.path.join(stdCppBasePath, "libc++_static.a"))
+			else:
+				debug.warning("unknow architecture: '" + str(target.arch) + "'");
+		else:
+			self.add_flag("c++", "-D__STDCPP_GNU__")
+			self.add_flag("c++-remove","-nostdlib")
+			self.add_flag("need-libstdc++", True)
+			# GPL v3 (+ exception link for gcc compilator)
+			self.add_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_path(        os.path.join(stdCppBasePath, "include"))
+				self.add_flag("link", os.path.join(stdCppBasePath, "thumb", "libgnustl_static.a"))
+				self.add_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_path(        os.path.join(stdCppBasePath, "include"))
+				self.add_flag("link", os.path.join(stdCppBasePath, "thumb", "libgnustl_static.a"))
+				self.add_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_path(        os.path.join(stdCppBasePath, "include/"))
+				self.add_flag("link", os.path.join(stdCppBasePath, "libgnustl_static.a"))
+				self.add_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_path(        os.path.join(stdCppBasePath, "include"))
+				self.add_flag("link", os.path.join(stdCppBasePath, "libgnustl_static.a"))
+				self.add_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.set_help("M : m library \n base of std libs (availlagle in GNU C lib and bionic")
+		# No check ==> on the basic std libs:
+		self.set_valid(True)
+		# todo : create a searcher of the presence of the library:
+		self.add_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.set_help("OpenGL: Generic graphic library")
+		self.set_valid(True)
+		# no check needed ==> just add this:
+		self.add_depend([
+		    'c',
+		    ])
+		"""
+		self.add_header_file([
+		    "/usr/include/GL/*"
+		    ],
+		    destination_path="GL",
+		    recursive=True)
+		"""
+		self.add_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.set_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.set_valid(True)
+		# todo : create a searcher of the presence of the library:
+		#self.add_flag("link-lib", "pthread")
+		self.add_depend([
+		    'c'
+		    ])
+
+

lutin/z_system/lutinSystem_Android_z.py

@@ -7,22 +7,23 @@
 ## @license APACHE v2.0 (see license file)
 ##
 
-import lutinDebug as debug
-import lutinSystem
-import lutinTools as tools
+from lutin import debug
+from lutin import system
+from lutin import tools
+from lutin import env
 import os
 
-class System(lutinSystem.System):
-	def __init__(self):
-		lutinSystem.System.__init__(self)
+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"
+		self.set_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"):
+		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
+		self.set_valid(True)
 		# todo : create a searcher of the presence of the library:
-		self.add_export_flag_LD(["-lz"])
+		self.add_flag("link-lib", "z")
 
 

lutin/z_system/lutinSystem_IOs_CoreAudio.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.set_help("CoreAudio : Ios interface for audio (all time present, just system interface)")
+		self.set_valid(True)
+		# todo : create a searcher of the presence of the library:
+		self.add_flag("link", "-framework CoreAudio")
+		self.add_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.set_help("CXX: Generic C++ library")
+		self.set_valid(True)
+		# no check needed ==> just add this:
+		self.add_flag("c++", "-D__STDCPP_LLVM__")
+		self.add_flag("c++-remove", "-nostdlib")
+		self.add_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.set_help("M : m library \n base of std libs (availlagle in GNU C lib and bionic")
+		# No check ==> on the basic std libs:
+		self.set_valid(True)
+		# todo : create a searcher of the presence of the library:
+		self.add_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.set_help("X11: Basic interface of Linux Graphic interface")
+		self.set_valid(True)
+		# no check needed ==> just add this:
+		self.add_depend(['c'])
+		self.add_flag('link-lib', 'X11')
+		if env.get_isolate_system() == True:
+			self.add_header_file([
+			    "/usr/include/X11/*"
+			    ],
+			    destination_path="X11",
+			    recursive=True)
+
+

lutin/z_system/lutinSystem_Linux_alsa.py

@@ -0,0 +1,46 @@
+#!/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.set_help("ALSA : Advanced Linux Sound Architecture\n Can be install with the package:\n    - libasound2-dev")
+		# check if the library exist:
+		if     not os.path.isfile("/usr/include/alsa/asoundlib.h") \
+		   and not os.path.isfile("/usr/include/dssi/alsa/asoundlib.h"):
+			# we did not find the library reqiested (just return) (automaticly set at false)
+			return;
+		self.set_valid(True)
+		if env.get_isolate_system() == False:
+			self.add_flag("link-lib", "asound")
+		else:
+			self.add_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_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.set_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.set_valid(True)
+		if env.get_isolate_system() == True:
+			#self.add_flag("link-lib", "xns")
+			self.add_header_file([
+			    "/usr/include/arpa/*"
+			    ],
+			    destination_path="arpa",
+			    recursive=True)
+			self.add_depend([
+			    'c'
+			    ])
+		
+
+
+

lutin/z_system/lutinSystem_Linux_boost.py

@@ -0,0 +1,45 @@
+#!/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.set_help("BOOST : Boost interface (need when we have not all c++ feature\n Can be install with the package:\n    - libboost-all-dev")
+		# check if the library exist:
+		if not os.path.isfile("/usr/include/boost/chrono.hpp"):
+			# we did not find the library reqiested (just return) (automaticly set at false)
+			return;
+		self.set_valid(True)
+		if env.get_isolate_system() == False:
+			# todo : create a searcher of the presence of the library:
+			self.add_flag("link-lib", [
+			    "boost_system",
+			    "boost_thread",
+			    "boost_chrono"
+			    ])
+		else:
+			self.add_header_file([
+			    "/usr/include/boost/*"
+			    ],
+			    destination_path="boost",
+			    recursive=True)
+			self.add_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.set_help("C: Generic C library")
+		self.set_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_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.set_help("CXX: Generic C++ library")
+		self.set_valid(True)
+		# no check needed ==> just add this:
+		self.add_depend([
+		    'c',
+		    'm',
+		    'pthread'
+		    ])
+		self.add_flag("c++", "-D__STDCPP_GNU__")
+		if env.get_isolate_system() == False:
+			self.add_flag("c++-remove", "-nostdlib")
+			self.add_flag("need-libstdc++", True)
+		else:
+			self.add_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

@@ -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.set_help("JACK : Jack Low-Latency Audio Server\n Can be install with the package:\n    - libjack-jackd2-dev (new)\n    - libjack-dev (old)")
+		# check if the library exist:
+		if     not os.path.isfile("/usr/include/jack/jack.h"):
+			# we did not find the library reqiested (just return) (automaticly set at false)
+			return;
+		self.set_valid(True)
+		self.add_depend([
+		    'uuid',
+		    'c'
+		    ])
+		self.add_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.set_help("M : m library \n base of std libs (availlagle in GNU C lib and bionic")
+		# No check ==> on the basic std libs:
+		self.set_valid(True)
+		# todo : create a searcher of the presence of the library:
+		self.add_flag("link-lib", "m")
+		self.add_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.set_help("OpenGL: Generic graphic library")
+		self.set_valid(True)
+		# no check needed ==> just add this:
+		self.add_depend([
+		    'c',
+		    'X11'
+		    ])
+		self.add_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_flag('link-lib', "GLESv2")
+		elif target.name=="Windows":
+			my_module.add_depend([
+			    "glew"
+			    ])
+		elif target.name=="MacOs":
+			my_module.add_flag('link', [
+			    "-framework OpenGL"])
+		elif target.name=="IOs":
+			my_module.add_flag('link', [
+			    "-framework OpenGLES"
+			    ])
+		"""
+
+

lutin/z_system/lutinSystem_Linux_oss.py

@@ -1,4 +1,5 @@
 #!/usr/bin/python
+# -*- coding: utf-8 -*-
 ##
 ## @author Edouard DUPIN
 ##
@@ -7,24 +8,25 @@
 ## @license APACHE v2.0 (see license file)
 ##
 
-import lutinDebug as debug
-import lutinSystem
-import lutinTools as tools
+from lutin import debug
+from lutin import system
+from lutin import tools
+from lutin import env
 import os
 
-class System(lutinSystem.System):
-	def __init__(self):
-		lutinSystem.System.__init__(self)
+class System(system.System):
+	def __init__(self, target):
+		system.System.__init__(self)
 		# create some HELP:
-		self.help="OSS : Linux Open Sound System\n Can be install with the package:\n    - ... TODO ..."
+		self.set_help("OSS : Linux Open Sound System\n Can be install with the package:\n    - ... TODO ...")
 		# check if the library exist:
 		"""
 		if     not os.path.isfile("/usr/include/jack/jack.h"):
 			# we did not find the library reqiested (just return) (automaticly set at false)
 			return;
-		self.valid = True
+		self.set_valid(True)
 		# todo : create a searcher of the presence of the library:
-		self.add_export_flag_CC("-ljack")
+		self.add_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.set_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.set_valid(True)
+		# todo : create a searcher of the presence of the library:
+		self.add_flag("link-lib", "pthread")
+		self.add_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

@@ -0,0 +1,65 @@
+#!/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.set_help("PULSE : The Linux PulseAudio\n Can be install with the package:\n    - libpulse-dev")
+		# check if the library exist:
+		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.set_valid(True)
+		self.add_depend([
+		    'c'
+		    ])
+		if env.get_isolate_system() == False:
+			self.add_flag("link-lib", [
+			    "pulse-simple",
+			    "pulse"
+			    ])
+		else:
+			# todo : create a searcher of the presence of the library:
+			self.add_flag("link-lib", [
+			    "pulsecommon-" + version + ".0",
+			    "pulse-mainloop-glib",
+			    "pulse-simple",
+			    "pulse"
+			    ])
+			self.add_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.set_help("rpc : generic RPC library (developed by oracle)")
+		# No check ==> on the basic std libs:
+		self.set_valid(True)
+		self.add_depend([
+		    'c'
+		    ])
+		# todo : create a searcher of the presence of the library:
+		self.add_flag("link-lib", "rpcsvc")
+		if env.get_isolate_system() == True:
+			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.set_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.set_valid(True)
+		self.add_depend([
+		    'c'
+		    ])
+		# todo : create a searcher of the presence of the library:
+		self.add_flag("link-lib", "uuid")
+		if env.get_isolate_system() == True:
+			self.add_header_file([
+			    "/usr/include/uuid/*",
+			    ],
+			    destination_path="uuid",
+			    recursive=True)
+
+

lutin/z_system/lutinSystem_Linux_z.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.set_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.set_valid(True)
+		# todo : create a searcher of the presence of the library:
+		self.add_flag("link-lib", "z")
+		self.add_depend([
+		    'c'
+		    ])
+		    
+		if env.get_isolate_system() == True:
+			self.add_header_file([
+			    "/usr/include/zlib.h"
+			    ],
+			    destination_path="")
+
+

lutin/z_system/lutinSystem_MacOs_CoreAudio.py

@@ -0,0 +1,26 @@
+#!/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.set_help("CoreAudio : MacOs interface for audio (all time present, just system interface)")
+		self.set_valid(True)
+		# todo : create a searcher of the presence of the library:
+		self.add_flag("link", "-framework CoreAudio")
+		self.add_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.set_help("CXX: Generic C++ library")
+		self.set_valid(True)
+		# no check needed ==> just add this:
+		self.add_flag("c++","-D__STDCPP_LLVM__")
+		self.add_flag("c++-remove","-nostdlib")
+		self.add_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.set_help("M : m library \n base of std libs (availlagle in GNU C lib and bionic")
+		# No check ==> on the basic std libs:
+		self.set_valid(True)
+		# todo : create a searcher of the presence of the library:
+		self.add_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.set_help("CXX: Generic C++ library")
+		self.set_valid(True)
+		# no check needed ==> just add this:
+		self.add_flag("c++","-D__STDCPP_GNU__")
+		self.add_flag("c++-remove","-nostdlib")
+		# force static link to prenvent many errors ...
+		self.add_flag("link", [
+		    "-static-libgcc",
+		    "-static-libstdc++",
+		    "-static"
+		    ])
+		self.add_flag("need-libstdc++", True)
+
+

lutin/z_system/lutinSystem_Windows_ds.py

@@ -1,4 +1,5 @@
 #!/usr/bin/python
+# -*- coding: utf-8 -*-
 ##
 ## @author Edouard DUPIN
 ##
@@ -7,25 +8,27 @@
 ## @license APACHE v2.0 (see license file)
 ##
 
-import lutinDebug as debug
-import lutinSystem
-import lutinTools as tools
+from lutin import debug
+from lutin import system
+from lutin import tools
+from lutin import env
 import os
 
-class System(lutinSystem.System):
-	def __init__(self):
-		lutinSystem.System.__init__(self)
+class System(system.System):
+	def __init__(self, target):
+		system.System.__init__(self)
 		# create some HELP:
-		self.help="DirectSound : Direct sound API for windows audio interface"
+		self.set_help("DirectSound : Direct sound API for windows audio interface")
 		# check if the library exist:
 		if     not os.path.isfile("/usr/i686-w64-mingw32/include/dsound.h"):
 			# we did not find the library reqiested (just return) (automaticly set at false)
 			return;
-		self.valid = True
+		self.set_valid(True)
 		# todo : create a searcher of the presence of the library:
-		self.add_export_flag_LD(["-ldsound",
-		                         "-lwinmm",
-		                         "-lole32"
-		                         ])
+		self.add_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.set_help("M : m library \n base of std libs (availlagle in GNU C lib and bionic")
+		# No check ==> on the basic std libs:
+		self.set_valid(True)
+		# todo : create a searcher of the presence of the library:
+		self.add_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

@@ -0,0 +1,519 @@
+#!/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
+from lutin import image
+from lutin import multiprocess
+from lutin import host
+import os
+import sys
+
+class Target(target.Target):
+	def __init__(self, config):
+		#processor type selection (auto/arm/ppc/x86)
+		if config["arch"] == "auto":
+			config["arch"] = "arm"
+		#bus size selection (auto/32/64)
+		if config["bus-size"] == "auto":
+			config["bus-size"] = "32"
+		self.type_arch = ""
+		target.Target.__init__(self, "Android", config, self.type_arch)
+		
+		if config["bus-size"] == "32":
+			self.type_arch="armv7"
+		else:
+			self.type_arch="arm64"
+		
+		self.path_ndk = os.getenv('PROJECT_NDK', "AUTO")
+		self.path_sdk = os.getenv('PROJECT_SDK', "AUTO")
+		# auto search NDK
+		if self.path_ndk == "AUTO":
+			for path in os.listdir("."):
+				if os.path.isdir(path)==True:
+					if path=="android":
+						self.path_ndk = path + "/ndk"
+			if self.path_ndk == "AUTO":
+				self.path_ndk = tools.get_run_path() + "/../android/ndk"
+		# auto search SDK
+		if self.path_sdk == "AUTO":
+			for path in os.listdir("."):
+				if os.path.isdir(path)==True:
+					if path=="android":
+						self.path_sdk = path + "/sdk"
+			if self.path_sdk == "AUTO":
+				self.path_sdk = tools.get_run_path() + "/../android/sdk"
+		
+		if not os.path.isdir(self.path_ndk):
+			debug.error("NDK path not set !!! set env : PROJECT_NDK on the NDK path")
+		if not os.path.isdir(self.path_sdk):
+			debug.error("SDK path not set !!! set env : PROJECT_SDK on the SDK path")
+		
+		
+		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/"
+			basepathX86 = self.path_ndk + "/toolchains/x86-" + gccVersion + "/prebuilt/linux-x86" + tmpOsVal + "/bin/"
+			self.set_cross_base(basepathArm + "arm-linux-androideabi-")
+			if not os.path.isdir(basepathArm):
+				debug.error("Gcc Arm path does not exist !!!")
+			if not os.path.isdir(basepathMips):
+				debug.info("Gcc Mips path does not exist !!!")
+			if not os.path.isdir(basepathX86):
+				debug.info("Gcc x86 path does not exist !!!")
+		
+		# TODO : Set it back in the package only ...
+		#self.path_bin="mustNotCreateBinary"
+		#self.path_lib="data/lib/armeabi"
+		#self.path_data="data/assets"
+		#self.path_doc="doc"
+		#self.suffix_package='.pkg'
+		self.pkg_path_data = "data/assets"
+		self.pkg_path_bin = "mustNotCreateBinary"
+		self.pkg_path_lib = "data/lib/armeabi"
+		self.pkg_path_license = "license"
+		
+		# 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")
+		
+		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_include_cc.append("-I" + os.path.join(self.path_ndk, "sources", "android", "support", "include"))
+		
+		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.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.type_arch == "armv5":
+				# -----------------------
+				# -- arm V5 :
+				# -----------------------
+				self.add_flag("c", [
+				    "-march=armv5te",
+				    "-msoft-float"
+				    ])
+			else:
+				# -----------------------
+				# -- arm V7 (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.add_flag("c", "-mthumb")
+		# -----------------------
+		# -- Common flags :
+		# -----------------------
+		self.add_flag("c", "-fpic")
+		if self.config["compilator"] != "clang":
+			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 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_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("------------------------------------------------------------------------")
+		#output path
+		target_outpath = self.get_staging_path(pkg_name)
+		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
+		# in Android Package we have no binary element, only shared object ... (and java start file)
+		
+		## Create libraries (special case of Android...)
+		copy_list={}
+		target_outpath_lib = os.path.join(target_outpath, self.pkg_path_lib)
+		tools.create_directory_of_file(target_outpath_lib)
+		# copy application lib: (needed to lunch ...)
+		file_src = self.get_build_file_dynamic(pkg_name)
+		if os.path.isfile(file_src):
+			debug.debug("      need copy: " + file_src + " to " + target_outpath_lib)
+			tools.copy_file(file_src,
+			                os.path.join(target_outpath_lib, os.path.basename(file_src)),
+			                in_list=copy_list)
+		# copy other if needed:
+		if static == False:
+			#copy all shared libsh...
+			debug.verbose("libs for " + str(pkg_name) + ":")
+			for heritage in heritage_list.list_heritage:
+				debug.debug("sub elements: " + str(heritage.name))
+				file_src = self.get_build_file_dynamic(heritage.name)
+				debug.verbose("      has directory: " + file_src)
+				if os.path.isfile(file_src):
+					debug.debug("      need copy: " + file_src + " to " + target_outpath_lib)
+					#copy all data:
+					# TODO : We can have a problem when writing over library files ...
+					tools.copy_file(file_src,
+					                os.path.join(target_outpath_lib, os.path.basename(file_src)),
+					                in_list=copy_list)
+		#real copy files
+		tools.copy_list(copy_list)
+		if self.pkg_path_lib != "":
+			# remove unneded files (NOT folder ...)
+			tools.clean_directory(target_outpath_lib, copy_list)
+		
+		## Create generic files:
+		self.make_package_generic_files(target_outpath, pkg_properties, pkg_name, base_pkg_path, heritage_list, static)
+		
+		## create specific android project (local)
+		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")
+		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 = ""
+		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")
+			pkg_properties["RIGHT"].append("ACCESS_NETWORK_STATE")
+		
+		
+		debug.print_element("pkg", "absractionFile", "<==", "dynamic file")
+		# Create path :
+		tools.create_directory_of_file(self.file_final_abstraction)
+		# Create file :
+		# java ==> done by ewol wrapper ... (and compiled in the normal compilation system ==> must be find in the dependency list of jar ...
+		
+		tools.create_directory_of_file(target_outpath + "/res/drawable/icon.png");
+		if     "ICON" in pkg_properties.keys() \
+		   and pkg_properties["ICON"] != "":
+			image.resize(pkg_properties["ICON"], target_outpath + "/res/drawable/icon.png", 256, 256)
+		else:
+			# to be sure that we have all time a resource ...
+			tmpFile = open(target_outpath + "/res/drawable/plop.txt", 'w')
+			tmpFile.write('plop\n')
+			tmpFile.flush()
+			tmpFile.close()
+		
+		if pkg_properties["ANDROID_MANIFEST"]!="":
+			debug.print_element("pkg", "AndroidManifest.xml", "<==", pkg_properties["ANDROID_MANIFEST"])
+			tools.copy_file(pkg_properties["ANDROID_MANIFEST"], target_outpath + "/AndroidManifest.xml", force=True)
+		else:
+			debug.error("missing parameter 'ANDROID_MANIFEST' in the properties ... ")
+		
+		#add properties on wallpaper :
+		# myModule.pkg_add("ANDROID_WALLPAPER_PROPERTIES", ["list", key, title, summary, [["key","value display"],["key2","value display 2"]])
+		# myModule.pkg_add("ANDROID_WALLPAPER_PROPERTIES", ["list", "testpattern", "Select test pattern", "Choose which test pattern to display", [["key","value display"],["key2","value display 2"]]])
+		# myModule.pkg_add("ANDROID_WALLPAPER_PROPERTIES", ["bool", key, title, summary, ["enable string", "disable String"])
+		# myModule.pkg_add("ANDROID_WALLPAPER_PROPERTIES", ["bool", "movement", "Motion", "Apply movement to test pattern", ["Moving test pattern", "Still test pattern"]
+		#copy needed resources :
+		for res_source, res_dest in pkg_properties["ANDROID_RESOURCES"]:
+			if res_source == "":
+				continue
+			tools.copy_file(res_source , target_outpath + "/res/" + res_dest + "/" + os.path.basename(res_source), force=True)
+		
+		
+		# Doc :
+		# 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")
+		android_tool_path = self.path_sdk + "/build-tools/"
+		# find android tool version
+		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 = android_tool_path + "aapt p -f " \
+		          + "-M " + target_outpath + "/AndroidManifest.xml " \
+		          + "-F " + target_outpath + "/resources.res " \
+		          + "-I " + self.path_sdk + "/platforms/android-" + str(self.board_id) + "/android.jar "\
+		          + "-S " + target_outpath + "/res/ " \
+		          + adModResoucepath \
+		          + "-J " + target_outpath + "/src/ "
+		multiprocess.run_command(cmdLine)
+		
+		tools.create_directory_of_file(target_outpath + "/build/classes/noFile")
+		debug.print_element("pkg", "*.class", "<==", "*.java")
+		#generate android java files:
+		filesString=""
+		
+		"""
+		old : 
+		if "ADMOD_ID" in pkg_properties:
+			# TODO : check this I do not think it is really usefull ... ==> write for IDE only ...
+			filesString += self.path_sdk + "/extras/google/google_play_services/libproject/google-play-services_lib/src/android/UnusedStub.java "
+		if len(pkg_properties["ANDROID_WALLPAPER_PROPERTIES"])!=0:
+			filesString += self.path_java_project + pkg_name_application_name + "Settings.java "
+		
+		adModJarFile = ""
+		if "ADMOD_ID" in pkg_properties:
+			adModJarFile = ":" + self.path_sdk + "/extras/google/google_play_services/libproject/google-play-services_lib/libs/google-play-services.jar"
+		
+		cmdLine = "javac " \
+		          + "-d " + self.get_staging_path(pkg_name) + "/build/classes " \
+		          + "-classpath " + self.path_sdk + "/platforms/android-" + str(self.board_id) + "/android.jar" \
+		          + adModJarFile + " " \
+		          + filesString \
+		          + self.file_final_abstraction + " "  \
+		          + self.get_staging_path(pkg_name) + "/src/R.java "
+		multiprocess.run_command(cmdLine)
+		"""
+		debug.verbose("heritage .so=" + str(tools.filter_extention(heritage_list.src['dynamic'], ["so"])))
+		debug.verbose("heritage .jar=" + str(tools.filter_extention(heritage_list.src['src'], ["jar"])))
+		
+		class_extern = ""
+		upper_jar = tools.filter_extention(heritage_list.src['src'], ["jar"])
+		#debug.warning("ploppppp = " + str(upper_jar))
+		for elem in upper_jar:
+			if len(class_extern) > 0:
+				class_extern += ":"
+			class_extern += elem
+		# create enpoint element :
+		cmdLine = "javac " \
+		          + "-d " + target_outpath + "/build/classes " \
+		          + "-classpath " + class_extern + " " \
+		          + target_outpath + "/src/R.java "
+		multiprocess.run_command(cmdLine)
+		
+		debug.print_element("pkg", ".dex", "<==", "*.class")
+		cmdLine = android_tool_path + "dx " \
+		          + "--dex --no-strict " \
+		          + "--output=" + target_outpath + "/build/" + pkg_name_application_name + ".dex " \
+		          + target_outpath + "/build/classes/ "
+		
+		if "ADMOD_ID" in pkg_properties:
+			cmdLine += self.path_sdk + "/extras/google/google_play_services/libproject/google-play-services_lib/libs/google-play-services.jar "
+		# add element to dexification:
+		for elem in upper_jar:
+			# remove android sdk:
+			if elem[-len("android.jar"):] != "android.jar":
+				cmdLine += elem + " "
+		
+		multiprocess.run_command(cmdLine)
+		
+		debug.print_element("pkg", ".apk", "<==", ".dex, assets, .so, res")
+		#builderDebug="-agentlib:jdwp=transport=dt_socket,server=y,address=8050,suspend=y "
+		builderDebug=""
+		# note : set -u not signed application...
+		#+ ":" + self.path_sdk + "/extras/google/google_play_services/libproject/google-play-services_lib/libs/google-play-services.jar "
+		cmdLine =   "java -Xmx128M " \
+		          + " -classpath " + self.path_sdk + "/tools/lib/sdklib.jar " \
+		          + builderDebug \
+		          + " com.android.sdklib.build.ApkBuilderMain " \
+		          + target_outpath + "/build/" + pkg_name_application_name + "-unalligned.apk " \
+		          + " -u " \
+		          + " -z " + target_outpath + "/resources.res " \
+		          + " -f " + target_outpath + "/build/" + pkg_name_application_name + ".dex " \
+		          + " -rf " + target_outpath + "/data "
+		multiprocess.run_command(cmdLine)
+		
+		# doc :
+		# http://developer.android.com/tools/publishing/app-signing.html
+		# Create a key for signing your application:
+		# keytool -genkeypair -v -keystore AndroidKey.jks -storepass Pass__AndroidDebugKey -alias alias__AndroidDebugKey -keypass PassKey__AndroidDebugKey -keyalg RSA -validity 36500
+		if self.config["mode"] == "debug":
+			debug.print_element("pkg", ".apk(signed debug)", "<==", ".apk (not signed)")
+			# verbose mode : 
+			#debugOption = "-verbose -certs "
+			debugOption = ""
+			cmdLine = "jarsigner " \
+			    + debugOption \
+			    + "-keystore " + tools.get_current_path(__file__) + "/AndroidDebugKey.jks " \
+			    + " -sigalg SHA1withRSA -digestalg SHA1 " \
+			    + " -storepass Pass__AndroidDebugKey " \
+			    + " -keypass PassKey__AndroidDebugKey " \
+			    + target_outpath + "/build/" + pkg_name_application_name + "-unalligned.apk " \
+			    + " alias__AndroidDebugKey"
+			multiprocess.run_command(cmdLine)
+			tmpFile = open("tmpPass.boo", 'w')
+			tmpFile.write("\n")
+			tmpFile.flush()
+			tmpFile.close()
+		else:
+			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 " + pkg_properties["ANDROID_SIGN"] + " " \
+			    + " -sigalg SHA1withRSA -digestalg SHA1 " \
+			    + target_outpath + "/build/" + pkg_name_application_name + "-unalligned.apk " \
+			    + " " + pkg_name_application_name
+			multiprocess.run_command(cmdLine)
+			cmdLine = "jarsigner " \
+			    + " -verify -verbose -certs " \
+			    + " -sigalg SHA1withRSA -digestalg SHA1 " \
+			    + target_outpath + "/build/" + pkg_name_application_name + "-unalligned.apk "
+			multiprocess.run_command(cmdLine)
+		
+		debug.print_element("pkg", ".apk(aligned)", "<==", ".apk (not aligned)")
+		tools.remove_file(target_outpath + "/" + pkg_name_application_name + ".apk")
+		# verbose mode : -v
+		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)
+		
+		# copy file in the final stage :
+		tools.copy_file(target_outpath + "/" + pkg_name_application_name + ".apk",
+		                self.get_final_path() + "/" + pkg_name_application_name + ".apk",
+		                force=True)
+	
+	def install_package(self, pkg_name):
+		debug.debug("------------------------------------------------------------------------")
+		debug.info("Install package '" + pkg_name + "'")
+		debug.debug("------------------------------------------------------------------------")
+		pkg_name_application_name = pkg_name
+		if self.config["mode"] == "debug":
+			pkg_name_application_name += "debug"
+		cmdLine = self.path_sdk + "/platform-tools/adb install -r " \
+		          + self.get_staging_path(pkg_name) + "/" + pkg_name_application_name + ".apk "
+		multiprocess.run_command(cmdLine)
+	
+	def un_install_package(self, pkg_name):
+		debug.debug("------------------------------------------------------------------------")
+		debug.info("Un-Install package '" + pkg_name + "'")
+		debug.debug("------------------------------------------------------------------------")
+		pkg_name_application_name = pkg_name
+		if self.config["mode"] == "debug":
+			pkg_name_application_name += "debug"
+		cmdLine = self.path_sdk + "/platform-tools/adb uninstall " + pkg_name_application_name
+		Rmultiprocess.run_command(cmdLine)
+	
+	def show_log(self, pkg_name):
+		debug.debug("------------------------------------------------------------------------")
+		debug.info("logcat of android board")
+		debug.debug("------------------------------------------------------------------------")
+		debug.info("cmd: " + self.path_sdk + "/platform-tools/adb shell logcat ")
+		cmdLine = self.path_sdk + "/platform-tools/adb shell logcat "
+		multiprocess.run_command(cmdLine)
+
+

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

@@ -0,0 +1,439 @@
+#!/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
+from lutin import image
+import os
+import stat
+from lutin import multiprocess
+from lutin import host
+import random
+import re
+
+class Target(target.Target):
+	def __init__(self, config):
+		if config["compilator"] == "gcc":
+			debug.info("compile only with clang for IOs");
+			config["compilator"] = "clang"
+		#processor type selection (auto/arm/ppc/x86)
+		if config["arch"] == "auto":
+			config["arch"] = "arm"
+		#bus size selection (auto/32/64)
+		if config["bus-size"] == "auto":
+			config["bus-size"] = "64"
+		
+		# http://biolpc22.york.ac.uk/pub/linux-mac-cross/
+		# http://devs.openttd.org/~truebrain/compile-farm/apple-darwin9.txt
+		if config["simulation"] == True:
+			arch = "i386"
+		else:
+			arch="arm64" # for ipad air
+			#arch="armv7" # for Iphone 4
+		target.Target.__init__(self, "IOs", config, arch)
+		if self.config["simulation"] == True:
+			self.set_cross_base("/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/")
+		else:
+			self.set_cross_base("/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/")
+		
+		# remove unneeded ranlib ...
+		self.ranlib=""
+		#self.path_bin=""
+		#self.path_data="share"
+		#self.path_doc="doc"
+		
+		self.suffix_lib_static='.a'
+		self.suffix_lib_dynamic='.dylib'
+		#self.suffix_binary=''
+		#self.suffix_package=''
+		
+		if self.sumulator == True:
+			self.sysroot = "-isysroot /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator.sdk"
+			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.add_flag("link", "-miphoneos-version-min=8.0")
+			self.add_flag("c", "-miphoneos-version-min=8.0")
+		
+		self.add_flag("link", [
+		    "-Xlinker",
+		    "-objc_abi_version",
+		    "-Xlinker 2",
+		    "-Xlinker",
+		    "-no_implicit_dylibs",
+		    "-stdlib=libc++",
+		    "-fobjc-arc",
+		    "-fobjc-link-runtime"
+		    ])
+		
+		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("------------------------------------------------------------------------")
+		debug.info("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)
+		
+		## 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 icon:
+		if    "ICON" in pkg_properties.keys() \
+		   and pkg_properties["ICON"] != "":
+			# 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", 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", 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", 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", 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", 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", 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", 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", 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", 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:
+		debug.print_element("pkg", "PkgInfo", "<==", "APPL????")
+		tools.file_write_data(os.path.join(target_outpath, "PkgInfo"),
+		                      "APPL????",
+		                      only_if_new=True)
+		
+		## Create Info.plist (in XML mode)
+		debug.print_element("pkg", "Info.plist", "<==", "Package properties")
+		# http://www.sandroid.org/imcross/#Deployment
+		data_file  = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+		data_file += "<!DOCTYPE plist PUBLIC \"-//Apple Computer//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"
+		data_file += "<plist version=\"1.0\">\n"
+		data_file += "		<dict>\n"
+		data_file += "			<key>CFBundleDevelopmentRegion</key>\n"
+		data_file += "			<string>en</string>\n"
+		data_file += "			<key>CFBundleDisplayName</key>\n"
+		data_file += "			<string>" + pkg_properties["NAME"] + "</string>\n"
+		data_file += "			<key>CFBundleExecutable</key>\n"
+		data_file += "			<string>" + pkg_name + "</string>\n"
+		data_file += "			<key>CFBundleIdentifier</key>\n"
+		data_file += "			<string>com." + pkg_properties["COMPAGNY_NAME2"] + "." + pkg_name + "</string>\n"
+		
+		data_file += "			<key>CFBundleIconFiles</key>\n"
+		data_file += "			<array>\n"
+		data_file += "				<string>Icon-60@2x.png</string>\n"
+		data_file += "				<string>Icon-76.png</string>\n"
+		data_file += "				<string>Icon-76@2x.png</string>\n"
+		data_file += "				<string>Icon-Small-40.png</string>\n"
+		data_file += "				<string>Icon-Small-40@2x.png</string>\n"
+		data_file += "				<string>Icon-Small.png</string>\n"
+		data_file += "				<string>Icon-Small@2x.png</string>\n"
+		data_file += "				<string>iTunesArtwork.png</string>\n"
+		data_file += "				<string>iTunesArtwork@2x.png</string>\n"
+		data_file += "			</array>\n"
+		
+		data_file += "			<key>CFBundleInfoDictionaryVersion</key>\n"
+		data_file += "			<string>6.0</string>\n"
+		data_file += "			<key>CFBundleName</key>\n"
+		data_file += "			<string>" + pkg_name + "</string>\n"
+		data_file += "			<key>CFBundlePackageType</key>\n"
+		data_file += "			<string>APPL</string>\n"
+		data_file += "			<key>CFBundleSignature</key>\n"
+		data_file += "			<string>????</string>\n"
+		data_file += "			<key>CFBundleSupportedPlatforms</key>\n"
+		data_file += "			<array>\n"
+		data_file += "				<string>iPhoneSimulator</string>\n"
+		data_file += "			</array>\n"
+		data_file += "			\n"
+		data_file += "			<key>CFBundleShortVersionString</key>\n"
+		data_file += "			<string>"+tools.version_to_string(pkg_properties["VERSION"])+"</string>\n"
+		data_file += "			<key>CFBundleVersion</key>\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"
+		if self.sumulator == False:
+			data_file += "			<key>LSRequiresIPhoneOS</key>\n"
+			data_file += "			<true/>\n"
+		else:
+			data_file += "			<key>DTPlatformName</key>\n"
+			data_file += "			<string>iphonesimulator</string>\n"
+			data_file += "			<key>DTSDKName</key>\n"
+			data_file += "			<string>iphonesimulator7.0</string>\n"
+		data_file += "			\n"
+		data_file += "			<key>UIDeviceFamily</key>\n"
+		data_file += "			<array>\n"
+		data_file += "				<integer>1</integer>\n"
+		data_file += "				<integer>2</integer>\n"
+		data_file += "			</array>\n"
+		data_file += "			<key>UIRequiredDeviceCapabilities</key>\n"
+		data_file += "			<array>\n"
+		data_file += "				<string>armv7</string>\n"
+		data_file += "			</array>\n"
+		data_file += "			<key>UIStatusBarHidden</key>\n"
+		data_file += "			<true/>\n"
+		data_file += "			<key>UISupportedInterfaceOrientations</key>\n"
+		data_file += "			<array>\n"
+		data_file += "				<string>UIInterfaceOrientationPortrait</string>\n"
+		data_file += "				<string>UIInterfaceOrientationPortraitUpsideDown</string>\n"
+		data_file += "				<string>UIInterfaceOrientationLandscapeLeft</string>\n"
+		data_file += "				<string>UIInterfaceOrientationLandscapeRight</string>\n"
+		data_file += "			</array>\n"
+		data_file += "			<key>UISupportedInterfaceOrientations~ipad</key>\n"
+		data_file += "			<array>\n"
+		data_file += "				<string>UIInterfaceOrientationPortrait</string>\n"
+		data_file += "				<string>UIInterfaceOrientationPortraitUpsideDown</string>\n"
+		data_file += "				<string>UIInterfaceOrientationLandscapeLeft</string>\n"
+		data_file += "				<string>UIInterfaceOrientationLandscapeRight</string>\n"
+		data_file += "			</array>\n"
+		data_file += "    </dict>\n"
+		data_file += "</plist>\n"
+		data_file += "\n\n"
+		tools.file_write_data(os.path.join(target_outpath, "Info.plist"),
+		                      data_file,
+		                      only_if_new=True)
+		
+		"""
+		infoFile = self.get_staging_path(pkg_name) + "/" + pkg_name + "-Info.plist"
+		# Create the info file
+		tmpFile = open(infoFile, 'w')
+		tmpFile.write(data_file)
+		tmpFile.flush()
+		tmpFile.close()
+		cmdLine  = "builtin-infoPlistUtility "
+		cmdLine += " " + self.get_staging_path(pkg_name) + "/" + pkg_name + "-Info.plist "
+		cmdLine += " -genpkginfo " + self.get_staging_path(pkg_name) + "/PkgInfo"
+		cmdLine += " -expandbuildsettings "
+		cmdLine += " -format binary "
+		if self.sumulator == False:
+			cmdLine += " -platform iphonesimulator "
+		else:
+			cmdLine += " -platform iphoneos "
+		cmdLine += " -o " + self.get_staging_path(pkg_name) + "/" + "Info.plist"
+		multiprocess.run_command(cmdLine)
+		"""
+		"""
+		
+			/Users/edouarddupin/dev/exampleProjectXcode/projectName/projectName/projectName-Info.plist
+			-genpkginfo
+			/Users/edouarddupin/Library/Developer/Xcode/DerivedData/projectName-gwycnyyzohokcmalgodeucqppxro/Build/Products/Debug-iphonesimulator/projectName.app/PkgInfo
+			-expandbuildsettings
+			-format binary
+			-platform iphonesimulator
+		    -additionalcontentfile /Users/edouarddupin/Library/Developer/Xcode/DerivedData/projectName-gwycnyyzohokcmalgodeucqppxro/Build/Intermediates/projectName.build/Debug-iphonesimulator/projectName.build/assetcatalog_generated_info.plist
+			-o /Users/edouarddupin/Library/Developer/Xcode/DerivedData/projectName-gwycnyyzohokcmalgodeucqppxro/Build/Products/Debug-iphonesimulator/projectName.app/Info.plist
+		 -additionalcontentfile /Users/edouarddupin/Library/Developer/Xcode/DerivedData/zdzdzd-bjuyukzpzhnyerdmxohjyuxfdllv/Build/Intermediates/zdzdzd.build/Debug-iphoneos/zdzdzd.build/assetcatalog_generated_info.plist -o /Users/edouarddupin/Library/Developer/Xcode/DerivedData/zdzdzd-bjuyukzpzhnyerdmxohjyuxfdllv/Build/Products/Debug-iphoneos/zdzdzd.app/Info.plist
+			
+			"""
+		#/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/dsymutil /Users/edouarddupin/Library/Developer/Xcode/DerivedData/projectName-gwycnyyzohokcmalgodeucqppxro/Build/Products/Debug-iphonesimulator/projectName.app/projectName -o /Users/edouarddupin/Library/Developer/Xcode/DerivedData/projectName-gwycnyyzohokcmalgodeucqppxro/Build/Products/Debug-iphonesimulator/projectName.app.dSYM
+			
+		debug.print_element("pkg", "ResourceRules.plist", "<==", "Resources autorisation")
+		data_file  = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+		data_file += "<!DOCTYPE plist PUBLIC \"-//Apple Computer//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"
+		data_file += "<plist version=\"1.0\">\n"
+		data_file += "	<dict>\n"
+		data_file += "		<key>rules</key>\n"
+		data_file += "		<dict>\n"
+		data_file += "			<key>.*</key>\n"
+		data_file += "			<true/>\n"
+		data_file += "			<key>Info.plist</key>\n"
+		data_file += "			<dict>\n"
+		data_file += "				<key>omit</key>\n"
+		data_file += "				<true/>\n"
+		data_file += "				<key>weight</key>\n"
+		data_file += "				<real>10</real>\n"
+		data_file += "			</dict>\n"
+		data_file += "			<key>ResourceRules.plist</key>\n"
+		data_file += "			<dict>\n"
+		data_file += "				<key>omit</key>\n"
+		data_file += "				<true/>\n"
+		data_file += "				<key>weight</key>\n"
+		data_file += "				<real>100</real>\n"
+		data_file += "			</dict>\n"
+		data_file += "		</dict>\n"
+		data_file += "	</dict>\n"
+		data_file += "</plist>\n"
+		data_file += "\n\n"
+		tools.file_write_data(os.path.join(target_outpath, "ResourceRules.plist"),
+		                      data_file,
+		                      only_if_new=True)
+
+		debug.print_element("pkg", "Entitlements.plist", "<==", "application mode")
+		data_file  = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+		data_file += "<!DOCTYPE plist PUBLIC \"-//Apple Computer//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"
+		data_file += "<plist version=\"1.0\">\n"
+		data_file += "	<dict>\n"
+		data_file += "		<key>get-task-allow</key>\n"
+		data_file += "		<true/>\n"
+		data_file += "    </dict>\n"
+		data_file += "</plist>\n"
+		data_file += "\n\n"
+		tools.file_write_data(os.path.join(target_outpath, "Entitlements.plist"),
+		                      data_file,
+		                      only_if_new=True)
+
+		# Simulateur path :
+		#~/Library/Application\ Support/iPhone\ Simulator/7.0.3/Applications/
+		# must have a 'uuidgen' UID generate value with this elemennt ...
+		# get the bundle path : ==> maybe usefull in MocOS ...
+		# NSLog(@"%@",[[NSBundle mainBundle] bundlePath]);
+		
+		# 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")
+			tmpFile.write("<!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n")
+			tmpFile.write("<plist version=\"1.0\">\n")
+			tmpFile.write("    <dict>\n")
+			tmpFile.write("        <key>application-identifier</key>\n")
+			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"] + "." + pkg_properties["COMPAGNY_TYPE"] + "." + pkg_properties["COMPAGNY_NAME2"] + "." + pkg_name + "</string>\n")
+			tmpFile.write("        </array>\n")
+			tmpFile.write("    </dict>\n")
+			tmpFile.write("</plist>\n")
+			tmpFile.flush()
+			tmpFile.close()
+			# application signing :
+			debug.print_element("pkg(signed)", "pkg", "<==", "Signing application")
+			iosDevelopperKeyFile = ".iosKey.txt"
+			if tools.file_size(iosDevelopperKeyFile) < 10:
+				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 create_random_number(self, len):
+		out = ""
+		for iii in range(0,len):
+			out += random.choice(["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F"])
+		return out
+	
+	def install_package(self, pkg_name):
+		debug.debug("------------------------------------------------------------------------")
+		debug.info("Install package '" + pkg_name + "'")
+		debug.debug("------------------------------------------------------------------------")
+		if self.sumulator == False:
+			if tools.file_size("ewol/ios-deploy/ios-deploy") == 0:
+				debug.print_element("tool", "ios-deploy", "<==", "external sources")
+				cmdLine = 'cd ewol/ios-deploy ; make ; cd ../.. '
+				multiprocess.run_command(cmdLine)
+			if tools.file_size("ewol/ios-deploy/ios-deploy") == 0:
+				debug.error("Can not create ios-deploy external software ...")
+			debug.print_element("deploy", "iphone/ipad", "<==", "aplication")
+			cmdLine = './ewol/ios-deploy/ios-deploy --bundle ' + self.get_staging_path(pkg_name)
+			multiprocess.run_command(cmdLine)
+		else:
+			simulatorIdFile = ".iosSimutatorId_" + pkg_name + ".txt"
+			if tools.file_size(simulatorIdFile) < 10:
+				#create the file:
+				tmpFile = open(simulatorIdFile, 'w')
+				tmpFile.write(self.create_random_number(8))
+				tmpFile.write("-")
+				tmpFile.write(self.create_random_number(4))
+				tmpFile.write("-")
+				tmpFile.write(self.create_random_number(4))
+				tmpFile.write("-")
+				tmpFile.write(self.create_random_number(4))
+				tmpFile.write("-")
+				tmpFile.write(self.create_random_number(12))
+				tmpFile.flush()
+				tmpFile.close()
+			simulatorId = tools.file_read_data(simulatorIdFile)
+			home = os.path.expanduser("~")
+			destinationpathBase = home + "/Library/Application\\ Support/iPhone\\ Simulator/7.1/Applications/" + simulatorId
+			destinationpath = home + "/Library/Application Support/iPhone Simulator/7.1/Applications/" + simulatorId + "/" + pkg_name + ".app"
+			destinationpath2 = home + "/Library/Application\\ Support/iPhone\\ Simulator/7.1/Applications/" + simulatorId + "/" + pkg_name + ".app"
+			debug.info("install in simulator : " + destinationpath)
+			tools.create_directory_of_file(destinationpath + "/plop.txt")
+			cmdLine = "cp -rf " + self.get_staging_path(pkg_name) + " " + destinationpath2
+			multiprocess.run_command(cmdLine)
+			cmdLine = "touch " + destinationpathBase
+			multiprocess.run_command(cmdLine)
+			
+		#sudo dpkg -i $(TARGET_OUT_FINAL)/$(PROJECT_NAME) + self.suffix_package
+	
+	def un_install_package(self, pkg_name):
+		debug.debug("------------------------------------------------------------------------")
+		debug.info("Un-Install package '" + pkg_name + "'")
+		debug.debug("------------------------------------------------------------------------")
+		if self.sumulator == False:
+			debug.warning("not implemented")
+		else:
+			simulatorIdFile = ".iosSimutatorId_" + pkg_name + ".txt"
+			if tools.file_size(simulatorIdFile) < 10:
+				debug.warning("Can not get simulation O_ID : " + simulatorIdFile)
+		
+		#sudo dpkg -r $(TARGET_OUT_FINAL)/$(PROJECT_NAME) + self.suffix_package
+		
+	def Log(self, pkg_name):
+		debug.debug("------------------------------------------------------------------------")
+		debug.info("log of iOs board")
+		debug.debug("------------------------------------------------------------------------")
+		if self.sumulator == False:
+			if tools.file_size("ewol/ios-deploy/ios-deploy") == 0:
+				debug.print_element("tool", "ios-deploy", "<==", "external sources")
+				cmdLine = 'cd ewol/ios-deploy ; make ; cd ../.. '
+				multiprocess.run_command(cmdLine)
+			if tools.file_size("ewol/ios-deploy/ios-deploy") == 0:
+				debug.error("Can not create ios-deploy external software ...")
+			debug.print_element("deploy", "iphone/ipad", "<==", "aplication")
+			cmdLine = './ewol/ios-deploy/ios-deploy --debug --bundle ' + self.get_staging_path(pkg_name)
+			multiprocess.run_command(cmdLine)
+		else:
+			cmdLine = "tail -f ~/Library/Logs/iOS\ Simulator/7.1/system.log"
+			multiprocess.run_command(cmdLine)
+
+
+
+

lutin/z_target/lutinTarget_Linux.py

@@ -0,0 +1,163 @@
+#!/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
+from lutin import env
+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"
+		# disable sysroot when generate build in isolated mode
+		if env.get_isolate_system() == True:
+			self.sysroot = "--sysroot=/aDirectoryThatDoesNotExist/"
+		
+	
+	"""
+	.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.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:
+		ret_share = self.make_package_binary_data(target_outpath, pkg_name, base_pkg_path, heritage_list, static)
+		
+		## copy binary files:
+		ret_bin = self.make_package_binary_bin(target_outpath, pkg_name, base_pkg_path, heritage_list, static)
+		
+		## Create libraries:
+		ret_lib = self.make_package_binary_lib(target_outpath, pkg_name, base_pkg_path, heritage_list, static)
+		
+		## Create generic files:
+		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.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.debug("------------------------------------------------------------------------")
+		# 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.debug("------------------------------------------------------------------------")
+		# 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)
+	
+	def run(self, pkg_name, option_list):
+		debug.debug("------------------------------------------------------------------------")
+		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("------------------------------------------------------------------------")
+
+

lutin/z_target/lutinTarget_MacOs.py

@@ -0,0 +1,168 @@
+#!/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
+from lutin import host
+from lutin import multiprocess
+import os
+import stat
+import shutil
+
+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)
+		# http://biolpc22.york.ac.uk/pub/linux-mac-cross/
+		# http://devs.openttd.org/~truebrain/compile-farm/apple-darwin9.txt
+		target.Target.__init__(self, "MacOs", config, "")
+		
+		#self.path_bin="MacOS"
+		#self.path_lib="lib"
+		#self.path_data="Resources"
+		#self.path_doc="doc"
+		
+		self.suffix_lib_static='.a'
+		self.suffix_lib_dynamic='.dylib'
+		#self.suffix_binary=''
+		#self.suffix_package=''
+		
+		self.pkg_path_data = "Resources"
+		self.pkg_path_bin = "MacOS"
+		self.pkg_path_lib = "lib"
+		self.pkg_path_license = "license"
+		
+	"""
+	def get_staging_path(self, binary_name):
+		return tools.get_run_path() + self.path_out + self.path_staging + "/" + binary_name + ".app/Contents/"
+	
+	def get_staging_path_data(self, binary_name):
+		return self.get_staging_path(binary_name) + self.path_data + "/"
+	"""
+	
+	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("------------------------------------------------------------------------")
+		#output path
+		target_outpath = os.path.join(self.get_staging_path(pkg_name), pkg_name + ".app/Contents")
+		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 icon (no convertion ==> TODO: must test if png is now supported):
+		if     "ICON" in pkg_properties.keys() \
+		   and pkg_properties["ICON"] != "":
+			tools.copy_file(pkg_properties["ICON"], os.path.join(target_outpath, "icon.icns"), force=True)
+		
+		## Create info.plist file:
+		# http://www.sandroid.org/imcross/#Deployment
+		data_file  = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+		data_file += "<!DOCTYPE plist PUBLIC \"-//Apple Computer//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"
+		data_file += "<plist version=\"1.0\">\n"
+		data_file += "    <dict>\n"
+		data_file += "        <key>CFBundleExecutableFile</key>\n"
+		data_file += "        <string>"+pkg_name+"</string>\n"
+		data_file += "        <key>CFBundleName</key>\n"
+		data_file += "        <string>"+pkg_name+"</string>\n"
+		data_file += "        <key>CFBundleIdentifier</key>\n"
+		data_file += "        <string>" + pkg_properties["COMPAGNY_TYPE"] + "." + pkg_properties["COMPAGNY_NAME2"] + "." + pkg_name + "</string>\n"
+		data_file += "        <key>CFBundleSignature</key>\n"
+		data_file += "        <string>????</string>\n"
+		data_file += "        <key>CFBundleIconFile</key>\n"
+		data_file += "        <string>icon.icns</string>\n"
+		data_file += "    </dict>\n"
+		data_file += "</plist>\n"
+		data_file += "\n\n"
+		tools.file_write_data(os.path.join(target_outpath, "Info.plist"),
+		                      data_file,
+		                      only_if_new=True)
+		
+		## Create PkgInfo file:
+		tools.file_write_data(os.path.join(target_outpath, "PkgInfo"),
+		                      "APPL????",
+		                      only_if_new=True)
+		
+		## Create a simple interface to localy install the aplication for the shell (a shell command line interface):
+		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"
+		tools.file_write_data(os.path.join(target_outpath, "shell", pkg_name),
+		                      data_file,
+		                      only_if_new=True)
+		
+		## Create the disk image of the application:
+		debug.info("Generate disk image for '" + pkg_name + "'")
+		output_file_name = os.path.join(self.get_final_path(), pkg_name + ".dmg")
+		cmd = "hdiutil create -volname "
+		cmd += pkg_name + " -srcpath "
+		cmd += os.path.join(tools.get_run_path(), self.path_out,  self.path_staging, pkg_name + ".app")
+		cmd += " -ov -format UDZO "
+		cmd += output_file_name
+		tools.create_directory_of_file(output_file_name)
+		multiprocess.run_command_direct(cmd)
+		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")
+	
+	def install_package(self, pkg_name):
+		debug.debug("------------------------------------------------------------------------")
+		debug.info("Install package '" + pkg_name + "'")
+		debug.debug("------------------------------------------------------------------------")
+		debug.info("copy " + tools.get_run_path() + self.path_out + self.path_staging + "/" + pkg_name + ".app in /Applications/")
+		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(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("------------------------------------------------------------------------")
+		debug.info("Un-Install package '" + pkg_name + "'")
+		debug.debug("------------------------------------------------------------------------")
+		debug.info("remove OLD application /Applications/" + pkg_name + ".app")
+		# 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

@@ -0,0 +1,157 @@
+#!/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
+from lutin import host
+import os
+import stat
+import sys
+from lutin import zip
+
+class Target(target.Target):
+	def __init__(self, config):
+		if config["compilator"] != "gcc":
+			debug.error("Windows does not support '" + config["compilator"] + "' compilator ... availlable : [gcc]")
+			config["compilator"] = "gcc"
+		
+		#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, "Windows", config, "")
+		
+		# on windows board the basic path is not correct 
+		# TODO : get external PATH for the minGW path
+		# TODO : Set the cyngwin path ...
+		if host.OS == "Windows":
+			self.set_cross_base("c:\\MinGW\\bin\\")
+			sys.path.append("c:\\MinGW\\bin" )
+			os.environ['PATH'] += ";c:\\MinGW\\bin\\"
+		else:
+			if self.config["bus-size"] == "64":
+				# 64 bits
+				self.set_cross_base("x86_64-w64-mingw32-")
+			else:
+				# 32 bits
+				self.set_cross_base("i686-w64-mingw32-")
+		
+		self.pkg_path_data = "data"
+		self.pkg_path_bin = ""
+		self.pkg_path_lib = "lib"
+		self.pkg_path_license = "license"
+		
+		self.suffix_lib_static='.a'
+		self.suffix_lib_dynamic='.dll'
+		self.suffix_binary='.exe'
+		#self.suffix_package=''
+	
+	
+	def get_staging_path_data(self, binary_name, heritage_list):
+		return self.get_staging_path(binary_name) + self.path_data
+	
+	def make_package_binary(self, pkg_name, pkg_properties, base_pkg_path, heritage_list, static):
+		debug.debug("------------------------------------------------------------------------")
+		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:
+		ret_share = self.make_package_binary_data(target_outpath, pkg_name, base_pkg_path, heritage_list, static)
+		
+		## copy binary files:
+		ret_bin = self.make_package_binary_bin(target_outpath, pkg_name, base_pkg_path, heritage_list, static)
+		
+		## Create libraries:
+		ret_lib = self.make_package_binary_lib(target_outpath, pkg_name, base_pkg_path, heritage_list, static)
+		
+		## Create generic files:
+		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("------------------------------------------------------------------------")
+		debug.info("Generate package '" + pkg_name + "'")
+		debug.debug("------------------------------------------------------------------------")
+		debug.print_element("zip", "data.zip", "<==", "data/*")
+		zipPath = self.get_staging_path(pkg_name) + "/data.zip"
+		zip.create_zip(self.get_staging_path_data(pkg_name), zipPath)
+		
+		binPath = self.get_staging_path(pkg_name) + "/" + self.path_bin + "/" + pkg_name + self.suffix_binary
+		binSize = tools.file_size(binPath)
+		debug.info("binarysize : " + str(binSize/1024) + " ko ==> " + str(binSize) + " octets")
+		
+		#now we create a simple bundle binary ==> all file is stored in one file ...
+		self.get_staging_path(pkg_name)
+		finalBin = self.get_final_path() + "/" + pkg_name + self.suffix_binary
+		tools.create_directory_of_file(finalBin);
+		debug.print_element("pkg", finalBin, "<==", pkg_name + self.suffix_binary)
+		#open output file
+		tmpFile = open(finalBin, 'wb')
+		# read all executable binary
+		dataExecutable = tools.file_read_data(binPath, binary=True)
+		# wrte binary to the output
+		tmpFile.write(dataExecutable)
+		#align data in the 32 Bytes position (prevent zip align error)
+		residualToAllign = 32 + 32 - (len(dataExecutable) - int(len(dataExecutable)/32)*32)
+		for iii in range(0,residualToAllign):
+			tmpFile.write(b'\0');
+		positionOfZip = len(dataExecutable) + residualToAllign;
+		# write a control TAG
+		tmpFile.write(b'***START DATA***');
+		# write all the zip file
+		debug.print_element("pkg", finalBin, "<==", "data.zip")
+		dataData = tools.file_read_data(zipPath, binary=True)
+		tmpFile.write(dataData)
+		#align data in the 32 Bytes position (to be fun"
+		tmpLen = len(dataData) + positionOfZip
+		residualToAllign = 32 + 32 - (tmpLen - int(tmpLen/32)*32)
+		for iii in range(0,residualToAllign):
+			tmpFile.write(b'\0');
+		# write a control TAG
+		tmpFile.write(b'*** END DATA ***');
+		# reserved AREA (can be use later for extra value ...)
+		for iii in range(0,8):
+			tmpFile.write(b'\0');
+		# write the position of the zip file (TAG position)
+		h = '{0:016x}'.format(positionOfZip)
+		s = ('0'*(len(h) % 2) + h).decode('hex')
+		tmpFile.write(s)
+		# package is done
+		tmpFile.flush()
+		tmpFile.close()
+		debug.verbose("zip position=" + str(positionOfZip) + " = 0x" + h)
+	
+	def install_package(self, pkg_name):
+		debug.debug("------------------------------------------------------------------------")
+		debug.info("Install package '" + pkg_name + "'")
+		debug.debug("------------------------------------------------------------------------")
+		debug.warning("    ==> TODO")
+		#sudo dpkg -i $(TARGET_OUT_FINAL)/$(PROJECT_NAME) + self.suffix_package
+	
+	def un_install_package(self, pkg_name):
+		debug.debug("------------------------------------------------------------------------")
+		debug.info("Un-Install package '" + pkg_name + "'")
+		debug.debug("------------------------------------------------------------------------")
+		debug.warning("    ==> TODO")
+		#sudo dpkg -r $(TARGET_OUT_FINAL)/$(PROJECT_NAME) + self.suffix_package
+

lutin/zip.py

@@ -0,0 +1,32 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+##
+## @author Edouard DUPIN
+##
+## @copyright 2012, Edouard DUPIN, all right reserved
+##
+## @license APACHE v2.0 (see license file)
+##
+
+import platform
+import os
+import zipfile
+# Local import
+from . import debug
+from . import tools
+
+
+def create_zip(path, outputFile):
+	debug.debug("Create Zip : '" + outputFile + "'")
+	debug.debug("    from '" + path + "'")
+	basePathlen = len(path)
+	zf = zipfile.ZipFile(outputFile, mode='w')
+	for root, dirnames, filenames in os.walk(path):
+		# List all files :
+		for filename in filenames:
+			file = os.path.join(root, filename)
+			debug.verbose("    ADD zip = " + str(file))
+			zf.write(file, file[basePathlen:])
+	zf.close()
+	
+

lutinArg.py

@@ -1,258 +0,0 @@
-#!/usr/bin/python
-##
-## @author Edouard DUPIN
-##
-## @copyright 2012, Edouard DUPIN, all right reserved
-##
-## @license APACHE v2.0 (see license file)
-##
-
-import sys
-import lutinDebug as debug
-
-class ArgElement:
-	def __init__(self, option, value=""):
-		self.m_option = option;
-		self.m_arg = value;
-	
-	def get_option_nName(self):
-		return self.m_option
-	
-	def get_arg(self):
-		return self.m_arg
-	
-	def display(self):
-		if len(self.m_arg)==0:
-			debug.info("option : " + self.m_option)
-		elif len(self.m_option)==0:
-			debug.info("element :       " + self.m_arg)
-		else:
-			debug.info("option : " + self.m_option + ":" + self.m_arg)
-
-
-class ArgDefine:
-	def __init__(self,
-	             smallOption="", # like v for -v
-	             bigOption="", # like verbose for --verbose
-	             list=[], # ["val", "description"]
-	             desc="",
-	             haveParam=False):
-		self.m_optionSmall = smallOption;
-		self.m_optionBig = bigOption;
-		self.m_list = list;
-		if len(self.m_list)!=0:
-			self.m_haveParam = True
-		else:
-			if True==haveParam:
-				self.m_haveParam = True
-			else:
-				self.m_haveParam = False
-		self.m_description = desc;
-	
-	def get_option_small(self):
-		return self.m_optionSmall
-		
-	def get_option_big(self):
-		return self.m_optionBig
-	
-	def need_parameters(self):
-		return self.m_haveParam
-	
-	def get_porperties(self):
-		return ""
-	
-	def check_availlable(self, argument):
-		if len(self.m_list)==0:
-			return True
-		for element,desc in self.m_list:
-			if element == argument:
-				return True
-		return False
-	
-	def display(self):
-		if self.m_optionSmall != "" and self.m_optionBig != "":
-			print("		-" + self.m_optionSmall + " / --" + self.m_optionBig)
-		elif self.m_optionSmall != "":
-			print("		-" + self.m_optionSmall)
-		elif self.m_optionBig != "":
-			print("		--" + self.m_optionBig)
-		else:
-			print("		???? ==> internal error ...")
-		if self.m_description != "":
-			print("			" + self.m_description)
-		if len(self.m_list)!=0:
-			hasDescriptiveElement=False
-			for val,desc in self.m_list:
-				if desc!="":
-					hasDescriptiveElement=True
-					break;
-			if hasDescriptiveElement==True:
-				for val,desc in self.m_list:
-					print("				" + val + " : " + desc)
-			else:
-				tmpElementPrint = ""
-				for val,desc in self.m_list:
-					if len(tmpElementPrint)!=0:
-						tmpElementPrint += " / "
-					tmpElementPrint += val
-				print("				{ " + tmpElementPrint + " }")
-	
-	def parse(self, argList, currentID):
-		return currentID;
-
-
-class ArgSection:
-	def __init__(self,
-	             sectionName="",
-	             desc=""):
-		self.m_section = sectionName;
-		self.m_description = desc;
-	
-	def get_option_small(self):
-		return ""
-		
-	def get_option_big(self):
-		return ""
-		
-	def get_porperties(self):
-		return " [" + self.m_section + "]"
-	
-	def display(self):
-		print("	[" + self.m_section + "] : " + self.m_description)
-	
-	def parse(self, argList, currentID):
-		return currentID;
-
-
-class LutinArg:
-	def __init__(self):
-		self.m_listProperties = []
-	
-	def add(self, argument):
-		self.m_listProperties.append(argument) #ArgDefine(smallOption, bigOption, haveParameter, parameterList, description));
-	
-	def add_section(self, sectionName, sectionDesc):
-		self.m_listProperties.append(ArgSection(sectionName, sectionDesc))
-	
-	def parse(self):
-		listArgument = [] # composed of list element
-		NotparseNextElement=False
-		for iii in range(1, len(sys.argv)):
-			# special case of parameter in some elements
-			if NotparseNextElement==True:
-				NotparseNextElement = False
-				continue
-			debug.verbose("parse [" + str(iii) + "]=" + sys.argv[iii])
-			argument = sys.argv[iii]
-			optionList = argument.split("=")
-			debug.verbose(str(optionList))
-			if type(optionList) == type(str()):
-				option = optionList
-			else:
-				option = optionList[0]
-			optionParam = argument[len(option)+1:]
-			debug.verbose(option)
-			argumentFound=False;
-			if option[:2]=="--":
-				# big argument
-				for prop in self.m_listProperties:
-					if prop.get_option_big()=="":
-						continue
-					if prop.get_option_big() == option[2:]:
-						# find it
-						debug.verbose("find argument 2 : " + option[2:])
-						if prop.need_parameters()==True:
-							internalSub = option[2+len(prop.get_option_big()):]
-							if len(internalSub)!=0:
-								if len(optionParam)!=0:
-									# wrong argument ...
-									debug.warning("maybe wrong argument for : '" + prop.get_option_big() + "' cmdLine='" + argument + "'")
-									prop.display()
-									continue
-								optionParam = internalSub
-							if len(optionParam)==0:
-								#Get the next parameters 
-								if len(sys.argv) > iii+1:
-									optionParam = sys.argv[iii+1]
-									NotparseNextElement=True
-								else :
-									# missing arguments
-									debug.warning("parsing argument error : '" + prop.get_option_big() + "' Missing : subParameters ... cmdLine='" + argument + "'")
-									prop.display()
-									exit(-1)
-							if prop.check_availlable(optionParam)==False:
-								debug.warning("argument error : '" + prop.get_option_big() + "' SubParameters not availlable ... cmdLine='" + argument + "' option='" + optionParam + "'")
-								prop.display()
-								exit(-1)
-							listArgument.append(ArgElement(prop.get_option_big(),optionParam))
-							argumentFound = True
-						else:
-							if len(optionParam)!=0:
-								debug.warning("parsing argument error : '" + prop.get_option_big() + "' need no subParameters : '" + optionParam + "'   cmdLine='" + argument + "'")
-								prop.display()
-							listArgument.append(ArgElement(prop.get_option_big()))
-							argumentFound = True
-						break;
-				if False==argumentFound:
-					debug.error("UNKNOW argument : '" + argument + "'")
-			elif option[:1]=="-":
-				# small argument
-				for prop in self.m_listProperties:
-					if prop.get_option_small()=="":
-						continue
-					if prop.get_option_small() == option[1:1+len(prop.get_option_small())]:
-						# find it
-						debug.verbose("find argument 1 : " + option[1:1+len(prop.get_option_small())])
-						if prop.need_parameters()==True:
-							internalSub = option[1+len(prop.get_option_small()):]
-							if len(internalSub)!=0:
-								if len(optionParam)!=0:
-									# wrong argument ...
-									debug.warning("maybe wrong argument for : '" + prop.get_option_big() + "' cmdLine='" + argument + "'")
-									prop.display()
-									continue
-								optionParam = internalSub
-							if len(optionParam)==0:
-								#Get the next parameters 
-								if len(sys.argv) > iii+1:
-									optionParam = sys.argv[iii+1]
-									NotparseNextElement=True
-								else :
-									# missing arguments
-									debug.warning("parsing argument error : '" + prop.get_option_big() + "' Missing : subParameters  cmdLine='" + argument + "'")
-									prop.display()
-									exit(-1)
-							if prop.check_availlable(optionParam)==False:
-								debug.warning("argument error : '" + prop.get_option_big() + "' SubParameters not availlable ... cmdLine='" + argument + "' option='" + optionParam + "'")
-								prop.display()
-								exit(-1)
-							listArgument.append(ArgElement(prop.get_option_big(),optionParam))
-							argumentFound = True
-						else:
-							if len(optionParam)!=0:
-								debug.warning("parsing argument error : '" + prop.get_option_big() + "' need no subParameters : '" + optionParam + "'  cmdLine='" + argument + "'")
-								prop.display()
-							listArgument.append(ArgElement(prop.get_option_big()))
-							argumentFound = True
-						break;
-			
-			if argumentFound==False:
-				#unknow element ... ==> just add in the list ...
-				debug.verbose("unknow argument : " + argument)
-				listArgument.append(ArgElement("", argument))
-			
-		#for argument in listArgument:
-		#	argument.display()
-		#exit(0)
-		return listArgument;
-	
-	
-	
-	def display(self):
-		print "usage:"
-		listOfPropertiesArg = "";
-		for element in self.m_listProperties :
-			listOfPropertiesArg += element.get_porperties()
-		print "	" + sys.argv[0] + listOfPropertiesArg + " ..."
-		for element in self.m_listProperties :
-			element.display()

lutinDebug.py

@@ -1,142 +0,0 @@
-#!/usr/bin/python
-##
-## @author Edouard DUPIN
-##
-## @copyright 2012, Edouard DUPIN, all right reserved
-##
-## @license APACHE v2.0 (see license file)
-##
-
-import os
-import thread
-import lutinMultiprocess
-import threading
-import re
-
-debugLevel=3
-debugColor=False
-
-color_default= ""
-color_red    = ""
-color_green  = ""
-color_yellow = ""
-color_blue   = ""
-color_purple = ""
-color_cyan   = ""
-
-
-debugLock = threading.Lock()
-
-def set_level(id):
-	global debugLevel
-	debugLevel = id
-	#print "SetDebug level at " + str(debugLevel)
-
-def get_level():
-	global debugLevel
-	return debugLevel
-
-def enable_color():
-	global debugColor
-	debugColor = True
-	global color_default
-	color_default= "\033[00m"
-	global color_red
-	color_red    = "\033[31m"
-	global color_green
-	color_green  = "\033[32m"
-	global color_yellow
-	color_yellow = "\033[33m"
-	global color_blue
-	color_blue   = "\033[34m"
-	global color_purple
-	color_purple = "\033[35m"
-	global color_cyan
-	color_cyan   = "\033[36m"
-
-def extreme_verbose(input, force=False):
-	global debugLock
-	global debugLevel
-	if    debugLevel >= 6 \
-	   or force == True:
-		debugLock.acquire()
-		print(color_blue + input + color_default)
-		debugLock.release()
-
-def verbose(input, force=False):
-	global debugLock
-	global debugLevel
-	if    debugLevel >= 5 \
-	   or force == True:
-		debugLock.acquire()
-		print(color_blue + input + color_default)
-		debugLock.release()
-
-def debug(input, force=False):
-	global debugLock
-	global debugLevel
-	if    debugLevel >= 4 \
-	   or force == True:
-		debugLock.acquire()
-		print(color_green + input + color_default)
-		debugLock.release()
-
-def info(input, force=False):
-	global debugLock
-	global debugLevel
-	if    debugLevel >= 3 \
-	   or force == True:
-		debugLock.acquire()
-		print(input + color_default)
-		debugLock.release()
-
-def warning(input, force=False):
-	global debugLock
-	global debugLevel
-	if    debugLevel >= 2 \
-	   or force == True:
-		debugLock.acquire()
-		print(color_purple + "[WARNING] " + input + color_default)
-		debugLock.release()
-
-def error(input, threadID=-1, force=False, crash=True):
-	global debugLock
-	global debugLevel
-	if    debugLevel >= 1 \
-	   or force == True:
-		debugLock.acquire()
-		print(color_red + "[ERROR] " + input + color_default)
-		debugLock.release()
-	if crash==True:
-		lutinMultiprocess.error_occured()
-		if threadID != -1:
-			thread.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 \
-	   or force == True:
-		debugLock.acquire()
-		print(color_cyan + type + color_default + " : " + color_yellow + lib + color_default + " " + dir + " " + color_blue + name + color_default)
-		debugLock.release()
-
-def print_compilator(myString):
-	global debugColor
-	global debugLock
-	if debugColor == True:
-		myString = myString.replace('\\n', '\n')
-		myString = myString.replace('\\t', '\t')
-		myString = myString.replace('error:', color_red+'error:'+color_default)
-		myString = myString.replace('warning:', color_purple+'warning:'+color_default)
-		myString = myString.replace('note:', color_green+'note:'+color_default)
-		myString = re.sub(r'([/\w_-]+\.\w+):', r'-COLORIN-\1-COLOROUT-:', myString)
-		myString = myString.replace('-COLORIN-', color_yellow)
-		myString = myString.replace('-COLOROUT-', color_default)
-	
-	debugLock.acquire()
-	print(myString)
-	debugLock.release()

lutinDepend.py

@@ -1,158 +0,0 @@
-#!/usr/bin/python
-##
-## @author Edouard DUPIN
-##
-## @copyright 2012, Edouard DUPIN, all right reserved
-##
-## @license APACHE v2.0 (see license file)
-##
-
-import os
-import lutinDebug as debug
-import lutinEnv as environement
-
-
-def need_re_build(dst, src, dependFile=None, file_cmd="", cmdLine=""):
-	debug.extreme_verbose("Resuest check of dependency of :")
-	debug.extreme_verbose("		dst='" + str(dst) + "'")
-	debug.extreme_verbose("		str='" + str(src) + "'")
-	debug.extreme_verbose("		dept='" + str(dependFile) + "'")
-	debug.extreme_verbose("		cmd='" + str(file_cmd) + "'")
-	# if force mode selected ==> just force rebuild ...
-	if environement.get_force_mode():
-		debug.extreme_verbose("			==> must rebuild (force mode)")
-		return True
-	
-	# check if the destination existed:
-	if     dst != "" \
-	   and dst != None \
-	   and os.path.exists(dst) == False:
-		debug.extreme_verbose("			==> must rebuild (dst does not exist)")
-		return True
-	if     dst != "" \
-	   and dst != None \
-	   and os.path.exists(src) == False:
-		debug.warning("			==> unexistant file :'" + src + "'")
-		return True
-	# chek the basic date if the 2 files
-	if     dst != "" \
-	   and dst != None \
-	   and os.path.getmtime(src) > os.path.getmtime(dst):
-		debug.extreme_verbose("			==> must rebuild (source time greater)")
-		return True
-	
-	if     dependFile != "" \
-	   and dependFile != None \
-	   and os.path.exists(dependFile) == False:
-		debug.extreme_verbose("			==> must rebuild (no depending file)")
-		return True
-	
-	if     file_cmd != "" \
-	   and file_cmd != None:
-		if os.path.exists(file_cmd) == False:
-			debug.extreme_verbose("			==> must rebuild (no commandLine file)")
-			return True
-		# check if the 2 cmdline are similar :
-		file2 = open(file_cmd, "r")
-		firstAndUniqueLine = file2.read()
-		if firstAndUniqueLine != cmdLine:
-			debug.extreme_verbose("			==> must rebuild (cmdLines are not identical)")
-			debug.extreme_verbose("				==> '" + cmdLine + "'")
-			debug.extreme_verbose("				==> '" + firstAndUniqueLine + "'")
-			file2.close()
-			return True
-		# the cmdfile is correct ...
-		file2.close()
-	
-	if     dependFile != "" \
-	   and dependFile != None:
-		debug.extreme_verbose("			start parsing dependency file : '" + dependFile + "'")
-		file = open(dependFile, "r")
-		for curLine in file.readlines():
-			# normal file : end with : ": \\n"
-			curLine = curLine[:len(curLine)-1]
-			# removing last \ ...
-			if curLine[len(curLine)-1:] == '\\' :
-				curLine = curLine[:len(curLine)-1]
-			# remove white space : 
-			#debug.verbose("				Line (read) : '" + curLine + "'");
-			curLine = curLine.strip()
-			#debug.verbose("				Line (strip) : '" + curLine + "'");
-			
-			testFile=""
-			if curLine[len(curLine)-1:] == ':':
-				debug.extreme_verbose("				Line (no check (already done) : '" + curLine + "'");
-			elif    len(curLine) == 0 \
-			     or curLine == '\\':
-				debug.extreme_verbose("				Line (Not parsed) : '" + curLine + "'");
-			else:
-				testFile = curLine
-				debug.extreme_verbose("				Line (might check) : '" + testFile + "'");
-			# really check files:
-			if testFile!="":
-				debug.extreme_verbose("					==> test");
-				if False==os.path.exists(testFile):
-					debug.extreme_verbose("			==> must rebuild (a dependency file does not exist)")
-					file.close()
-					return True
-				if os.path.getmtime(testFile) > os.path.getmtime(dst):
-					debug.extreme_verbose("			==> must rebuild (a dependency file time is newer)")
-					file.close()
-					return True
-		# close the current file :
-		file.close()
-	
-	debug.extreme_verbose("			==> Not rebuild (all dependency is OK)")
-	return False
-
-
-
-def need_re_package(dst, srcList, mustHaveSrc, file_cmd="", cmdLine=""):
-	debug.extreme_verbose("Resuest check of dependency of :")
-	debug.extreme_verbose("		dst='" + dst + "'")
-	debug.extreme_verbose("		src()=")
-	for src in srcList:
-		debug.verbose("			'" + src + "'")
-	
-	if mustHaveSrc==False and len(srcList)==0:
-		return False
-	
-	# if force mode selected ==> just force rebuild ...
-	if environement.get_force_mode():
-		debug.extreme_verbose("			==> must re-package (force mode)")
-		return True
-	
-	# check if the destination existed:
-	if False==os.path.exists(dst):
-		debug.extreme_verbose("			==> must re-package (dst does not exist)")
-		return True
-	# chek the basic date if the 2 files
-	if len(srcList)==0:
-		debug.extreme_verbose("			==> must re-package (no source ???)")
-		return True
-	for src in srcList:
-		if os.path.getmtime(src) > os.path.getmtime(dst):
-			debug.extreme_verbose("			==> must re-package (source time greater) : '" + src + "'")
-			return True
-	
-	if ""!=file_cmd:
-		if False==os.path.exists(file_cmd):
-			debug.extreme_verbose("			==> must rebuild (no commandLine file)")
-			return True
-		# check if the 2 cmdline are similar :
-		file2 = open(file_cmd, "r")
-		firstAndUniqueLine = file2.read()
-		if firstAndUniqueLine != cmdLine:
-			debug.extreme_verbose("			==> must rebuild (cmdLines are not identical)")
-			debug.extreme_verbose("				==> '" + cmdLine + "'")
-			debug.extreme_verbose("				==> '" + firstAndUniqueLine + "'")
-			file2.close()
-			return True
-		# the cmdfile is correct ...
-		file2.close()
-	
-	debug.extreme_verbose("			==> Not re-package (all dependency is OK)")
-	return False
-
-
-

lutinEnv.py

@@ -1,97 +0,0 @@
-#!/usr/bin/python
-##
-## @author Edouard DUPIN
-##
-## @copyright 2012, Edouard DUPIN, all right reserved
-##
-## @license APACHE v2.0 (see license file)
-##
-
-import lutinDebug as debug
-
-
-
-forceMode=False
-
-def set_force_mode(val):
-	global forceMode
-	if val==1:
-		forceMode = 1
-	else:
-		forceMode = 0
-
-def get_force_mode():
-	global forceMode
-	return forceMode
-
-
-printPrettyMode=False
-
-def set_print_pretty_mode(val):
-	global printPrettyMode
-	if val == True:
-		printPrettyMode = True
-	else:
-		printPrettyMode = False
-
-def get_print_pretty_mode():
-	global printPrettyMode
-	return printPrettyMode
-
-def print_pretty(myString, force=False):
-	global printPrettyMode
-	if    printPrettyMode == True \
-	   or force == True:
-		if myString[len(myString)-1]==' ' : 
-			tmpcmdLine = myString[:len(myString)-1]
-		else :
-			tmpcmdLine = myString
-		tmpcmdLine = tmpcmdLine.replace(' ', '\n\t')
-		tmpcmdLine = tmpcmdLine.replace('\n\t\n\t', '\n\t')
-		tmpcmdLine = tmpcmdLine.replace('\n\t\n\t', '\n\t')
-		tmpcmdLine = tmpcmdLine.replace('\n\t\n\t', '\n\t')
-		baseElementList = ["-o",
-		                   "-D",
-		                   "-I",
-		                   "-L",
-		                   "g++",
-		                   "gcc",
-		                   "clang",
-		                   "clang++",
-		                   "ar",
-		                   "ld",
-		                   "ranlib",
-		                   "-framework",
-		                   "-isysroot",
-		                   "-arch",
-		                   "-keystore",
-		                   "-sigalg",
-		                   "-digestalg",
-		                   "<",
-		                   "<<",
-		                   ">",
-		                   ">>"]
-		for element in baseElementList:
-			tmpcmdLine = tmpcmdLine.replace(element+'\n\t', element+' ')
-		baseElementList = ["g++", "gcc", "clang", "clang++", "ar", "ld", "ranlib"]
-		for element in baseElementList:
-			tmpcmdLine = tmpcmdLine.replace('/'+element+' ', '/'+element+'\n\t')
-		tmpcmdLine = tmpcmdLine.replace('\n\t', ' \\\n\t')
-		
-		return tmpcmdLine
-	else:
-		return myString
-
-forceStripMode=False
-
-def set_force_strip_mode(val):
-	global forceStripMode
-	if val==True:
-		forceStripMode = True
-	else:
-		forceStripMode = False
-
-def get_force_strip_mode():
-	global forceStripMode
-	return forceStripMode
-

lutinHeritage.py

@@ -1,195 +0,0 @@
-#!/usr/bin/python
-##
-## @author Edouard DUPIN
-##
-## @copyright 2012, Edouard DUPIN, all right reserved
-##
-## @license APACHE v2.0 (see license file)
-##
-
-import sys
-import copy
-import lutinDebug as debug
-
-
-def append_to_list(listout, list):
-	if type(list) == type(str()):
-		if list not in listout:
-			listout.append(list)
-	else:
-		# mulyiple imput in the list ...
-		for elem in list:
-			if elem not in listout:
-				listout.append(elem)
-
-
-
-class HeritageList:
-	def __init__(self, heritage = None):
-		self.flags_ld=[]
-		self.flags_cc=[]
-		self.flags_xx=[]
-		self.flags_m=[]
-		self.flags_mm=[]
-		self.flags_xx_version=1999
-		self.flags_cc_version=1989
-		# sources list:
-		self.src=[]
-		self.path=[]
-		
-		self.listHeritage=[]
-		if heritage != None:
-			self.add_heritage(heritage)
-	
-	def add_heritage(self, heritage):
-		if type(heritage) == type(None) or heritage.name == "":
-			return
-		for element in self.listHeritage:
-			if element.name == heritage.name:
-				return
-		self.listHeritage.append(heritage)
-		self.regenerateTree()
-		
-	def add_heritage_list(self, heritage_list):
-		if type(heritage_list) == type(None):
-			return
-		for herit in heritage_list.listHeritage:
-			find = False
-			for element in self.listHeritage:
-				if element.name == herit.name:
-					find = True
-			if find == False:
-				self.listHeritage.append(herit)
-		self.regenerateTree()
-	
-	def regenerateTree(self):
-		self.flags_ld=[]
-		self.flags_cc=[]
-		self.flags_xx=[]
-		self.flags_xx_version=1999
-		self.flags_xx_version=1989
-		self.flags_m=[]
-		self.flags_mm=[]
-		# sources list:
-		self.src=[]
-		self.path=[]
-		# reorder heritage list :
-		listHeritage = self.listHeritage
-		self.listHeritage = []
-		# first step : add all lib with no dependency:
-		for herit in listHeritage:
-			if len(herit.depends) == 0:
-				self.listHeritage.append(herit)
-				listHeritage.remove(herit)
-		while len(listHeritage) > 0:
-			currentHeritageSize = len(listHeritage)
-			debug.verbose("list heritage = " + str([[x.name, x.depends] for x in listHeritage]))
-			# Add element only when all dependence are resolved
-			for herit in listHeritage:
-				listDependsName = [y.name for y in self.listHeritage]
-				if all(x in listDependsName for x in herit.depends) == True:
-					listHeritage.remove(herit)
-					self.listHeritage.append(herit)
-			if currentHeritageSize == len(listHeritage):
-				debug.warning("Not resolve dependency between the library ==> can be a cyclic dependency !!!")
-				for herit in listHeritage:
-					self.listHeritage.append(herit)
-				listHeritage = []
-				debug.warning("new heritage list:")
-				for element in self.listHeritage:
-					debug.warning("	" + element.name + " " + str(element.depends))
-		debug.verbose("new heritage list:")
-		for element in self.listHeritage:
-			debug.verbose("	" + element.name + " " + str(element.depends))
-		for element in reversed(self.listHeritage):
-			append_to_list(self.flags_ld, element.flags_ld)
-			append_to_list(self.flags_cc, element.flags_cc)
-			append_to_list(self.flags_xx, element.flags_xx)
-			append_to_list(self.flags_m, element.flags_m)
-			append_to_list(self.flags_mm, element.flags_mm)
-			append_to_list(self.path, element.path)
-			append_to_list(self.src, element.src)
-			if self.flags_xx_version < element.flags_xx_version:
-				self.flags_xx_version = element.flags_xx_version
-			if self.flags_cc_version < element.flags_cc_version:
-				self.flags_cc_version = element.flags_cc_version
-
-
-class heritage:
-	def __init__(self, module):
-		self.name=""
-		self.depends=[]
-		## Remove all variable to prevent error of multiple definition
-		# all the parameter that the upper classe need when build
-		self.flags_ld=[]
-		self.flags_cc=[]
-		self.flags_xx=[]
-		self.flags_xx_version=1999
-		self.flags_cc_version=1989
-		self.flags_m=[]
-		self.flags_mm=[]
-		# sources list:
-		self.src=[]
-		self.path=[]
-		# update is set at true when data are newly created ==> force upper element to update
-		self.hasBeenUpdated=False
-		
-		if type(module) != type(None):
-			# all the parameter that the upper classe need when build
-			self.name = module.name
-			self.depends = copy.deepcopy(module.depends)
-			self.flags_ld = module.export_flags_ld
-			self.flags_cc = module.export_flags_cc
-			self.flags_xx = module.export_flags_xx
-			self.flags_m = module.export_flags_m
-			self.flags_mm = module.export_flags_mm
-			self.path = module.export_path
-			self.flags_xx_version = module.xx_version_api
-			self.flags_cc_version = module.cc_version_api
-	
-	def add_depends(self, depend):
-		self.depends.append(depend)
-	
-	def add_flag_LD(self, list):
-		append_to_list(self.flags_ld, list)
-	
-	def add_flag_CC(self, list):
-		append_to_list(self.flags_cc, list)
-	
-	def add_flag_XX(self, list):
-		append_to_list(self.flags_xx, list)
-	
-	def add_flag_M(self, list):
-		append_to_list(self.flags_m, list)
-	
-	def add_flag_MM(self, list):
-		append_to_list(self.flags_mm, list)
-	
-	def add_import_path(self, list):
-		append_to_list(self.path, list)
-	
-	def add_sources(self, list):
-		append_to_list(self.src, list)
-	
-	def need_update(self, list):
-		self.hasBeenUpdated=True
-	
-	def add_sub(self, other):
-		if type(other) == type(None):
-			debug.verbose("input of the heriatege class is None !!!")
-			return
-		if other.hasBeenUpdated == True:
-			self.hasBeenUpdated = True
-		self.add_flag_LD(other.flags_ld)
-		self.add_flag_CC(other.flags_cc)
-		self.add_flag_XX(other.flags_xx)
-		self.add_flag_M(other.flags_m)
-		self.add_flag_MM(other.flags_mm)
-		self.add_import_path(other.path)
-		self.add_sources(other.src)
-		if self.flags_xx_version < module.xx_version_api:
-			self.flags_xx_version = module.xx_version_api
-		if self.flags_cc_version < module.cc_version_api:
-			self.flags_cc_version = module.cc_version_api
-
-

lutinModule.py

@@ -1,904 +0,0 @@
-#!/usr/bin/python
-##
-## @author Edouard DUPIN
-##
-## @copyright 2012, Edouard DUPIN, all right reserved
-##
-## @license APACHE v2.0 (see license file)
-##
-
-import sys
-import os
-import inspect
-import fnmatch
-import lutinModule as module
-import lutinHost as host
-import lutinTools
-import lutinDebug as debug
-import lutinHeritage as heritage
-import lutinDepend as dependency
-import lutinMultiprocess
-import lutinEnv
-
-class Module:
-	
-	##
-	## @brief Module class represent all system needed for a specific
-	## 	module like 
-	## 		- type (bin/lib ...)
-	## 		- dependency
-	## 		- flags
-	## 		- files
-	## 		- ...
-	##
-	def __init__(self, file, moduleName, moduleType):
-		## Remove all variable to prevent error of multiple deffinition of the module ...
-		debug.verbose("Create a new module : '" + moduleName + "' TYPE=" + moduleType)
-		self.originFile=''
-		self.originFolder=''
-		# type of the module:
-		self.type='LIBRARY'
-		# Name of the module
-		self.name=moduleName
-		# Dependency list:
-		self.depends = []
-		# Dependency list (optionnal module):
-		self.depends_optionnal = []
-		self.depends_find = []
-		# Documentation list:
-		self.documentation = None
-		# export PATH
-		self.export_path = []
-		self.local_path = []
-		self.export_flags_ld = []
-		self.export_flags_cc = []
-		self.export_flags_xx = []
-		self.export_flags_m = []
-		self.export_flags_mm = []
-		# list of all flags:
-		self.flags_ld = []
-		self.flags_cc = []
-		self.flags_xx = []
-		self.flags_m = []
-		self.flags_mm = []
-		self.flags_s = []
-		self.flags_ar = []
-		# sources list:
-		self.src = []
-		# copy files and folders:
-		self.imageToCopy = []
-		self.files = []
-		self.folders = []
-		self.isbuild = False
-		# CPP version:
-		self.xx_version = 1999
-		self.xx_version_api = 1999
-		self.cc_version = 1989
-		self.cc_version_api = 1989
-		## end of basic INIT ...
-		if    moduleType == 'BINARY' \
-		   or moduleType == 'LIBRARY' \
-		   or moduleType == 'PACKAGE' \
-		   or moduleType == 'PREBUILD':
-			self.type=moduleType
-		else :
-			debug.error('for module "%s"' %moduleName)
-			debug.error('    ==> error : "%s" ' %moduleType)
-			raise 'Input value error'
-		self.originFile = file;
-		self.originFolder = lutinTools.get_current_path(self.originFile)
-		self.localHeritage = heritage.heritage(self)
-		
-		self.packageProp = { "COMPAGNY_TYPE" : set(""),
-		                     "COMPAGNY_NAME" : set(""),
-		                     "COMPAGNY_NAME2" : set(""),
-		                     "MAINTAINER" : set([]),
-		                     #"ICON" : set(""),
-		                     "SECTION" : set([]),
-		                     "PRIORITY" : set(""),
-		                     "DESCRIPTION" : set(""),
-		                     "VERSION" : set("0.0.0"),
-		                     "VERSION_CODE" : "",
-		                     "NAME" : set("no-name"), # name of the application
-		                     "ANDROID_MANIFEST" : "", # By default generate the manifest
-		                     "ANDROID_JAVA_FILES" : ["DEFAULT"], # when user want to create his own services and activities
-		                     "ANDROID_RESOURCES" : [],
-		                     "ANDROID_APPL_TYPE" : "APPL", # the other mode is "WALLPAPER" ... and later "WIDGET"
-		                     "ANDROID_WALLPAPER_PROPERTIES" : [], # To create properties of the wallpaper (no use of EWOL display)
-		                     "RIGHT" : [],
-		                     "ADMOD_POSITION" : "top"
-		                    }
-		self.subHeritageList = None
-	
-	##
-	## @brief add Some copilation flags for this module (and only this one)
-	##
-	def add_extra_compile_flags(self):
-		self.compile_flags_CC([
-			"-Wall",
-			"-Wsign-compare",
-			"-Wreturn-type",
-			#"-Wint-to-pointer-cast",
-			"-Wno-write-strings",
-			"-Woverloaded-virtual",
-			"-Wnon-virtual-dtor",
-			"-Wno-unused-variable"]);
-		#only for gcc : "-Wunused-variable", "-Wunused-but-set-variable",
-	
-	##
-	## @brief remove all unneeded warning on compilation ==> for extern libs ...
-	##
-	def remove_compile_warning(self):
-		self.compile_flags_CC([
-			"-Wno-int-to-pointer-cast"
-			]);
-		self.compile_flags_XX([
-			"-Wno-c++11-narrowing"
-			])
-		# only for gcc :"-Wno-unused-but-set-variable"
-	
-	##
-	## @brief Commands for running gcc to compile a m++ file.
-	##
-	def compile_mm_to_o(self, file, binary, target, depancy):
-		file_src, file_dst, file_depend, file_cmd = target.file_generate_object(binary,self.name,self.originFolder,file)
-		xx_version = max(self.xx_version, depancy.flags_xx_version)
-		if xx_version == 2014:
-			debug.error("not supported flags for X14 ...");
-			local_xx_version_flags=["-std=c++14", "-D__CPP_VERSION__=2014"]
-		elif xx_version == 2011:
-			local_xx_version_flags=["-std=c++11", "-D__CPP_VERSION__=2011"]
-		elif xx_version == 2003:
-			local_xx_version_flags=["-std=c++03", "-D__CPP_VERSION__=2003"]
-		else:
-			local_xx_version_flags=["-D__CPP_VERSION__=1999"]
-		
-		# create the command line befor requesting start:
-		cmdLine=lutinTools.list_to_str([
-			target.xx,
-			"-o", file_dst,
-			target.arch,
-			target.sysroot,
-			target.global_include_cc,
-			lutinTools.add_prefix("-I",self.export_path),
-			lutinTools.add_prefix("-I",self.local_path),
-			lutinTools.add_prefix("-I",depancy.path),
-			local_xx_version_flags,
-			target.global_flags_cc,
-			target.global_flags_mm,
-			depancy.flags_cc,
-			depancy.flags_mm,
-			self.flags_mm,
-			self.flags_cc,
-			self.export_flags_mm,
-			self.export_flags_cc,
-			"-c -MMD -MP",
-			"-x objective-c++",
-			file_src])
-		# check the dependency for this file :
-		if False==dependency.need_re_build(file_dst, file_src, file_depend, file_cmd, cmdLine):
-			return file_dst
-		lutinTools.create_directory_of_file(file_dst)
-		comment = ["m++", self.name, "<==", file]
-		#process element
-		lutinMultiprocess.run_in_pool(cmdLine, comment, file_cmd)
-		return file_dst
-	
-	##
-	## @brief Commands for running gcc to compile a m file.
-	##
-	def compile_m_to_o(self, file, binary, target, depancy):
-		file_src, file_dst, file_depend, file_cmd = target.file_generate_object(binary,self.name,self.originFolder,file)
-		cc_version = max(self.cc_version, depancy.flags_cc_version)
-		if cc_version == 2011:
-			local_cc_version_flags=["-std=c11", "-D__C_VERSION__=2011"]
-		elif cc_version == 1999:
-			local_cc_version_flags=["-std=c99", "-D__C_VERSION__=1999"]
-		elif cc_version == 1990:
-			local_cc_version_flags=["-std=c90", "-D__C_VERSION__=1990"]
-		else:
-			local_cc_version_flags=["-std=c89", "-D__C_VERSION__=1989"]
-		
-		# create the command line befor requesting start:
-		cmdLine=lutinTools.list_to_str([
-			target.cc,
-			"-o", file_dst ,
-			target.arch,
-			target.sysroot,
-			target.global_include_cc,
-			lutinTools.add_prefix("-I",self.export_path),
-			lutinTools.add_prefix("-I",self.local_path),
-			lutinTools.add_prefix("-I",depancy.path),
-			local_cc_version_flags,
-			target.global_flags_cc,
-			target.global_flags_m,
-			depancy.flags_cc,
-			depancy.flags_m,
-			self.flags_m,
-			self.flags_cc,
-			self.export_flags_m,
-			self.export_flags_cc,
-			"-c -MMD -MP",
-			"-x objective-c",
-			file_src])
-		# check the dependency for this file :
-		if False==dependency.need_re_build(file_dst, file_src, file_depend, file_cmd, cmdLine):
-			return file_dst
-		lutinTools.create_directory_of_file(file_dst)
-		comment = ["m", self.name, "<==", file]
-		#process element
-		lutinMultiprocess.run_in_pool(cmdLine, comment, file_cmd)
-		return file_dst
-	
-	##
-	## @brief Commands for running gcc to compile a C++ file.
-	##
-	def compile_xx_to_o(self, file, binary, target, depancy):
-		file_src, file_dst, file_depend, file_cmd = target.file_generate_object(binary,self.name,self.originFolder,file)
-		xx_version = max(self.xx_version, depancy.flags_xx_version)
-		if xx_version == 2014:
-			debug.error("not supported flags for X14 ...");
-			local_xx_version_flags=["-std=c++14", "-D__CPP_VERSION__=2014"]
-		elif xx_version == 2011:
-			local_xx_version_flags=["-std=c++11", "-D__CPP_VERSION__=2011"]
-		elif xx_version == 2003:
-			local_xx_version_flags=["-std=c++03", "-D__CPP_VERSION__=2003"]
-		else:
-			local_xx_version_flags=["-D__CPP_VERSION__=1999"]
-		
-		# create the command line befor requesting start:
-		cmdLine=lutinTools.list_to_str([
-			target.xx,
-			"-o", file_dst,
-			target.arch,
-			target.sysroot,
-			target.global_include_cc,
-			lutinTools.add_prefix("-I",self.export_path),
-			lutinTools.add_prefix("-I",self.local_path),
-			lutinTools.add_prefix("-I",depancy.path),
-			local_xx_version_flags,
-			target.global_flags_cc,
-			target.global_flags_xx,
-			depancy.flags_cc,
-			depancy.flags_xx,
-			self.flags_xx,
-			self.flags_cc,
-			self.export_flags_xx,
-			self.export_flags_cc,
-			" -c -MMD -MP",
-			file_src])
-		# check the dependency for this file :
-		if False==dependency.need_re_build(file_dst, file_src, file_depend, file_cmd, cmdLine):
-			return file_dst
-		lutinTools.create_directory_of_file(file_dst)
-		comment = ["c++", self.name, "<==", file]
-		#process element
-		lutinMultiprocess.run_in_pool(cmdLine, comment, file_cmd)
-		return file_dst
-	
-	##
-	## @brief Commands for running gcc to compile a C file.
-	##
-	def compile_cc_to_o(self, file, binary, target, depancy):
-		file_src, file_dst, file_depend, file_cmd = target.file_generate_object(binary,self.name,self.originFolder,file)
-		cc_version = max(self.cc_version, depancy.flags_cc_version)
-		if cc_version == 2011:
-			local_cc_version_flags=["-std=c11", "-D__C_VERSION__=2011"]
-		elif cc_version == 1999:
-			local_cc_version_flags=["-std=c99", "-D__C_VERSION__=1999"]
-		elif cc_version == 1990:
-			local_cc_version_flags=["-std=c90", "-D__C_VERSION__=1990"]
-		else:
-			local_cc_version_flags=["-std=c89", "-D__C_VERSION__=1989"]
-		
-		# create the command line befor requesting start:
-		cmdLine=lutinTools.list_to_str([
-			target.cc,
-			"-o", file_dst,
-			target.arch,
-			target.sysroot,
-			target.global_include_cc,
-			lutinTools.add_prefix("-I",self.export_path),
-			lutinTools.add_prefix("-I",self.local_path),
-			lutinTools.add_prefix("-I",depancy.path),
-			local_cc_version_flags,
-			target.global_flags_cc,
-			depancy.flags_cc,
-			self.flags_cc,
-			self.export_flags_cc,
-			" -c -MMD -MP",
-			file_src])
-		
-		# check the dependency for this file :
-		if False==dependency.need_re_build(file_dst, file_src, file_depend, file_cmd, cmdLine):
-			return file_dst
-		lutinTools.create_directory_of_file(file_dst)
-		comment = ["c", self.name, "<==", file]
-		# process element
-		lutinMultiprocess.run_in_pool(cmdLine, comment, file_cmd)
-		return file_dst
-	
-	
-	##
-	## @brief Commands for running ar.
-	##
-	def link_to_a(self, file, binary, target, depancy):
-		file_src, file_dst, file_depend, file_cmd = target.generate_file(binary, self.name,self.originFolder,file,"lib-static")
-		#$(Q)$(TARGET_AR) $(TARGET_GLOBAL_ARFLAGS) $(PRIVATE_ARFLAGS) $@ $(PRIVATE_ALL_OBJECTS)
-		cmdLine=lutinTools.list_to_str([
-			target.ar,
-			target.global_flags_ar,
-			self.flags_ar,
-			file_dst,
-			file_src])#,
-			#depancy.src])
-		
-		# check the dependency for this file :
-		if     False==dependency.need_re_package(file_dst, file_src, True, file_cmd, cmdLine) \
-		   and False==dependency.need_re_package(file_dst, depancy.src, False, file_cmd, cmdLine):
-			return file_dst
-		lutinTools.create_directory_of_file(file_dst)
-		debug.print_element("StaticLib", self.name, "==>", file_dst)
-		# explicitly remove the destination to prevent error ...
-		if os.path.exists(file_dst) and os.path.isfile(file_dst):
-			os.remove(file_dst)
-		lutinMultiprocess.run_command(cmdLine)
-		#$(Q)$(TARGET_RANLIB) $@
-		if target.ranlib != "":
-			cmdLineRanLib=lutinTools.list_to_str([
-				target.ranlib,
-				file_dst ])
-			lutinMultiprocess.run_command(cmdLineRanLib)
-		# write cmd line only after to prevent errors ...
-		lutinMultiprocess.store_command(cmdLine, file_cmd)
-		return file_dst
-	
-	
-	##
-	## @brief Commands for running gcc to link a shared library.
-	##
-	def link_to_so(self, file, binary, target, depancy, libName=""):
-		if libName=="":
-			libName = self.name
-		file_src, file_dst, file_depend, file_cmd = target.generate_file(binary, libName,self.originFolder,file,"lib-shared")
-		#create command Line
-		cmdLine=lutinTools.list_to_str([
-			target.xx,
-			"-o", file_dst,
-			target.global_sysroot,
-			target.arch,
-			"-shared",
-			file_src,
-			depancy.src,
-			self.flags_ld,
-			depancy.flags_ld,
-			target.global_flags_ld])
-		
-		# check the dependency for this file :
-		if     dependency.need_re_package(file_dst, file_src, True, file_cmd, cmdLine) == False \
-		   and dependency.need_re_package(file_dst, depancy.src, False, file_cmd, cmdLine) == False:
-			return tmpList[1]
-		lutinTools.create_directory_of_file(file_dst)
-		debug.print_element("SharedLib", libName, "==>", file_dst)
-		lutinMultiprocess.run_command(cmdLine)
-		if    target.config["mode"] == "release" \
-		   or lutinEnv.get_force_strip_mode()==True:
-			# get the file size of the non strip file
-			originSize = lutinTools.file_size(file_dst);
-			debug.print_element("SharedLib(strip)", libName, "", "")
-			cmdLineStrip=lutinTools.list_to_str([
-				target.strip,
-				file_dst])
-			lutinMultiprocess.run_command(cmdLineStrip)
-			# get the stip size of the binary
-			stripSize = lutinTools.file_size(file_dst)
-			debug.debug("file reduce size : " + str(originSize/1024) + "ko ==> " + str(stripSize/1024) + "ko")
-		# write cmd line only after to prevent errors ...
-		lutinMultiprocess.store_command(cmdLine, file_cmd)
-		#debug.print_element("SharedLib", self.name, "==>", tmpList[1])
-	
-	
-	##
-	## @brief Commands for running gcc to link an executable.
-	##
-	def link_to_bin(self, file, binary, target, depancy):
-		file_src, file_dst, file_depend, file_cmd = target.generate_file(binary, self.name,self.originFolder,file,"bin")
-		#create comdLine : 
-		cmdLine=lutinTools.list_to_str([
-			target.xx,
-			target.arch,
-			target.sysroot,
-			target.global_sysroot,
-			"-o", file_dst,
-			file_src,
-			depancy.src,
-			self.flags_ld,
-			depancy.flags_ld,
-			target.global_flags_ld])
-		# check the dependency for this file :
-		if False==dependency.need_re_package(file_dst, file_src, True, file_cmd, cmdLine) \
-				and False==dependency.need_re_package(file_dst, depancy.src, False, file_cmd, cmdLine):
-			return file_dst
-		lutinTools.create_directory_of_file(file_dst)
-		debug.print_element("Executable", self.name, "==>", file_dst)
-		
-		lutinMultiprocess.run_command(cmdLine)
-		if    "release"==target.config["mode"] \
-		   or lutinEnv.get_force_strip_mode()==True:
-			# get the file size of the non strip file
-			originSize = lutinTools.file_size(file_dst);
-			debug.print_element("Executable(strip)", self.name, "", "")
-			cmdLineStrip=lutinTools.list_to_str([
-				target.strip,
-				file_dst])
-			lutinMultiprocess.run_command(cmdLineStrip)
-			# get the stip size of the binary
-			stripSize = lutinTools.file_size(file_dst)
-			debug.debug("file reduce size : " + str(originSize/1024) + "ko ==> " + str(stripSize/1024) + "ko")
-		# write cmd line only after to prevent errors ...
-		lutinMultiprocess.store_command(cmdLine, file_cmd)
-		
-	
-	##
-	## @brief Commands for copying files
-	##
-	def image_to_staging(self, binaryName, target):
-		for source, destination, sizeX, sizeY in self.imageToCopy:
-			extension = source[source.rfind('.'):]
-			if     extension != ".png" \
-			   and extension != ".jpg" \
-			   and sizeX > 0:
-				debug.error("Can not manage image other than .png and jpg to resize : " + source);
-			displaySource = source
-			source = self.originFolder + "/" + source
-			if destination == "":
-				destination = source[source.rfind('/')+1:]
-				debug.verbose("Regenerate Destination : '" + destination + "'")
-			file_cmd = target.generate_file(binaryName, self.name, self.originFolder, destination, "image")[0]
-			if sizeX > 0:
-				debug.verbose("Image file : " + displaySource + " ==> " + destination + " resize=(" + str(sizeX) + "," + str(sizeY) + ")")
-				fileName, fileExtension = os.path.splitext(self.originFolder+"/" + source)
-				target.add_image_staging(source, destination, sizeX, sizeY, file_cmd)
-			else:
-				debug.verbose("Might copy file : " + displaySource + " ==> " + destination)
-				target.add_file_staging(source, destination, file_cmd)
-	
-	##
-	## @brief Commands for copying files
-	##
-	def files_to_staging(self, binaryName, target):
-		for source, destination in self.files:
-			displaySource = source
-			source = self.originFolder + "/" + source
-			if destination == "":
-				destination = source[source.rfind('/')+1:]
-				debug.verbose("Regenerate Destination : '" + destination + "'")
-			file_cmd = target.generate_file(binaryName, self.name, self.originFolder, destination, "image")[0]
-			# TODO : when destination is missing ...
-			debug.verbose("Might copy file : " + displaySource + " ==> " + destination)
-			target.add_file_staging(source, destination, file_cmd)
-	
-	##
-	## @brief Commands for copying files
-	##
-	def folders_to_staging(self, binaryName, target):
-		for source, destination in self.folders:
-			debug.debug("Might copy folder : " + source + "==>" + destination)
-			lutinTools.copy_anything_target(target, self.originFolder + "/" + source, destination)
-	
-	# call here to build the module
-	def build(self, target, packageName):
-		# ckeck if not previously build
-		if target.is_module_build(self.name)==True:
-			if self.subHeritageList == None:
-				self.localHeritage = heritage.heritage(self)
-			return self.subHeritageList
-		# create the packege heritage
-		self.localHeritage = heritage.heritage(self)
-		
-		if     packageName==None \
-		   and (    self.type=="BINARY" \
-		         or self.type=="PACKAGE" ) :
-			# this is the endpoint binary ...
-			packageName = self.name
-		else :
-			# TODO : Set it better ...
-			None
-		
-		# build dependency before
-		listSubFileNeededTobuild = []
-		self.subHeritageList = heritage.HeritageList()
-		# optionnal dependency :
-		for dep, option, export in self.depends_optionnal:
-			inheritList, isBuilt = target.build_optionnal(dep, packageName)
-			if isBuilt == True:
-				self.localHeritage.add_depends(dep);
-				# TODO : Add optionnal Flags ...
-				#     ==> do it really better ...
-				if export == False:
-					self.compile_flags_CC("-D"+option);
-				else:
-					self.add_export_flag_CC("-D"+option);
-			# add at the heritage list :
-			self.subHeritageList.add_heritage_list(inheritList)
-		for dep in self.depends:
-			inheritList = target.build(dep, packageName)
-			# add at the heritage list :
-			self.subHeritageList.add_heritage_list(inheritList)
-		
-		# build local sources
-		for file in self.src:
-			#debug.info(" " + self.name + " <== " + file);
-			fileExt = file.split(".")[-1]
-			if    fileExt in ["c", "C"]:
-				resFile = self.compile_cc_to_o(file, packageName, target, self.subHeritageList)
-				listSubFileNeededTobuild.append(resFile)
-			elif    fileExt in ["cpp", "CPP", "cxx", "CXX", "xx", "XX", "CC", "cc"]:
-				resFile = self.compile_xx_to_o(file, packageName, target, self.subHeritageList)
-				listSubFileNeededTobuild.append(resFile)
-			elif    fileExt in ["mm", "MM"]:
-				resFile = self.compile_mm_to_o(file, packageName, target, self.subHeritageList)
-				listSubFileNeededTobuild.append(resFile)
-			elif    fileExt in ["m", "M"]:
-				resFile = self.compile_m_to_o(file, packageName, target, self.subHeritageList)
-				listSubFileNeededTobuild.append(resFile)
-			else:
-				debug.warning(" UN-SUPPORTED file format:  '" + self.originFolder + "/" + file + "'")
-		# when multiprocess availlable, we need to synchronize here ...
-		lutinMultiprocess.pool_synchrosize()
-		
-		# generate end point:
-		if self.type=='PREBUILD':
-			debug.print_element("Prebuild", self.name, "==>", "find")
-		elif self.type=='LIBRARY':
-			resFile = self.link_to_a(listSubFileNeededTobuild, packageName, target, self.subHeritageList)
-			self.localHeritage.add_sources(resFile)
-		elif self.type=='BINARY':
-			resFile = self.link_to_bin(listSubFileNeededTobuild, packageName, target, self.subHeritageList)
-			# generate tree for this special binary
-			target.clean_module_tree()
-			self.build_tree(target, self.name)
-			target.copy_to_staging(self.name)
-		elif self.type=="PACKAGE":
-			if target.name=="Android":
-				# special case for android wrapper :
-				resFile = self.link_to_so(listSubFileNeededTobuild, packageName, target, self.subHeritageList, "libewol")
-			else:
-				resFile = self.link_to_bin(listSubFileNeededTobuild, packageName, target, self.subHeritageList)
-			target.clean_module_tree()
-			# generate tree for this special binary
-			self.build_tree(target, self.name)
-			target.copy_to_staging(self.name)
-			if target.endGeneratePackage==True:
-				# generate the package with his properties ...
-				target.make_package(self.name, self.packageProp, self.originFolder + "/..")
-		else:
-			debug.error("Dit not know the element type ... (impossible case) type=" + self.type)
-			
-		self.subHeritageList.add_heritage(self.localHeritage)
-		# return local dependency ...
-		return self.subHeritageList
-	
-	# call here to build the module
-	def build_tree(self, target, packageName):
-		# ckeck if not previously build
-		if target.is_module_buildTree(self.name)==True:
-			return
-		debug.verbose("build tree of " + self.name)
-		# add all the elements (first added only one keep ==> permit to everload sublib element)
-		self.image_to_staging(packageName, target)
-		self.files_to_staging(packageName, target)
-		self.folders_to_staging(packageName, target)
-		#build tree of all submodules
-		for dep in self.depends:
-			inherit = target.build_tree(dep, packageName)
-	
-	
-	# call here to clean the module
-	def clean(self, target):
-		if self.type=='PREBUILD':
-			# nothing to add ==> just dependence
-			None
-		elif self.type=='LIBRARY':
-			# remove folder of the lib ... for this targer
-			folderbuild = target.get_build_folder(self.name)
-			debug.info("remove folder : '" + folderbuild + "'")
-			lutinTools.remove_folder_and_sub_folder(folderbuild)
-		elif    self.type=='BINARY' \
-		     or self.type=='PACKAGE':
-			# remove folder of the lib ... for this targer
-			folderbuild = target.get_build_folder(self.name)
-			debug.info("remove folder : '" + folderbuild + "'")
-			lutinTools.remove_folder_and_sub_folder(folderbuild)
-			folderStaging = target.get_staging_folder(self.name)
-			debug.info("remove folder : '" + folderStaging + "'")
-			lutinTools.remove_folder_and_sub_folder(folderStaging)
-		else:
-			debug.error("Dit not know the element type ... (impossible case) type=" + self.type)
-	
-	def append_and_check(self, listout, newElement, order):
-		for element in listout:
-			if element==newElement:
-				return
-		listout.append(newElement)
-		if True==order:
-			listout.sort()
-	
-	def append_to_internalList(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_module_depend(self, list):
-		self.append_to_internalList(self.depends, list, True)
-	
-	def add_optionnal_module_depend(self, module_name, compilation_flags="", export=False):
-		self.append_and_check(self.depends_optionnal, [module_name, compilation_flags, export], True)
-	
-	def add_export_path(self, list):
-		self.append_to_internalList(self.export_path, list)
-	
-	def add_path(self, list):
-		self.append_to_internalList(self.local_path, list)
-	
-	def add_export_flag_LD(self, list):
-		self.append_to_internalList(self.export_flags_ld, list)
-	
-	def add_export_flag_CC(self, list):
-		self.append_to_internalList(self.export_flags_cc, list)
-	
-	def add_export_flag_XX(self, list):
-		self.append_to_internalList(self.export_flags_xx, list)
-	
-	def add_export_flag_M(self, list):
-		self.append_to_internalList(self.export_flags_m, list)
-	
-	def add_export_flag_MM(self, list):
-		self.append_to_internalList(self.export_flags_mm, list)
-	
-	# add the link flag at the module
-	def compile_flags_LD(self, list):
-		self.append_to_internalList(self.flags_ld, list)
-	
-	def compile_flags_CC(self, list):
-		self.append_to_internalList(self.flags_cc, list)
-	
-	def compile_flags_XX(self, list):
-		self.append_to_internalList(self.flags_xx, list)
-	
-	def compile_flags_M(self, list):
-		self.append_to_internalList(self.flags_m, list)
-	
-	def compile_flags_MM(self, list):
-		self.append_to_internalList(self.flags_mm, list)
-	
-	def compile_flags_S(self, list):
-		self.append_to_internalList(self.flags_s, list)
-	
-	def compile_version_XX(self, version, same_as_api=True):
-		cpp_version_list = [1999, 2003, 2011, 2014]
-		if version not in cpp_version_list:
-			debug.error("can not select CPP version : " + str(version) + " not in " + str(cpp_version_list))
-		self.xx_version = version
-		if same_as_api == True:
-			self.xx_version_api = self.xx_version
-	
-	def compile_version_CC(self, version, same_as_api=True):
-		c_version_list = [1989, 1990, 1999, 2011]
-		if version not in c_version_list:
-			debug.error("can not select C version : " + str(version) + " not in " + str(c_version_list))
-		self.cc_version = version
-		if same_as_api == True:
-			self.cc_version_api = self.cc_version
-	
-	def add_src_file(self, list):
-		self.append_to_internalList(self.src, list, True)
-	
-	def copy_image(self, source, destination='', sizeX=-1, sizeY=-1):
-		self.imageToCopy.append([source, destination, sizeX, sizeY])
-	
-	def copy_file(self, source, destination=''):
-		self.files.append([source, destination])
-	
-	def copy_folder(self, source, destination=''):
-		self.folders.append([source, destination])
-	
-	def print_list(self, description, list):
-		if len(list) > 0:
-			print '        %s' %description
-			for elem in list:
-				print '            %s' %elem
-	
-	def display(self, target):
-		print '-----------------------------------------------'
-		print ' package : "%s"' %self.name
-		print '-----------------------------------------------'
-		print '    type:"%s"' %self.type
-		print '    file:"%s"' %self.originFile
-		print '    folder:"%s"' %self.originFolder
-		self.print_list('depends',self.depends)
-		self.print_list('depends_optionnal', self.depends_optionnal)
-		self.print_list('flags_ld',self.flags_ld)
-		self.print_list('flags_cc',self.flags_cc)
-		self.print_list('flags_xx',self.flags_xx)
-		self.print_list('flags_m',self.flags_m)
-		self.print_list('flags_mm',self.flags_mm)
-		self.print_list('flags_s',self.flags_s)
-		self.print_list('src',self.src)
-		self.print_list('files',self.files)
-		self.print_list('folders',self.folders)
-		self.print_list('export_path',self.export_path)
-		self.print_list('export_flags_ld',self.export_flags_ld)
-		self.print_list('export_flags_cc',self.export_flags_cc)
-		self.print_list('export_flags_xx',self.export_flags_xx)
-		self.print_list('export_flags_m',self.export_flags_m)
-		self.print_list('export_flags_mm',self.export_flags_mm)
-		self.print_list('local_path',self.local_path)
-	
-	def pkg_set(self, variable, value):
-		if "COMPAGNY_TYPE" == variable:
-			#	com : Commercial
-			#	net : Network??
-			#	org : Organisation
-			#	gov : Governement
-			#	mil : Military
-			#	edu : Education
-			#	pri : Private
-			#	museum : ...
-			if value not in ["com", "net", "org", "gov", "mil", "edu", "pri", "museum"]:
-				debug.error("can not set the value for this Input : '" + variable + "' : '" + value + "'")
-			else:
-				self.packageProp[variable] = value
-		elif "COMPAGNY_NAME" == variable:
-			self.packageProp[variable] = value
-			val2 = value.lower()
-			val2 = val2.replace(' ', '')
-			val2 = val2.replace('-', '')
-			val2 = val2.replace('_', '')
-			self.packageProp["COMPAGNY_NAME2"] = val2
-		elif "ICON" == variable:
-			self.packageProp[variable] = value
-		elif "MAINTAINER" == variable:
-			self.packageProp[variable] = value
-		elif "SECTION" == variable:
-			# project section : (must be separate by coma
-			#    refer to : http://packages.debian.org/sid/
-			#        admin cli-mono comm database debian-installer
-			#        debug doc editors electronics devel embedded
-			#        fonts games gnome gnu-r gnustep graphics
-			#        hamradio haskell httpd interpreters java
-			#        kde kernel libdevel libs lisp localization
-			#        mail math misc net news ocaml oldlibs otherosfs
-			#        perl php python ruby science shells sound tex
-			#        text utils vcs video virtual web x11 xfce zope ...
-			self.packageProp[variable] = value
-		elif "PRIORITY" == variable:
-			#list = ["required","important","standard","optional","extra"]
-			#if isinstance(value, list):
-			if value not in ["required", "important", "standard", "optional", "extra"]:
-				debug.error("can not set the value for this Input : '" + variable + "' : '" + value + "'")
-			else:
-				self.packageProp[variable] = value
-		elif "DESCRIPTION" == variable:
-			self.packageProp[variable] = value
-		elif "VERSION" == variable:
-			self.packageProp[variable] = value
-		elif "VERSION_CODE" == variable:
-			self.packageProp[variable] = value
-		elif "NAME" == variable:
-			self.packageProp[variable] = value
-		elif "ANDROID_MANIFEST" == variable:
-			self.packageProp[variable] = value
-		elif "ANDROID_JAVA_FILES" == variable:
-			self.packageProp[variable] = value
-		elif "RIGHT" == variable:
-			self.packageProp[variable] = value
-		elif "ANDROID_RESOURCES" == variable:
-			self.packageProp[variable] = value
-		elif "ANDROID_APPL_TYPE" == variable:
-			self.packageProp[variable] = value
-		elif "ADMOD_ID" == variable:
-			self.packageProp[variable] = value
-		elif "APPLE_APPLICATION_IOS_ID" == variable:
-			self.packageProp[variable] = value
-		elif "ADMOD_POSITION" == variable:
-			if value in ["top", "bottom"]:
-				self.packageProp[variable] = value
-			else:
-				debug.error("not know pkg element : '" + variable + "' with value : '" + value + "' must be [top|bottom]")
-		else:
-			debug.error("not know pkg element : '" + variable + "'")
-	
-	def pkg_add(self, variable, value):
-		# TODO : Check values...
-		self.packageProp[variable].append(value)
-	
-	def ext_project_add_module(self, target, projectMng, addedModule = []):
-		if self.name in addedModule:
-			return
-		addedModule.append(self.name)
-		debug.verbose("add a module to the project generator :" + self.name)
-		debug.verbose("local path :" + self.originFolder)
-		projectMng.add_files(self.name, self.originFolder, self.src)
-		#projectMng.add_data_file(self.originFolder, self.files)
-		#projectMng.add_data_folder(self.originFolder, self.folders)
-		"""
-		for depend in self.depends:
-			target.project_add_module(depend, projectMng, addedModule)
-		"""
-	
-	def create_project(self, target, projectMng):
-		projectMng.set_project_name(self.name)
-		self.ext_project_add_module(target, projectMng)
-		projectMng.generate_project_file()
-
-
-
-moduleList=[]
-__startModuleName="lutin_"
-
-def import_path(path):
-	global moduleList
-	matches = []
-	debug.debug('Start find sub File : "%s"' %path)
-	for root, dirnames, filenames in os.walk(path):
-		tmpList = fnmatch.filter(filenames, __startModuleName + "*.py")
-		# Import the module :
-		for filename in tmpList:
-			debug.debug('    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)) )
-			moduleName = filename.replace('.py', '')
-			moduleName = moduleName.replace(__startModuleName, '')
-			debug.debug("integrate module: '" + moduleName + "' from '" + os.path.join(root, filename) + "'")
-			moduleList.append([moduleName,os.path.join(root, filename)])
-
-def exist(target, name):
-	global moduleList
-	for mod in moduleList:
-		if mod[0] == name:
-			return True
-	return False
-
-def load_module(target, name):
-	global moduleList
-	for mod in moduleList:
-		if mod[0] == name:
-			sys.path.append(os.path.dirname(mod[1]))
-			debug.verbose("import module : '" + __startModuleName + name + "'")
-			theModule = __import__(__startModuleName + name)
-			#try:
-			tmpElement = theModule.create(target)
-			#except:
-			#tmpElement = None
-			#debug.warning(" no function 'create' in the module : " + mod[0] + " from:'" + mod[1] + "'")
-			if (tmpElement == None) :
-				debug.debug("Request load module '" + name + "' not define for this platform")
-			else:
-				target.add_module(tmpElement)
-
-def list_all_module():
-	global moduleList
-	tmpListName = []
-	for mod in moduleList:
-		tmpListName.append(mod[0])
-	return tmpListName
-
-def list_all_module_with_desc():
-	global moduleList
-	tmpList = []
-	for mod in moduleList:
-		sys.path.append(os.path.dirname(mod[1]))
-		theModule = __import__("lutin_" + mod[0])
-		try:
-			tmpdesc = theModule.get_desc()
-			tmpList.append([mod[0], tmpdesc])
-		except:
-			debug.warning("has no naeme : " + mod[0])
-			tmpList.append([mod[0], ""])
-	return tmpList
-
-

lutinMultiprocess.py

@@ -1,266 +0,0 @@
-#!/usr/bin/python
-##
-## @author Edouard DUPIN
-##
-## @copyright 2012, Edouard DUPIN, all right reserved
-##
-## @license APACHE v2.0 (see license file)
-##
-
-import sys
-import lutinDebug as debug
-import threading
-import time
-import Queue
-import os
-import subprocess
-import lutinTools
-import lutinEnv
-import shlex
-
-queueLock = threading.Lock()
-workQueue = Queue.Queue()
-currentThreadWorking = 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 = {
-	"id":-1,
-	"cmd":"",
-	"return":0,
-	"err":"",
-	"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
-
-def store_command(cmdLine, file):
-	# write cmd line only after to prevent errors ...
-	if     file != "" \
-	   and file != None:
-		# Create directory:
-		lutinTools.create_directory_of_file(file)
-		# Store the command Line:
-		file2 = open(file, "w")
-		file2.write(cmdLine)
-		file2.flush()
-		file2.close()
-
-##
-## @brief Execute the command and ruturn generate data
-##
-def run_command_direct(cmdLine):
-	# prepare command line:
-	args = shlex.split(cmdLine)
-	debug.verbose("cmd = " + str(args))
-	try:
-		# create the subprocess
-		p = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-	except subprocess.CalledProcessError as e:
-		debug.error("subprocess.CalledProcessError : " + str(args))
-	# launch the subprocess:
-	output, err = p.communicate()
-	# Check error :
-	if p.returncode == 0:
-		if output == None:
-			return err[:-1];
-		return output[:-1];
-	else:
-		return False
-
-
-def run_command(cmdLine, storeCmdLine="", buildId=-1, file=""):
-	global errorOccured
-	global exitFlag
-	global currentIdExecution
-	# prepare command line:
-	args = shlex.split(cmdLine)
-	debug.verbose("cmd = " + str(args))
-	try:
-		# create the subprocess
-		p = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-	except subprocess.CalledProcessError as e:
-		debug.error("subprocess.CalledProcessError : TODO ...")
-	# launch the subprocess:
-	output, err = p.communicate()
-	# Check error :
-	if p.returncode == 0:
-		debug.debug(lutinEnv.print_pretty(cmdLine))
-		queueLock.acquire()
-		# TODO : Print the output all the time .... ==> to show warnings ...
-		if buildId >= 0 and (output != "" or err != ""):
-			debug.warning("output in subprocess compiling: '" + file + "'")
-		if output != "":
-			debug.print_compilator(output)
-		if err != "":
-			debug.print_compilator(err)
-		queueLock.release()
-	else:
-		errorOccured = True
-		exitFlag = True
-		# if No ID : Not in a multiprocess mode ==> just stop here
-		if buildId < 0:
-			debug.debug(lutinEnv.print_pretty(cmdLine), force=True)
-			debug.print_compilator(output)
-			debug.print_compilator(err)
-			if p.returncode == 2:
-				debug.error("can not compile file ... [keyboard interrrupt]")
-			else:
-				debug.error("can not compile file ... ret : " + str(p.returncode))
-		else:
-			# in multiprocess interface
-			queueLock.acquire()
-			# if an other write an error before, check if the current process is started before ==> then is the first error
-			if errorExecution["id"] >= buildId:
-				# nothing to do ...
-				queueLock.release()
-				return;
-			errorExecution["id"] = buildId
-			errorExecution["cmd"] = cmdLine
-			errorExecution["return"] = p.returncode
-			errorExecution["err"] = err,
-			errorExecution["out"] = output,
-			queueLock.release()
-		# not write the command file...
-		return
-	debug.verbose("done 3")
-	# write cmd line only after to prevent errors ...
-	store_command(cmdLine, storeCmdLine)
-
-
-
-class myThread(threading.Thread):
-	def __init__(self, threadID, lock, queue):
-		threading.Thread.__init__(self)
-		self.threadID = threadID
-		self.name = "Thread " + str(threadID)
-		self.queue = queue
-		self.lock = lock
-	def run(self):
-		debug.verbose("Starting " + self.name)
-		global exitFlag
-		global currentThreadWorking
-		workingSet = False
-		while exitFlag == False:
-			self.lock.acquire()
-			if not self.queue.empty():
-				if workingSet==False:
-					currentThreadWorking += 1
-					workingSet = True
-				data = self.queue.get()
-				self.lock.release()
-				debug.verbose(self.name + " processing '" + data[0] + "'")
-				if data[0]=="cmdLine":
-					comment = data[2]
-					cmdLine = data[1]
-					cmdStoreFile = data[3]
-					debug.print_element( "[" + str(data[4]) + "][" + str(self.threadID) + "] " + comment[0], comment[1], comment[2], comment[3])
-					run_command(cmdLine, cmdStoreFile, buildId=data[4], file=comment[3])
-				else:
-					debug.warning("unknow request command : " + data[0])
-			else:
-				if workingSet==True:
-					currentThreadWorking -= 1
-					workingSet=False
-				# no element to parse, just wait ...
-				self.lock.release()
-				time.sleep(0.2)
-		# kill requested ...
-		debug.verbose("Exiting " + self.name)
-
-
-def error_occured():
-	global exitFlag
-	exitFlag = True
-
-def set_core_number(numberOfcore):
-	global processorAvaillable
-	processorAvaillable = numberOfcore
-	debug.debug(" set number of core for multi process compilation : " + str(processorAvaillable))
-	# nothing else to do
-
-def init():
-	global exitFlag
-	global isinit
-	if isinit==False:
-		isinit=True
-		global threads
-		global queueLock
-		global workQueue
-		# Create all the new threads
-		threadID = 0
-		while threadID < processorAvaillable:
-			thread = myThread(threadID, queueLock, workQueue)
-			thread.start()
-			threads.append(thread)
-			threadID += 1
-		
-
-
-def un_init():
-	global exitFlag
-	# Notify threads it's time to exit
-	exitFlag = True
-	if processorAvaillable > 1:
-		# Wait for all threads to complete
-		for tmp in threads:
-			debug.verbose("join thread ...")
-			tmp.join()
-		debug.verbose("Exiting ALL Threads")
-
-
-
-def run_in_pool(cmdLine, comment, storeCmdLine=""):
-	global currentIdExecution
-	if processorAvaillable <= 1:
-		debug.print_element(comment[0], comment[1], comment[2], comment[3])
-		run_command(cmdLine, storeCmdLine, file=comment[3])
-		return
-	# multithreaded mode
-	init()
-	# Fill the queue
-	queueLock.acquire()
-	debug.verbose("add : in pool cmdLine")
-	workQueue.put(["cmdLine", cmdLine, comment, storeCmdLine, currentIdExecution])
-	currentIdExecution +=1;
-	queueLock.release()
-	
-
-def pool_synchrosize():
-	global errorOccured
-	global errorExecution
-	if processorAvaillable <= 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:
-		time.sleep(0.2)
-		pass
-	# Wait all thread have ended their current process
-	while currentThreadWorking != 0 \
-	      and False==errorOccured:
-		time.sleep(0.2)
-		pass
-	if False==errorOccured:
-		debug.verbose("queue is empty")
-	else:
-		un_init()
-		debug.debug("Thread return with error ... ==> stop all the pool")
-		if errorExecution["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(lutinEnv.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("can not compile file ... [keyboard interrrupt]")
-		else:
-			debug.error("can not compile file ... return value : " + str(errorExecution["return"]))
-	

lutinSystem.py

@@ -1,163 +0,0 @@
-#!/usr/bin/python
-##
-## @author Edouard DUPIN
-##
-## @copyright 2012, Edouard DUPIN, all right reserved
-##
-## @license APACHE v2.0 (see license file)
-##
-
-import sys
-import os
-import inspect
-import fnmatch
-import lutinDebug as debug
-import datetime
-import lutinTools
-import lutinModule as module
-import lutinImage
-import lutinHost
-
-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=[]
-		
-	def append_and_check(self, listout, newElement, order):
-		for element in listout:
-			if element==newElement:
-				return
-		listout.append(newElement)
-		if True==order:
-			listout.sort()
-	
-	def append_to_internalList(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_flag_LD(self, list):
-		self.append_to_internalList(self.export_flags_ld, list)
-	
-	def add_export_flag_CC(self, list):
-		self.append_to_internalList(self.export_flags_cc, list)
-	
-	def add_export_flag_XX(self, list):
-		self.append_to_internalList(self.export_flags_xx, list)
-	
-	def add_export_flag_M(self, list):
-		self.append_to_internalList(self.export_flags_m, list)
-	
-	def add_export_flag_MM(self, list):
-		self.append_to_internalList(self.export_flags_mm, list)
-	
-	
-
-
-
-def createModuleFromSystem(target, dict):
-	myModule = module.Module(dict["path"], dict["name"], 'PREBUILD')
-	
-	myModule.add_export_flag_CC(dict["system"].export_flags_cc)
-	myModule.add_export_flag_LD(dict["system"].export_flags_ld)
-	myModule.add_export_flag_XX(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 the currrent module at the 
-	return myModule
-
-
-
-
-# Dictionnaire of Target name
-#   inside table of ["Name of the lib", "path of the lib", boolean loaded, module loaded]
-systemList={}
-__startSystemName="lutinSystem_"
-
-
-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, __startSystemName + "*.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(__startSystemName, '')
-			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}]
-
-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"])
-
-
-def exist(lib_name, target_name) :
-	global systemList
-	if target_name not in systemList:
-		return False
-	for data in systemList[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__(__startSystemName + target_name + "_" + data["name"])
-				#create the system module
-				try:
-					data["system"] = theSystem.System()
-					data["exist"] = data["system"].valid
-				except:
-					debug.debug("Not find: '" + data["name"] + "'")
-			return data["exist"]
-	return False
-
-def load(target, lib_name, target_name):
-	global systemList
-	if target_name not in systemList:
-		debug.error("you must call this function after checking of the system exist() !1!")
-	for data in systemList[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["loaded"] = True
-			target.add_module(data["module"])
-			return
-

lutinTarget.py

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

lutinTools.py

@@ -1,143 +0,0 @@
-#!/usr/bin/python
-##
-## @author Edouard DUPIN
-##
-## @copyright 2012, Edouard DUPIN, all right reserved
-##
-## @license APACHE v2.0 (see license file)
-##
-
-import os
-import shutil
-import errno
-import lutinDebug as debug
-import fnmatch
-import lutinMultiprocess
-import lutinDepend as dependency
-
-
-"""
-	
-"""
-def get_run_folder():
-	return os.getcwd()
-
-"""
-	
-"""
-def get_current_path(file):
-	return os.path.dirname(os.path.realpath(file))
-
-def create_directory_of_file(file):
-	folder = os.path.dirname(file)
-	try:
-		os.stat(folder)
-	except:
-		os.makedirs(folder)
-
-def get_list_sub_folder(path):
-	# TODO : os.listdir(path)
-	for dirname, dirnames, filenames in os.walk(path):
-		return dirnames
-	return []
-
-def remove_folder_and_sub_folder(path):
-	if os.path.isdir(path):
-		debug.verbose("remove folder : '" + path + "'")
-		shutil.rmtree(path)
-
-def remove_file(path):
-	if os.path.isfile(path):
-		os.remove(path)
-
-def file_size(path):
-	if not os.path.isfile(path):
-		return 0
-	statinfo = os.stat(path)
-	return statinfo.st_size
-
-def file_read_data(path):
-	if not os.path.isfile(path):
-		return ""
-	file = open(path, "r")
-	data_file = file.read()
-	file.close()
-	return data_file
-
-def file_write_data(path, data):
-	file = open(path, "w")
-	file.write(data)
-	file.close()
-
-def list_to_str(list):
-	if type(list) == type(str()):
-		return list + " "
-	else:
-		result = ""
-		# mulyiple imput in the list ...
-		for elem in list:
-			result += list_to_str(elem)
-		return result
-
-def add_prefix(prefix,list):
-	if type(list) == type(None):
-		return ""
-	if type(list) == type(str()):
-		return prefix+list
-	else:
-		if len(list)==0:
-			return ''
-		else:
-			result=[]
-			for elem in list:
-				result.append(prefix+elem)
-			return result
-
-def copy_file(src, dst, cmd_file=None, force=False):
-	if os.path.exists(src) == False:
-		debug.error("Request a copy a file that does not existed : '" + src + "'")
-	cmd_line = "copy \"" + src + "\" \"" + dst + "\""
-	if     force == False \
-	   and dependency.need_re_build(dst, src, file_cmd=cmd_file , cmdLine=cmd_line) == False:
-		return
-	debug.print_element("copy file", src, "==>", dst)
-	create_directory_of_file(dst)
-	shutil.copyfile(src, dst)
-	lutinMultiprocess.store_command(cmd_line, cmd_file)
-
-
-def copy_anything(src, dst):
-	tmpPath = os.path.dirname(os.path.realpath(src))
-	tmpRule = os.path.basename(src)
-	for root, dirnames, filenames in os.walk(tmpPath):
-		debug.verbose(" root='" + str(root) + "' dir='" + str(dirnames) + "' filenames=" + str(filenames))
-		tmpList = filenames
-		if len(tmpRule)>0:
-			tmpList = fnmatch.filter(filenames, tmpRule)
-		# Import the module :
-		for cycleFile in tmpList:
-			#for cycleFile in filenames:
-			debug.verbose("Might copy : '" + tmpPath+cycleFile + "' ==> '" + dst + "'")
-			copy_file(tmpPath+"/"+cycleFile, dst+"/"+cycleFile)
-
-
-def copy_anything_target(target, src, dst):
-	tmpPath = os.path.dirname(os.path.realpath(src))
-	tmpRule = os.path.basename(src)
-	for root, dirnames, filenames in os.walk(tmpPath):
-		debug.verbose(" root='" + str(root) + "' dir='" + str(dirnames) + "' filenames=" + str(filenames))
-		tmpList = filenames
-		if len(tmpRule)>0:
-			tmpList = fnmatch.filter(filenames, tmpRule)
-		# Import the module :
-		for cycleFile in tmpList:
-			#for cycleFile in filenames:
-			newDst = dst
-			if len(newDst) != 0 and newDst[-1] != "/":
-				newDst += "/"
-			if root[len(src)-1:] != "":
-				newDst += root[len(src)-1:]
-				if len(newDst) != 0 and newDst[-1] != "/":
-					newDst += "/"
-			debug.verbose("Might copy : '" + root+"/"+cycleFile + "' ==> '" + newDst+cycleFile + "'" )
-			target.add_file_staging(root+"/"+cycleFile, newDst+cycleFile)

setup.py

@@ -0,0 +1,48 @@
+#!/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():
+	with open('README.rst') as f:
+		return f.read()
+
+# https://pypi.python.org/pypi?%3Aaction=list_classifiers
+setup(name='lutin',
+      version='2.0.1',
+      description='Lutin generic builder (might replace makefile, CMake ...)',
+      long_description=readme(),
+      url='http://github.com/HeeroYui/lutin',
+      author='Edouard DUPIN',
+      author_email='yui.heero@gmail.com',
+      license='APACHE-2',
+      packages=['lutin',
+                'lutin/z_builder',
+                'lutin/z_system',
+                'lutin/z_target'],
+      classifiers=[
+        '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'],
+      # Does not work on MacOs
+      #data_file=[
+      #    ('/etc/bash_completion.d', ['bash-autocompletion/lutin']),
+      #],
+      include_package_data = True,
+      zip_safe=False)
+
+#To developp: sudo ./setup.py install
+#             sudo ./setup.py develop
+#TO register all in pip: ./setup.py register sdist upload
+

system/lutinSystem_IOs_CoreAudio.py

@@ -1,25 +0,0 @@
-#!/usr/bin/python
-##
-## @author Edouard DUPIN
-##
-## @copyright 2012, Edouard DUPIN, all right reserved
-##
-## @license APACHE v2.0 (see license file)
-##
-
-import lutinDebug as debug
-import lutinSystem
-import lutinTools as tools
-import os
-
-class System(lutinSystem.System):
-	def __init__(self):
-		lutinSystem.System.__init__(self)
-		# create some HELP:
-		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")
-
-

system/lutinSystem_Linux_alsa.py

@@ -1,29 +0,0 @@
-#!/usr/bin/python
-##
-## @author Edouard DUPIN
-##
-## @copyright 2012, Edouard DUPIN, all right reserved
-##
-## @license APACHE v2.0 (see license file)
-##
-
-import lutinDebug as debug
-import lutinSystem
-import lutinTools as tools
-import os
-
-class System(lutinSystem.System):
-	def __init__(self):
-		lutinSystem.System.__init__(self)
-		# create some HELP:
-		self.help="ALSA : Advanced Linux Sound Architecture\n Can be install with the package:\n    - libasound2-dev"
-		# check if the library exist:
-		if     not os.path.isfile("/usr/include/alsa/asoundlib.h") \
-		   and not os.path.isfile("/usr/include/dssi/alsa/asoundlib.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_LD("-lasound")
-
-