[RELEASE] release version 2.2.1

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

.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

README.rst

@@ -14,19 +14,6 @@ Release (master)
     :target: https://travis-ci.org/HeeroYui/lutin
 
 
-.. image:: http://atria-soft.com/ci/build/HeeroYui/lutin.svg?branch=master&tag=Linux
-    :target: http://atria-soft.com/ci/HeeroYui/lutin
-.. image:: http://atria-soft.com/ci/build/HeeroYui/lutin.svg?branch=master&tag=MacOs
-    :target: http://atria-soft.com/ci/HeeroYui/lutin
-.. image:: http://atria-soft.com/ci/build/HeeroYui/lutin.svg?branch=master&tag=Mingw
-    :target: http://atria-soft.com/ci/HeeroYui/lutin
-
-
-.. image:: http://atria-soft.com/ci/build/HeeroYui/lutin.svg?branch=master&tag=Android
-    :target: http://atria-soft.com/ci/HeeroYui/lutin
-.. image:: http://atria-soft.com/ci/build/HeeroYui/lutin.svg?branch=master&tag=IOs
-    :target: http://atria-soft.com/ci/HeeroYui/lutin
-
 
 Developement (dev)
 ------------------
@@ -35,20 +22,6 @@ Developement (dev)
     :target: https://travis-ci.org/HeeroYui/lutin
 
 
-.. image:: http://atria-soft.com/ci/build/HeeroYui/lutin.svg?branch=dev&tag=Linux
-    :target: http://atria-soft.com/ci/HeeroYui/lutin
-.. image:: http://atria-soft.com/ci/build/HeeroYui/lutin.svg?branch=dev&tag=MacOs
-    :target: http://atria-soft.com/ci/HeeroYui/lutin
-.. image:: http://atria-soft.com/ci/build/HeeroYui/lutin.svg?branch=dev&tag=Mingw
-    :target: http://atria-soft.com/ci/HeeroYui/lutin
-
-
-.. image:: http://atria-soft.com/ci/build/HeeroYui/lutin.svg?branch=dev&tag=Android
-    :target: http://atria-soft.com/ci/HeeroYui/lutin
-.. image:: http://atria-soft.com/ci/build/HeeroYui/lutin.svg?branch=dev&tag=IOs
-    :target: http://atria-soft.com/ci/HeeroYui/lutin
-
-
 Instructions
 ------------
 
@@ -70,7 +43,7 @@ http://github.com/HeeroYui/lutin/
 Documentation
 -------------
 
-http://github.io/HeeroYui/lutin/
+http://HeeroYui.github.io/lutin/
 
 Installation
 ------------

bin/lutin

@@ -25,31 +25,32 @@ import lutin.host as lutinHost
 import lutin.tools as lutinTools
 
 myArgs = arguments.LutinArg()
-myArgs.add(arguments.ArgDefine("h", "help", desc="Display this help"))
-myArgs.add(arguments.ArgDefine("H", "HELP", desc="Display this help (with all compleate information)"))
+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(arguments.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"))
-myArgs.add(arguments.ArgDefine("C", "color", desc="Display makefile output in color"))
-myArgs.add(arguments.ArgDefine("B", "force-build", desc="Force the rebuild without checking the dependency"))
-myArgs.add(arguments.ArgDefine("P", "pretty", desc="Print the debug has pretty display"))
-myArgs.add(arguments.ArgDefine("j", "jobs", haveParam=True, desc="Specifies the number of jobs (commands) to run simultaneously"))
-myArgs.add(arguments.ArgDefine("d", "depth", haveParam=True, desc="Depth of the search of sub element lutin_*.py (default=" + str(env.get_parse_depth()) + ")"))
-myArgs.add(arguments.ArgDefine("s", "force-strip", desc="Force the stripping of the compile elements"))
-myArgs.add(arguments.ArgDefine("o", "force-optimisation", desc="Force optimisation of the build"))
-myArgs.add(arguments.ArgDefine("w", "warning", desc="Store warning in a file build file"))
+myArgs.add("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(arguments.ArgDefine("t", "target", haveParam=True, desc="Select a target (by default the platform is the computer that compile this) To know list : 'lutin.py --list-target'"))
-myArgs.add(arguments.ArgDefine("c", "compilator", list=[["clang",""],["gcc",""]], desc="Compile with clang or Gcc mode (by default gcc will be used)"))
-myArgs.add(arguments.ArgDefine("", "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(arguments.ArgDefine("m", "mode", list=[["debug",""],["release",""]], desc="Compile in release or debug mode (default release)"))
-myArgs.add(arguments.ArgDefine("a", "arch", list=[["auto","Automatic choice"],["arm","Arm processer"],["x86","Generic PC : AMD/Intel"],["ppc","Power PC"]], desc="Architecture to compile"))
-myArgs.add(arguments.ArgDefine("b", "bus", list=[["auto","Automatic choice"],["32","32 bits"],["64","64 bits"]], desc="Adressing size (Bus size)"))
-myArgs.add(arguments.ArgDefine("p", "package", desc="Disable the package generation (usefull when just compile for test on linux ...)"))
-myArgs.add(arguments.ArgDefine("g", "gcov", desc="Enable code coverage intrusion in code"))
-myArgs.add(arguments.ArgDefine("", "simulation", desc="Simulater mode (availlable only for IOS)"))
-myArgs.add(arguments.ArgDefine("", "list-target", desc="List all availlables targets ==> for auto completion"))
-myArgs.add(arguments.ArgDefine("", "list-module", desc="List all availlables module ==> for auto completion"))
+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 " + lutinHost.HOST_DEFAULT_COMPILATOR + " 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()
@@ -237,6 +238,13 @@ def parseGenericArg(argument, active):
 			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:
@@ -262,34 +270,46 @@ if os.path.isfile(config_file) == True:
 	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)
 		
 	
 
@@ -303,7 +323,7 @@ lutin.init()
 #available target : Linux / MacOs / Windows / Android ...
 targetName = host.OS
 config = {
-	"compilator":"gcc",
+	"compilator":lutinHost.HOST_DEFAULT_COMPILATOR,
 	"mode":"release",
 	"bus-size":"auto",
 	"arch":"auto",
@@ -344,7 +364,7 @@ for argument in localArgument:
 			debug.debug("change target ==> '" + targetName + "' & reset mode : gcc&release")
 			#reset properties by defauult:
 			config = {
-			             "compilator":"gcc",
+			             "compilator":lutinHost.HOST_DEFAULT_COMPILATOR,
 			             "mode":"release",
 			             "bus-size":"auto",
 			             "arch":"auto",

doc/010_basic_concept.bb

@@ -1,59 +0,0 @@
-=?= [center]Basic concept[/center] =?=
-___________________________________________
-
-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 problesm. 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. In Pytho it is fast as Linux.
-
-Lutin is not based over an other builder, but request compilation 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 instalable.
-:** Library:
-:: This represent an element that is used by other application
-:** Package:
-:: To Be Define.
-
-
-===Target===
-
-
-
-===Builder===
-
-
-===System===
-
-
-

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.bb

@@ -1,153 +0,0 @@
-=?= [center]Basic concept[/center] =?=
-___________________________________________
-
-Lutin permit simply to compile applications and library.
-
-To simply understand the use, we will use a simple library:
-
-[code style=bash]
-	git clone http://github.con/atria-soft/etk.git
-[/code]
-
-etk is a basic library that have drive the lutin project.
-
-
-== compile a module ==
-
-It is really simple:
-
-[code style=bash]
-	lutin yourModuleName
-	#example:
-	lutin etk
-[/code]
-
-
-
-== Option working ==
-
-Lutin have a complex option methodologie. We can consider 3 part of the option:
-:** Global option
-:** target option
-:** modules
-
-
-
-
-== Generic options ==
-
-=== Display help ===
-
-Availlable everywhere ...
-
-[code style=bash]
-	lutin -h
-	lutin --help
-[/code]
-
-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 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 ===
-
-[code style=bash]
-	lutin -C
-	lutin --color
-[/code]
-
-=== Display build line in pretty print mode ===
-
-when an error apear, the gcc or clang compile line can be really unreadable:
-[code]
-	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
-[/code]
-
-whith this option you can transform this not obvious line in a readable line:
-
-[code style=bash]
-	lutin -P
-	lutin --pretty
-[/code]
-
-result:
-[code]
-	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
-[/code]
-
-=== lutin log ===
-
-Lutin have an internal log system. To enable or disable it just select your debug level with the option:
-
-[code style=bash]
-	lutin -v4
-	lutin --verbose 4
-[/code]
-
-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 ===
-
-By default lutin manage only 1 CPU core (faster to debug) but for speed requirement you can use use multiple core:
-
-[code style=bash]
-	#for 5 core
-	lutin -j5
-	lutin --jobs 5
-[/code]
-
-=== Force rebuild all ===
-
-Sometime it is needed to rebuild all the program, just do :
-
-[code style=bash]
-	lutin -B
-	lutin --force-build
-[/code]
-
-=== Force rebuild all ===
-
-Force strip of output binary (remove symboles)
-
-[code style=bash]
-	lutin -s
-	lutin --force-strip
-[/code]
-
-
-
-		-w / --warning
-			Store warning in a file build file

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:
+
+```{.sh}
+	git clone http://github.con/atria-soft/etk.git
+```
+
+
+compile a module:                               {#lutin_use_compile}
+=================
+
+It is really simple:
+
+```{.sh}
+	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 ...
+
+```{.sh}
+	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}
+---------------
+
+```{.sh}
+	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:
+```{.sh}
+	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:
+
+```{.sh}
+	lutin -P
+	lutin --pretty
+```
+
+result:
+```{.sh}
+	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:
+
+```{.sh}
+	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:
+
+```{.sh}
+	#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:
+
+```{.sh}
+	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)
+
+```{.sh}
+	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:
+
+```{.sh}
+	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
+
+```{.sh}
+	lutin -m debug your-module
+	lutin -m release your-module
+```
+
+You can desire to have compilation optimisation when you build in debug mode:
+
+```{.sh}
+	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:
+
+```{.sh}
+	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,502 @@
+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:
+
+```{.sh}
+	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:
+
+```{.py}
+#!/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] my_module Module handle that migh be configured
+# @return True The module is welled configure
+# @return False The module is Not availlable (for this target or ...)
+def configure(target, my_module):
+	...
+	return True
+```
+
+Thes it is simple to specify build for:
+
+Create a new Module (LIBRARY):                               {#lutin_module_library}
+==============================
+
+What to change:
+```{.py}
+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:
+```{.py}
+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:
+```{.py}
+def get_type():
+	return "BINARY"
+
+def get_sub_type():
+	return "TEST"
+```
+or:
+```{.py}
+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:
+```{.py}
+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)
+
+```{.py}
+def configure(target, my_module):
+	...
+	
+	# 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:
+```{.py}
+def configure(target, my_module):
+	...
+	
+	my_module.add_header_file([
+	    'module-name/file1.h',
+	    'module-name/file2.h'
+	    ])
+	
+	...
+```
+
+You can add a path to your local include:
+```{.py}
+def configure(target, my_module):
+	...
+	
+	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:
+```{.py}
+def configure(target, my_module):
+	...
+	
+	# add dependency of the generic C library:
+	my_module.add_depend('c')
+	# add dependency of the generic C++ library:
+	my_module.add_depend('cxx')
+	# add dependency of the generic math library:
+	my_module.add_depend('m')
+	# or other user lib:
+	my_module.add_depend('lib-name')
+	
+	...
+```
+
+The system can have optinnal sub-library, then if you just want to add an optionnal dependency:
+```{.py}
+def configure(target, my_module):
+	...
+	
+	# Add an optionnal dependency (set flag in CPP build if the subLib exist) ==> flag is locally set
+	my_module.add_optionnal_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_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):
+```{.py}
+def configure(target, my_module):
+	...
+	# 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:
+```{.py}
+def configure(target, my_module):
+	...
+	
+	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:
+
+```{.py}
+def configure(target, my_module):
+	...
+	
+	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:
+
+```{.py}
+def configure(target, my_module):
+	...
+	
+	# copy file in the share/binanyName/ path (no sub path)
+	my_module.copy_path('data/icon.svg')
+	
+	...
+```
+
+Copy multiple files (change path)
+
+```{.py}
+def configure(target, my_module):
+	...
+	
+	my_module.copy_path('data/*', 'destinationPath')
+	
+	...
+```
+
+display some debug to help writing code:                       {#lutin_module_internal_write_log}
+----------------------------------------
+
+
+```{.py}
+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:
+```{.sh}
+	lutin_module-name.py
+```
+
+With:
+```{.py}
+#!/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>"]
+	# return "authors.txt"
+
+# Version of the library
+# Note: this fucntion is optionnal.
+def get_version():
+	return [0,1,"dev"]
+	# return "version.txt"
+
+# create the module
+# @param[in] target reference on the Target that is currently build
+# @param[in] my_module Module handle that migh be configured
+# @return True The module is welled configure
+# @return False The module is Not availlable (for this target or ...)
+def configure(target, my_module):
+	
+	# 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_depend('c')
+	# add dependency of the generic C++ library:
+	my_module.add_depend('cxx')
+	# add dependency of the generic math library:
+	my_module.add_depend('m')
+	# or other user lib:
+	my_module.add_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_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_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_flag('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 True if the module is compatible with the target or ...
+	return True
+```
+
+
+**Index:**
+  - @ref mainpage
+  - @ref lutin_concept
+  - @ref lutin_use
+  - @ref lutin_module
+

doc/100_Use_on_Ios.md

@@ -0,0 +1,112 @@
+Build and deploy for IOS                               {#lutin_ios}
+========================
+
+@tableofcontents
+
+Deploy on IOs is a little complicated, due to the fact Apple demand a developper licence.
+
+To deploy you need to buy a [developper licence](https://developer.apple.com/account) nearly 99€ / year
+
+Step 1: deploy your application with Xcode             {#lutin_ios_xcode}
+==========================================
+
+it can be conplicated to do the first deploy (register tablette:watch ... or user ...) 
+Then the best way is now to create your first game sample application with XCode and deploy it on your device ...
+
+
+when all your problem are solved, I can help you...
+
+**Note:**
+
+```
+	To add a device, in xcode select your top project, and in the section "signing" select "automatic manage signing", select your team and activate your device ...
+```
+
+
+step 2: Build for IOs                                  {#lutin_ios_build}
+=====================
+
+This step is simpliest... All is integrated:
+
+Select the target IOs
+
+```{.sh}
+	lutin -C -D -tIOs yourApplication?build
+```
+
+This is done .... now deploy ...
+
+
+
+step 3: Deploy                                  {#lutin_ios_deploy}
+==============
+
+Do it ... it does not work ...
+
+```{.sh}
+	lutin -C -D -tIOs yourApplication?install
+```
+
+Appliocation ID
+---------------
+
+It miss some things to do:
+
+create a reference of you application in [apple interface](https://developer.apple.com/account/ios/identifier/bundle/create)
+
+
+your application id is: 
+
+```{.py}
+	get_compagny_type() + "." + get_compagny_name() + "." + module.get_name()
+```
+
+For example if you module is named: ```lutin_application.py```
+
+And you set description:
+
+```{.py}
+def get_compagny_type():
+	return "com"
+
+def get_compagny_name():
+	return "compagny NAME"
+
+```
+
+your id is: ```com.compagnyname.application```
+
+
+When you have create the application, it will generate for you a unique ID, you can see it on the webpage, it is like: ```DFGDSFGSDFGS.com.compagnyname.application```
+
+In your module definition you need to add:
+```{.py}
+my_module.set_pkg("APPLE_APPLICATION_IOS_ID", "DFGDSFGSDFGS");
+```
+
+Team signing ID
+---------------
+
+the second point to do is creating the file: ```.iosKey.txt``` in you root path of your workspace (where you execute lutin)
+
+it will contain sothing like: 
+```
+'iPhone Developer: Francis DUGENOUX (YRRQE5KGTH)'
+
+```
+
+you can optain it with executing:
+```{.sh}
+certtool y | grep "Developer"
+```
+
+
+
+Install:
+--------
+
+Now it works ...
+
+```{.sh}
+	lutin -C -D -tIOs yourApplication?build
+```

doc/index.bb

@@ -1,100 +0,0 @@
-=?= [center]Lutin Build system[/center] =?=
-___________________________________________
-
-===What is Lutin, and how can I use it?===
-
-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 [b]workspace build[/b] (in oposition of CMake/make/...)
-
-
-=== Install: ===
-
-Requirements: ``Python >= 2.7`` and ``pip``
-
-==== Install lutin: ===
-Just run:
-[code style=bash]
-	pip install lutin
-[/code]
-
-==== Install pip ====
-Install pip on debian/ubuntu:
-[code style=bash]
-	sudo apt-get install pip
-[/code]
-
-Install pip on ARCH-linux:
-[code style=bash]
-	sudo pacman -S pip
-[/code]
-
-Install pip on MacOs:
-[code style=bash]
-	sudo easy_install pip
-[/code]
-
-==== Install from sources ====
-
-[code style=bash]
-	git clone http://github.com/HeeroYui/lutin.git
-	cd lutin
-	sudo ./setup.py install
-[/code]
-
-=== 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.
-
-
-=== 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.
-
-[tutorial[000_Build | Tutorials]]

doc/mainpage.md

@@ -0,0 +1,144 @@
+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:
+```{.sh}
+	pip install lutin
+```
+
+Install pip:
+------------
+
+Install pip on debian/ubuntu:
+```{.sh}
+	sudo apt-get install pip
+```
+
+Install pip on ARCH-linux:
+```{.sh}
+	sudo pacman -S pip
+```
+
+Install pip on MacOs:
+```{.sh}
+	sudo easy_install pip
+```
+
+Install from sources:
+---------------------
+
+```{.sh}
+	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
+  - @ref lutin_ios
+
+
+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.
+
+
+[link macos account developper](https://developer.apple.com/library/content/documentation/IDEs/Conceptual/AppStoreDistributionTutorial/AddingYourAccounttoXcode/AddingYourAccounttoXcode.html)

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,2,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/arg.py

@@ -8,30 +8,63 @@
 ## @license APACHE v2.0 (see license file)
 ##
 import sys
-# Local import
 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:
+		if len(self.arg) == 0:
 			debug.info("option : " + self.option)
-		elif len(self.option)==0:
+		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
@@ -50,18 +83,46 @@ class ArgDefine:
 				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
@@ -70,6 +131,10 @@ class ArgDefine:
 				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 != "":
@@ -98,46 +163,94 @@ class ArgDefine:
 						tmpElementPrint += " / "
 					tmpElementPrint += val
 				print("				{ " + tmpElementPrint + " }")
-	
-	def parse(self, argList, currentID):
-		return currentID;
 
 
+##
+## @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)
-	
-	def parse(self, argList, currentID):
-		return currentID;
 
 
+##
+## @brief Class to define the agmument list availlable for a program
+##
 class LutinArg:
+	##
+	## @brief Constructor.
+	## @param[in] self Class handle
+	##
 	def __init__(self):
-		self.listProperties = []
+		self.list_properties = []
 	
-	def add(self, argument):
-		self.listProperties.append(argument) #ArgDefine(smallOption, bigOption, haveParameter, parameterList, description));
+	##
+	## @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.listProperties.append(ArgSection(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
@@ -159,7 +272,7 @@ class LutinArg:
 			argumentFound=False;
 			if option[:2]=="--":
 				# big argument
-				for prop in self.listProperties:
+				for prop in self.list_properties:
 					if prop.get_option_big()=="":
 						continue
 					if prop.get_option_big() == option[2:]:
@@ -201,7 +314,7 @@ class LutinArg:
 					debug.error("UNKNOW argument : '" + argument + "'")
 			elif option[:1]=="-":
 				# small argument
-				for prop in self.listProperties:
+				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())]:
@@ -250,13 +363,16 @@ class LutinArg:
 		#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.listProperties :
+		for element in self.list_properties :
 			listOfPropertiesArg += element.get_porperties()
 		print("	" + sys.argv[0] + listOfPropertiesArg + " ...")
-		for element in self.listProperties :
-			element.display()
+		for element in self.list_properties :
+			element.display()
+

lutin/builder.py

@@ -27,7 +27,10 @@ from . import env
 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()
@@ -57,7 +60,10 @@ def import_path(path_list):
 	for elem in builder_list:
 		debug.verbose("    " + str(elem["name"]))
 
-# we must have call all import before ...
+
+##
+## @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 ...')
@@ -65,6 +71,10 @@ def init():
 		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:
@@ -75,13 +85,16 @@ def get_builder(input_type):
 	debug.error("Can not find builder for type : '" + str(input_type) + "'")
 	raise ValueError('type error :' + str(input_type))
 
-
-def get_builder_with_output(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 input_type in element["element"].get_output_type():
+			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(input_type) + "'")
-	raise ValueError('type error :' + str(input_type))
+	debug.error("Can not find builder for type : '" + str(output_type) + "'")
+	raise ValueError('type error :' + str(output_type))

lutin/debug.py

@@ -26,15 +26,33 @@ 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
@@ -53,6 +71,9 @@ def enable_color():
 	global color_cyan
 	color_cyan   = "\033[36m"
 
+##
+## @brief Disable color of the console Log system
+##
 def disable_color():
 	global debug_color
 	debug_color = True
@@ -71,6 +92,11 @@ def disable_color():
 	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
@@ -80,6 +106,11 @@ def extreme_verbose(input, force=False):
 		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
@@ -89,6 +120,11 @@ def verbose(input, force=False):
 		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
@@ -98,6 +134,11 @@ def debug(input, force=False):
 		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
@@ -107,6 +148,11 @@ def info(input, force=False):
 		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
@@ -116,6 +162,11 @@ def warning(input, force=False):
 		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
@@ -125,6 +176,13 @@ def todo(input, force=False):
 		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
@@ -142,6 +200,15 @@ def error(input, thread_id=-1, force=False, crash=True):
 		#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
@@ -151,23 +218,31 @@ def print_element(type, lib, dir, name, force=False):
 		print(color_cyan + type + color_default + " : " + color_yellow + lib + color_default + " " + dir + " " + color_blue + name + color_default)
 		debug_lock.release()
 
-def print_compilator(myString):
+##
+## @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:
-		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)
+		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(myString)
+	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

lutin/depend.py

@@ -41,6 +41,11 @@ def _file_read_data(path, binary=False):
 	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:
@@ -48,6 +53,16 @@ def create_dependency_file(depend_file, list_files):
 	_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) + "'")
@@ -142,7 +157,7 @@ def need_re_build(dst, src, depend_file=None, file_cmd="", cmd_line="", force_id
 		file.close()
 	# check the 2 files are identical:
 	if force_identical == True:
-		# check if the 2 cmd_line are similar :
+		# check if the 2 cmd_line are similar:
 		size_src = _file_size(src)
 		size_dst = _file_size(dst)
 		if size_src != size_dst:
@@ -157,8 +172,15 @@ def need_re_build(dst, src, depend_file=None, file_cmd="", cmd_line="", force_id
 	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) + "'")

lutin/env.py

@@ -39,6 +39,19 @@ 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):

lutin/heritage.py

@@ -16,12 +16,12 @@ from . import debug
 def append_to_list(list_out, elem):
 	if type(elem) == str:
 		if elem not in list_out:
-			list_out.append(elem)
+			list_out.append(copy.deepcopy(elem))
 	else:
 		# mulyiple imput in the list ...
 		for element in elem:
 			if element not in list_out:
-				list_out.append(element)
+				list_out.append(copy.deepcopy(element))
 
 
 
@@ -61,6 +61,7 @@ class HeritageList:
 		self.regenerate_tree()
 	
 	def regenerate_tree(self):
+		debug.verbose("Regenerate heritage list:")
 		self.flags = {}
 		# sources list:
 		self.src = { 'src':[],
@@ -72,30 +73,37 @@ class HeritageList:
 		listHeritage = self.list_heritage
 		self.list_heritage = []
 		# first step : add all lib with no dependency:
+		debug.extreme_verbose("    add element with no dependency:")
 		for herit in listHeritage:
 			if len(herit.depends) == 0:
-				self.list_heritage.append(herit)
+				debug.extreme_verbose("        add: " + str(herit.name))
+				self.list_heritage.append(copy.deepcopy(herit))
 				listHeritage.remove(herit)
+		debug.extreme_verbose("    add element with dependency:")
 		while len(listHeritage) > 0:
 			currentHeritageSize = len(listHeritage)
-			debug.verbose("list heritage = " + str([[x.name, x.depends] for x in listHeritage]))
+			debug.verbose("        list heritage = " + str([[x.name, x.depends] for x in listHeritage]))
+			debug.extreme_verbose("        list heritage (rest):")
+			for tmppp_herit in listHeritage:
+				debug.extreme_verbose("            elem= " + str(tmppp_herit.name) + " : " + str(tmppp_herit.depends))
 			# Add element only when all dependence are resolved
 			for herit in listHeritage:
 				listDependsName = [y.name for y in self.list_heritage]
 				if all(x in listDependsName for x in herit.depends) == True:
+					debug.extreme_verbose("        add: " + str(herit.name))
 					listHeritage.remove(herit)
-					self.list_heritage.append(herit)
+					self.list_heritage.append(copy.deepcopy(herit))
 			if currentHeritageSize == len(listHeritage):
 				debug.warning("Not resolve dependency between the library ==> can be a cyclic dependency !!!")
 				for herit in listHeritage:
-					self.list_heritage.append(herit)
+					self.list_heritage.append(copy.deepcopy(herit))
 				listHeritage = []
 				debug.warning("new heritage list:")
 				for element in self.list_heritage:
 					debug.warning("	" + element.name + " " + str(element.depends))
-		debug.verbose("new heritage list:")
+		debug.extreme_verbose("new heritage list:")
 		for element in self.list_heritage:
-			debug.verbose("	" + element.name + " " + str(element.depends))
+			debug.extreme_verbose("	" + element.name + " " + str(element.depends))
 		for element in reversed(self.list_heritage):
 			for flags in element.flags:
 				# get value
@@ -122,16 +130,32 @@ class HeritageList:
 						# keep only true, if false ==> bad case ...
 						if self.flags[flags] < value:
 							self.flags[flags] = value
+			append_to_list(self.src['src'], element.src['src'])
+			append_to_list(self.src['dynamic'], element.src['dynamic'])
+			append_to_list(self.src['static'], element.src['static'])
+		for element in self.list_heritage:
+			debug.extreme_verbose("    elem: " + str(element.name))
+			debug.extreme_verbose("    Path (base): " + str(self.path))
+			debug.extreme_verbose("         inside: " + str(element.path))
 			for ppp in element.path:
-				value = element.path[ppp]
+				value = copy.deepcopy(element.path[ppp])
 				if ppp not in self.path:
 					self.path[ppp] = value
 				else:
 					append_to_list(self.path[ppp], value)
-			append_to_list(self.src['src'], element.src['src'])
-			append_to_list(self.src['dynamic'], element.src['dynamic'])
-			append_to_list(self.src['static'], element.src['static'])
+			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) + "}"
 
@@ -150,19 +174,19 @@ class heritage:
 		self.path = {}
 		self.include = ""
 		# update is set at true when data are newly created ==> force upper element to update
-		self.hasBeenUpdated=False
+		self.has_been_updated=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.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"]
-			self.path = module.path["export"]
+			self.flags = module._flags["export"] # have no deep copy here is a feature ...
+			self.path = copy.deepcopy(module._path["export"])
 			# if the user install some header ==> they will ba autoamaticaly exported ...
 			if target != None:
-				if len(module.header) > 0:
-					self.include = target.get_build_path_include(module.name)
+				if len(module._header) > 0:
+					self.include = target.get_build_path_include(module.get_name())
 	
 	def add_depends(self, elements):
 		self.depends.append(elements)
@@ -199,18 +223,18 @@ class heritage:
 			self.path['c'].append(self.include)
 	
 	def need_update(self, list):
-		self.hasBeenUpdated=True
+		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.hasBeenUpdated == True:
-			self.hasBeenUpdated = True
+		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] = value
+				self.flags[flags] = copy.deepcopy(value)
 			else:
 				append_to_list(self.flags[flags], value)
 		self.add_import_path(other.path)
@@ -228,6 +252,11 @@ class heritage:
 					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

@@ -15,10 +15,13 @@ from . import debug
 # print os.name # ==> 'posix'
 if platform.system() == "Linux":
 	OS = "Linux"
+	HOST_DEFAULT_COMPILATOR = "gcc"
 elif platform.system() == "Windows":
 	OS = "Windows"
+	HOST_DEFAULT_COMPILATOR = "gcc"
 elif platform.system() == "Darwin":
 	OS = "MacOs"
+	HOST_DEFAULT_COMPILATOR = "clang"
 else:
 	debug.error("Unknow the Host OS ... '" + platform.system() + "'")
 

lutin/image.py

@@ -25,12 +25,25 @@ except:
 	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

lutin/multiprocess.py

@@ -55,8 +55,9 @@ def run_command_no_lock_out(cmd_line):
 		p = subprocess.Popen(args)
 	except subprocess.CalledProcessError as e:
 		debug.error("subprocess.CalledProcessError : " + str(args))
-	except:
-		debug.error("Exception on : " + str(args))
+		return
+	#except:
+	#	debug.error("Exception on : " + str(args))
 	# launch the subprocess:
 	p.communicate()
 

lutin/system.py

@@ -18,70 +18,191 @@ 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._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
 	
-	def add_export_sources(self, list):
-		tools.list_append_to(self.export_src, list)
+	##
+	## @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_export_path(self, list):
-		tools.list_append_to(self.export_path, list)
+	def add_path(self, list):
+		tools.list_append_to(self._export_path, list)
 	
-	def add_module_depend(self, list):
-		tools.list_append_to(self.export_depends, list, True)
+	##
+	## @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)
 	
-	def add_export_flag(self, type, list):
-		tools.list_append_to_2(self.export_flags, type, list)
+	##
+	## @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_add_src_filestate:
-			self.action_on_state[name_of_state] = [[level, name, action]]
+		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])
+			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}"
-
-
-
-def create_module_from_system(target, dict):
-	myModule = module.Module(dict["path"], dict["name"], 'PREBUILD')
-	# add element flags to export
-	for elem in dict["system"].export_flags:
-		debug.verbose("add element :" + str(elem) + " elems=" + str(dict["system"].export_flags[elem]))
-		myModule.add_export_flag(elem, dict["system"].export_flags[elem])
-	# add module dependency
-	myModule.add_module_depend(dict["system"].export_depends)
-	# add exporting sources
-	myModule.add_src_file(dict["system"].export_src)
-	# add export path
-	myModule.add_export_path(dict["system"].export_path)
-	# Export all actions ...
-	for elem in dict["system"].action_on_state:
-		level, name, action = dict["system"].action_on_state[elem]
-		target.add_action(elem, level, name, action)
 	
-	return myModule
+	##
+	## @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
+		if self._export_depends != []:
+			module.add_depend(self._export_depends)
+		# add exporting sources
+		if self._export_src != []:
+			module.add_src_file(self._export_src)
+		# add export path
+		if self._export_path != []:
+			# no control on API
+			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={}
+__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 __system_list
 	global_base = env.get_build_system_base_name()
 	debug.debug("SYSTEM: Init with Files list:")
 	for elem in path_list:
@@ -100,69 +221,100 @@ def import_path(path_list):
 		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,
+		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})
-		else:
-			system_list[system_type] = [{"name":system_name,
-			                           "path":elem,
-			                           "system":None,
-			                           "loaded":False,
-			                           "exist":False,
-			                           "module":None}]
+			                               "module":None}]
 	debug.verbose("New list system: ")
-	for elem in system_list:
+	for elem in __system_list:
 		debug.verbose("    " + str(elem))
-		for val in system_list[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:
+	global __system_list
+	for elementName in __system_list:
 		debug.info("SYSTEM:     Integrate system: '" + elementName +"'")
-		for data in system_list[elementName]:
+		for data in __system_list[elementName]:
 			debug.info("SYSTEM:    '" + data["name"] +"' in " + data["path"])
 
-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:
+##
+## @brief Check if a system Module is availlable for a specific target
+## @param[in] lib_name (string) Name of the Library
+## @param[in] list_target_name ([string,...]) list of name of the target (ordered by request order)
+## @param[in] target (handle) Handle on the @ref Target build engine
+## @return (bool) find the system lib or not
+##
+def exist(lib_name, list_target_name, target) :
+	global __system_list
+	debug.verbose("exist= " + lib_name + " in " + str(list_target_name))
+	find_target = False
+	for target_name in list_target_name:
+		if target_name in __system_list:
+			find_target = True
+	if find_target == False:
 		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"] + "'")
-				theSystem = __import__(env.get_build_system_base_name() + __start_system_name + target_name + "_" + data["name"])
-				#create the system module
-				try:
-					debug.verbose("SYSTEM: request: " + data["name"])
-					data["system"] = theSystem.System(target)
-					data["exist"] = data["system"].valid
-				except:
-					debug.warning("Not find: '" + data["name"] + "' ==> get exception")
-			return data["exist"]
+	for target_name in reversed(list_target_name):
+		if target_name not in __system_list:
+			continue
+		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
 
-def load(target, lib_name, target_name):
-	global system_list
-	if target_name not in system_list:
+##
+## @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] list_target_name ([string,...]) list of name of the target (ordered by request order)
+## @return None
+##
+def load(target, lib_name, list_target_name):
+	global __system_list
+	find_target = False
+	for target_name in list_target_name:
+		if target_name in __system_list:
+			find_target = True
+	if find_target == False:
 		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
+		return
+	for target_name in reversed(list_target_name):
+		if target_name not in __system_list:
+			continue
+		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/target.py

@@ -21,19 +21,27 @@ from . import module
 from . import system
 from . import multiprocess
 from . import env
-
+##
+## @brief Target class represent the buyild environement for a specific platform like Linux, or Android ....
+##
 class Target:
+	##
+	## @brief contructor
+	## @param[in] name ([string,...]) Name of the target
+	## @param[in] config (dict) User configuration
+	## @param[in] arch (string) specific parameter for gcc -arch element
+	##
 	def __init__(self, name, config, arch):
+		if tools.get_type_string(name) != "list":
+			debug.error("You must define a name in a list ...")
+		if len(name) < 1:
+			debug.error("You must define a name for your target ...")
+		## configuration of the build
 		self.config = config
 		
-		#processor type selection (auto/arm/ppc/x86)
-		self.select_arch = config["arch"]; # TODO : Remove THIS ...
-		#bus size selection (auto/32/64)
-		self.select_bus = config["bus-size"]; # TODO : Remove THIS ...
-		
-		if config["bus-size"] == "auto":
+		if self.config["bus-size"] == "auto":
 			debug.error("system error ==> must generate the default 'bus-size' config")
-		if config["arch"] == "auto":
+		if self.config["arch"] == "auto":
 			debug.error("system error ==> must generate the default 'bus-size' config")
 		
 		debug.debug("config=" + str(config))
@@ -42,13 +50,13 @@ class Target:
 		else:
 			self.arch = ""
 		
-		# todo : remove this :
-		self.sumulator = config["simulation"]
-		self.name = name
-		self.config_based_on = name
 		self.end_generate_package = config["generate-package"]
+		# todo : remove this :
+		self._name = name[-1]
+		self._config_based_on = name
 		debug.info("=================================");
-		debug.info("== Target='" + self.name + "' " + config["bus-size"] + " bits for arch '" + config["arch"] + "'");
+		debug.info("== Target='" + self._name + "' " + self.config["bus-size"] + " bits for arch '" + self.config["arch"] + "'");
+		debug.info("== Target list=" + str(self._config_based_on))
 		debug.info("=================================");
 		
 		self.set_cross_base()
@@ -57,28 +65,11 @@ class Target:
 		# Target global variables.
 		###############################################################################
 		self.global_include_cc=[]
-		"""
-		self.global_flags_cc=['-D__TARGET_OS__'+self.name,
-		                      '-D__TARGET_ARCH__'+self.select_arch,
-		                      '-D__TARGET_ADDR__'+self.select_bus + 'BITS',
-		                      '-D_REENTRANT']
-		self.global_flags_xx=[]
-		self.global_flags_mm=[]
-		if self.name == "Windows":
-			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_flags={}
 		
 		self.global_libs_ld=[]
 		self.global_libs_ld_shared=[]
 		
-		self.global_sysroot=""
-		
 		self.suffix_cmd_line='.cmd'
 		self.suffix_warning='.warning'
 		self.suffix_dependence='.d'
@@ -90,20 +81,24 @@ class Target:
 		self.suffix_package='.deb'
 		
 		self.path_generate_code="/generate_header"
-		self.path_arch="/" + self.name
+		self.path_arch = "/" + self._name
 		
+		for elem in self._config_based_on:
+			self.add_flag("c", '-D__TARGET_OS__' + elem)
 		self.add_flag("c", [
-		    '-D__TARGET_OS__' + self.name,
-		    '-D__TARGET_ARCH__' + self.select_arch,
-		    '-D__TARGET_ADDR__' + self.select_bus + 'BITS',
+		    '-D__TARGET_ARCH__' + self.config["arch"],
+		    '-D__TARGET_ADDR__' + self.config["bus-size"] + 'BITS',
 		    '-D_REENTRANT'
 		    ])
+		self.add_flag("c", "-nodefaultlibs")
 		self.add_flag("c++", "-nostdlib")
 		self.add_flag("ar", 'rcs')
 		
-		if self.name == "Windows":
-			self.add_flag("c++", ['-static-libgcc', '-static-libstdc++'])
-		
+		if self._name == "Windows":
+			self.add_flag("c++", [
+			    '-static-libgcc',
+			    '-static-libstdc++'
+			    ])
 		if "debug" == self.config["mode"]:
 			self.add_flag("c", [
 			    "-g",
@@ -138,12 +133,13 @@ class Target:
 				    "--coverage"
 				    ])
 		
-		self.update_path_tree()
+		self._update_path_tree()
 		self.path_bin="bin"
 		self.path_lib="lib"
 		self.path_data="share"
 		self.path_doc="doc"
 		self.path_include="include"
+		self.path_temporary_generate="generate"
 		self.path_object="obj"
 		
 		
@@ -168,18 +164,106 @@ class Target:
 		# special case for IOS (example) no build dynamicly ...
 		self.support_dynamic_link = True
 	
+	##
+	## @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.Target}"
 	
-	def add_flag(self, type, list):
-		tools.list_append_to_2(self.global_flags, type, list)
+	##
+	## @brief Get the type of the target: ["Linux, ...]
+	## @param[in] self (handle) Class handle
+	## @return ([string,...]) The current target name and other sub name type (ubuntu ...)
+	##
+	def get_type(self):
+		return self._config_based_on
 	
-	def update_path_tree(self):
-		self.path_out = os.path.join("out", self.name + "_" + self.config["arch"] + "_" + self.config["bus-size"], self.config["mode"])
+	##
+	## @brief Add a type that the model is based on
+	## @param[in] self (handle) Class handle
+	## @param[in] name (string) Name of that the element is based on ...
+	##
+	def add_type(self, name):
+		self._config_based_on.append(name)
+	
+	##
+	## @brief Get the name of the target: Linux, Windows, ...
+	## @param[in] self (handle) Class handle
+	## @return (string) Name of the target
+	##
+	def get_name(self):
+		return self._name
+	
+	##
+	## @brief Get build mode of the target: ["debug", "release"]
+	## @param[in] self (handle) Class handle
+	## @return (string) The current target build mode.
+	##
+	def get_mode(self):
+		return self.config["mode"]
+	
+	##
+	## @brief Get build for a simulator (Ios and Android for example)
+	## @param[in] self (handle) Class handle
+	## @return (bool) sumulation requested
+	##
+	def get_simulation(self):
+		return self.config["simulation"]
+	
+	##
+	## @brief Get compilator name (clang / gcc)
+	## @param[in] self (handle) Class handle
+	## @return (bool) name of the compilator requested
+	##
+	def get_compilator(self):
+		return self.config["compilator"]
+	
+	##
+	## @brief Get architecture name (x86 / arm / ...)
+	## @param[in] self (handle) Class handle
+	## @return (bool) name of the arch requested
+	##
+	def get_arch(self):
+		return self.config["arch"]
+	##
+	## @brief Get architecture name (x86 / arm / ...)
+	## @param[in] self (handle) Class handle
+	## @return (bool) name of the arch requested
+	##
+	def get_bus_size(self):
+		return self.config["bus-size"]
+	
+	##
+	## @brief Add global target flags
+	## @param[in] self (handle) Class handle
+	## @param[in] type (string) inclusion group name 'c', 'c++', 'java' ...
+	## @param[in] in_list ([string,...] or string) List of path to include
+	## @return None
+	##
+	def add_flag(self, in_type, in_list):
+		tools.list_append_to_2(self.global_flags, in_type, in_list)
+	
+	##
+	## @brief Update basic tree path positions on the build tree
+	## @param[in] self (handle) Class handle
+	## @return None
+	##
+	def _update_path_tree(self):
+		self.path_out = os.path.join("out", self._name + "_" + self.config["arch"] + "_" + self.config["bus-size"], self.config["mode"])
 		self.path_final = os.path.join("final", self.config["compilator"])
 		self.path_staging = os.path.join("staging", self.config["compilator"])
+		self.path_staging_tmp = os.path.join("staging_tmp", self.config["compilator"])
 		self.path_build = os.path.join("build", self.config["compilator"])
 	
+	# TODO: Remove this from here ==> this is a tools
+	##
+	## @brief create a string version number with the associated list values
+	## @param[in] self (handle) Class handle
+	## @param[in] data ([int|string,...]) version basic number
+	## @return (string) version number
+	##
 	def create_number_from_version_string(self, data):
 		tmp_data = data.split("-")
 		if len(tmp_data) > 1:
@@ -199,6 +283,12 @@ class Target:
 			offset /= 1000
 		return out
 	
+	##
+	## @brief Configure the cross toolchain
+	## @param[in] self (handle) Class handle
+	## @param[in] cross (string) Path of the cross toolchain
+	## @return None
+	##
 	def set_cross_base(self, cross=""):
 		self.cross = cross
 		debug.debug("== Target='" + self.cross + "'");
@@ -232,7 +322,7 @@ class Target:
 		self.nm = self.cross + "nm"
 		self.strip = self.cross + "strip"
 		self.dlltool = self.cross + "dlltool"
-		self.update_path_tree()
+		self._update_path_tree()
 		
 		#some static libraries that is sometime needed when not use stdlib ...
 		ret = multiprocess.run_command_direct(self.xx + " -print-file-name=libgcc.a");
@@ -244,13 +334,14 @@ class Target:
 			debug.error("Can not get the g++/clang++ libsupc++.a ...")
 		self.stdlib_name_libsupc = ret;
 	
+	##
+	## @brief Get the current build mode
+	## @param[in] self (handle) Class handle
+	## @return Build mode value [debug,release]
+	##
 	def get_build_mode(self):
 		return self.config["mode"]
 	
-	def clean_module_tree(self):
-		self.build_tree_done = []
-		self.list_final_file = []
-	
 	def get_full_name_source(self, basePath, file):
 		if file[0] == '/':
 			if tools.os.path.isfile(file):
@@ -286,117 +377,156 @@ class Target:
 	def get_full_dependency(self, module_name, basePath, file):
 		return self.get_build_path_object(module_name) + "/" + file + self.suffix_dependence
 	
-	"""
-		return a list of 3 elements :
-			0 : sources files (can be a list)
-			1 : destination file
-			2 : dependence files module (*.d)
-	"""
-	# TODO : Remove this it is urgent ...
-	def generate_file(self,
-	                  binary_name,
-	                  module_name,
-	                  basePath,
-	                  file,
-	                  type):
-		#debug.warning("genrate_file(" + str(binary_name) + "," + str(module_name) + "," + str(basePath) + "," + str(file) + "," + str(type) + ")")
-		list=[]
-		if (type=="bin"):
-			list.append(file)
-			list.append(self.get_build_file_bin(binary_name))
-			list.append(os.path.join(self.get_build_path(module_name), module_name + self.suffix_dependence))
-			list.append(self.get_build_file_bin(binary_name) + self.suffix_cmd_line)
-			list.append(self.get_build_file_bin(binary_name) + self.suffix_warning)
-		elif (type=="lib-shared"):
-			list.append(file)
-			list.append(self.get_build_file_dynamic(module_name))
-			list.append(os.path.join(self.get_build_path(module_name), self.path_lib, module_name + self.suffix_dependence))
-			list.append(self.get_build_file_dynamic(module_name) + self.suffix_cmd_line)
-			list.append(self.get_build_file_dynamic(module_name) + self.suffix_warning)
-		elif (type=="lib-static"):
-			list.append(file)
-			list.append(self.get_build_file_static(module_name))
-			list.append(os.path.join(self.get_build_path(module_name), self.path_lib, module_name + self.suffix_dependence))
-			list.append(self.get_build_file_static(module_name) + self.suffix_cmd_line)
-			list.append(self.get_build_file_static(module_name) + self.suffix_warning)
-		elif (type=="jar"):
-			list.append(file)
-			list.append(os.path.join(self.get_build_path(module_name), module_name + ".jar"))
-			list.append(os.path.join(self.get_build_path(module_name), module_name + ".jar" + self.suffix_dependence))
-			list.append(os.path.join(self.get_build_path(module_name), module_name + ".jar" + self.suffix_cmd_line))
-			list.append(os.path.join(self.get_build_path(module_name), module_name + ".jar" + self.suffix_warning))
-		elif (type=="image"):
-			list.append(os.path.join(self.get_build_path(binary_name), "data", file + self.suffix_cmd_line))
-		else:
-			debug.error("unknow type : " + type)
-		return list
-	
 	##
-	## @brief Get the fianal path ==> contain all the generated packages
-	## @return The path of the pa
+	## @brief Get the final path ==> contain all the generated packages
+	## @param[in] self (handle) Class handle
+	## @return (string) The path
 	##
 	def get_final_path(self):
 		return os.path.join(tools.get_run_path(), self.path_out, self.path_final)
 	
-	def get_staging_path(self, binary_name):
-		return os.path.join(tools.get_run_path(), self.path_out, self.path_staging, binary_name)
+	##
+	## @brief Get the staging path ==> all install stangalone package (no dependency file, no object files, no cmdlines files
+	## @param[in] self (handle) Class handle
+	## @param[in] name (string) Name of the module
+	## @return (string) The path
+	##
+	def get_staging_path(self, name, tmp=False):
+		if tmp == False:
+			return os.path.join(tools.get_run_path(), self.path_out, self.path_staging, name)
+		else:
+			return os.path.join(tools.get_run_path(), self.path_out, self.path_staging_tmp, name)
 	
-	def get_build_path(self, module_name):
-		#debug.warning("A=" + str(tools.get_run_path()) + " " + str(self.path_out) + " " + str(self.path_build) + " " + str(module_name))
-		return os.path.join(tools.get_run_path(), self.path_out, self.path_build, module_name)
+	##
+	## @brief Get the build path ==> dependency file, object files, cmdlines files, generate files, local install headers ...
+	## @param[in] self (handle) Class handle
+	## @param[in] name (string) Name of the module
+	## @return (string) The path
+	##
+	def get_build_path(self, name):
+		return os.path.join(tools.get_run_path(), self.path_out, self.path_build, name)
+	
+	##
+	## @brief Get the build object path where write .o files
+	## @param[in] self (handle) Class handle
+	## @param[in] name (string) Name of the module
+	## @return (string) The path
+	##
+	def get_build_path_object(self, name):
+		return os.path.join(self.get_build_path(name), self.path_object)
+	
+	##
+	## @brief Get the build binary path where write .bin, .exe ... files
+	## @param[in] self (handle) Class handle
+	## @param[in] name (string) Name of the module
+	## @return (string) The path
+	##
+	def get_build_path_bin(self, name):
+		return os.path.join(self.get_build_path(name), self.path_bin)
+	
+	##
+	## @brief Get the shared/static library object path where write .a / .so files
+	## @param[in] self (handle) Class handle
+	## @param[in] name (string) Name of the module
+	## @return (string) The path
+	##
+	def get_build_path_lib(self, name):
+		return os.path.join(self.get_build_path(name), self.path_lib)
+	
+	##
+	## @brief Get the data path where pre-write the install "data" files
+	## @param[in] self (handle) Class handle
+	## @param[in] name (string) Name of the module
+	## @return (string) The path
+	##
+	def get_build_path_data(self, name):
+		return os.path.join(self.get_build_path(name), self.path_data, name)
+	
+	##
+	## @brief Get the include path where pre-install "include" headers files
+	## @param[in] self (handle) Class handle
+	## @param[in] name (string) Name of the module
+	## @return (string) The path
+	##
+	def get_build_path_include(self, name):
+		return os.path.join(self.get_build_path(name), self.path_include)
+	
+	##
+	## @brief Get the path where to generate files when needed (before compiling / installing it)
+	## @param[in] self (handle) Class handle
+	## @param[in] name (string) Name of the module
+	## @return (string) The path
+	##
+	def get_build_path_temporary_generate(self, name):
+		return os.path.join(self.get_build_path(name), self.path_temporary_generate)
+	
+	##
+	## @brief Get the path filename of the build binary name
+	## @param[in] self (handle) Class handle
+	## @param[in] name (string) Name of the module
+	## @return (string) The path
+	##
+	def get_build_file_bin(self, name):
+		return os.path.join(self.get_build_path_bin(name), name + self.suffix_binary)
+	
+	##
+	## @brief Get the path filename of the build static library name
+	## @param[in] self (handle) Class handle
+	## @param[in] name (string) Name of the module
+	## @return (string) The path
+	##
+	def get_build_file_static(self, name):
+		return os.path.join(self.get_build_path_lib(name), self.prefix_lib + name + self.suffix_lib_static)
+	
+	##
+	## @brief Get the path filename of the build shared library name
+	## @param[in] self (handle) Class handle
+	## @param[in] name (string) Name of the module
+	## @return (string) The path
+	##
+	def get_build_file_dynamic(self, name):
+		return os.path.join(self.get_build_path_lib(name), self.prefix_lib + name + self.suffix_lib_dynamic)
 	
 	
-	def get_build_path_object(self, binary_name):
-		return os.path.join(self.get_build_path(binary_name), self.path_object)
+	##
+	## @brief Get the bin path for staging step
+	## @param[in] self (handle) Class handle
+	## @param[in] name (string) Name of the package
+	## @return (string) The path
+	##
+	def get_staging_path_bin(self, name, tmp=False):
+		return os.path.join(self.get_staging_path(name, tmp), self.path_bin)
 	
-	def get_build_path_bin(self, binary_name):
-		return os.path.join(self.get_build_path(binary_name), self.path_bin)
-	
-	def get_build_path_lib(self, binary_name):
-		return os.path.join(self.get_build_path(binary_name), self.path_lib)
-	
-	def get_build_path_data(self, binary_name):
-		return os.path.join(self.get_build_path(binary_name), self.path_data, binary_name)
-	
-	def get_build_path_include(self, binary_name):
-		return os.path.join(self.get_build_path(binary_name), self.path_include)
-	
-	
-	def get_build_file_bin(self, binary_name):
-		return os.path.join(self.get_build_path_bin(binary_name), binary_name + self.suffix_binary)
-	
-	def get_build_file_static(self, binary_name):
-		return os.path.join(self.get_build_path_lib(binary_name), self.prefix_lib + binary_name + self.suffix_lib_static)
-	
-	def get_build_file_dynamic(self, binary_name):
-		return os.path.join(self.get_build_path_lib(binary_name), self.prefix_lib + binary_name + self.suffix_lib_dynamic)
-	
-	
-	
-	
-	def get_staging_path_bin(self, package_name):
-		return os.path.join(self.get_staging_path(package_name), self.path_bin)
-	
-	def get_staging_path_lib(self, package_name):
-		return os.path.join(self.get_staging_path(package_name), self.path_lib, package_name)
-	
-	def get_staging_path_data(self, package_name):
-		return os.path.join(self.get_staging_path(package_name), self.path_data, package_name)
-	
-	def get_staging_path_include(self, package_name):
-		return os.path.join(self.get_staging_path(package_name), self.path_include)
-	
-	"""
-	def get_staging_file_bin(self, package_name, binary_name):
-		return os.path.join(self.get_staging_path_bin(package_name), binary_name + self.suffix_binary)
-	"""
+	##
+	## @brief Get the lib path for staging step
+	## @param[in] self (handle) Class handle
+	## @param[in] name (string) Name of the package
+	## @return (string) The path
+	##
+	def get_staging_path_lib(self, name, tmp=False):
+		return os.path.join(self.get_staging_path(name, tmp), self.path_lib, name)
 	
+	##
+	## @brief Get the data path for staging step
+	## @param[in] self (handle) Class handle
+	## @param[in] name (string) Name of the package
+	## @return (string) The path
+	##
+	def get_staging_path_data(self, name, tmp=False):
+		return os.path.join(self.get_staging_path(name, tmp), self.path_data, name)
 	
+	##
+	## @brief Get the include path for staging step
+	## @param[in] self (handle) Class handle
+	## @param[in] name (string) Name of the package
+	## @return (string) The path
+	##
+	def get_staging_path_include(self, name):
+		return os.path.join(self.get_staging_path(name), self.path_include)
 	
 	def get_doc_path(self, module_name):
 		return os.path.join(tools.get_run_path(), self.path_out, self.path_doc, module_name)
 	
-	
 	def is_module_build(self, my_module):
 		for mod in self.build_done:
 			if mod == my_module:
@@ -411,43 +541,66 @@ class Target:
 		self.build_tree_done.append(my_module)
 		return False
 	
-	def add_module(self, newModule):
-		debug.debug("Add nodule for Taget : " + newModule.name)
-		self.module_list.append(newModule)
+	##
+	## @brief Add new loaded module
+	## @param[in] self (handle) Class handle
+	## @param[in] new_module (handle) pointer on the module instance
+	## @return None
+	##
+	def add_module(self, new_module):
+		debug.debug("Add nodule for Taget : " + new_module.get_name())
+		self.module_list.append(new_module)
 	
+	##
+	## @brief Get a module handle that is used in this target
+	## @param[in] self (handle) Class handle
+	## @param[in] name (string) Name of the module
+	## @return (handle|None) @ref lutin.module.Module pointer on the module requested or None
+	##
 	def get_module(self, name):
 		for mod in self.module_list:
-			if mod.name == name:
+			if mod.get_name() == name:
 				return mod
 		debug.error("the module '" + str(name) + "'does not exist/already build")
 		return None
 	
-	# return inherit packages ...
-	"""
-	def build(self, name, packagesName):
-		for module in self.module_list:
-			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):
+	##
+	## @brief Build data associated at the module name in a specific package
+	## @param[in] self (handle) Class handle
+	## @param[in] name (string) Name of the module
+	## @param[in] package_name (string) Name of the package
+	## @return None
+	##
+	def build_tree(self, name, package_name):
 		for mod in self.module_list:
-			if mod.name == name:
-				mod.build_tree(self, packagesName)
+			if mod.get_name() == name:
+				mod.build_tree(self, package_name)
 				return
 		debug.error("request to build tree on un-existant module name : '" + name + "'")
 	
+	##
+	## @brief Clean a specific module for this target (clean all data in the "out" path)
+	## @param[in] self (handle) Class handle
+	## @param[in] name (string) Name of the module
+	## @return None
+	##
 	def clean(self, name):
 		for mod in self.module_list:
-			if mod.name == name:
+			if mod.get_name() == name:
 				mod.clean(self)
 				return
 		debug.error("request to clean an un-existant module name : '" + name + "'")
 	
+	##
+	## @brief Load a specific module if it accessible
+	## @param[in] self (handle) Class handle
+	## @param[in] name (string) Name of the module to load
+	## @param[in] optionnal (bool) not create an error if the module does not exist.
+	## @return (bool) module loading status
+	##
 	def load_if_needed(self, name, optionnal=False):
 		for elem in self.module_list:
-			if elem.name == name:
+			if elem.get_name() == name:
 				return True
 		# try to find in the local Modules:
 		exist = module.exist(self, name)
@@ -455,26 +608,33 @@ class Target:
 			module.load_module(self, name)
 			return True;
 		# need to import the module (or the system module ...)
-		exist = system.exist(name, self.name, self)
+		exist = system.exist(name, self._config_based_on, self)
 		if exist == True:
-			system.load(self, name, self.name)
+			system.load(self, name, self._config_based_on)
 			return True;
 		# we did not find the module ...
 		return False;
 	
+	##
+	## @brief Load all module that are accessible in the worktree
+	## @param[in] self (handle) Class handle
+	## @return None
+	##
 	def load_all(self):
 		listOfAllTheModule = module.list_all_module()
 		for modName in listOfAllTheModule:
 			self.load_if_needed(modName)
 	
-	def project_add_module(self, name, projectMng, addedModule):
-		for mod in self.module_list:
-			if mod.name == name:
-				mod.ext_project_add_module(self, projectMng, addedModule)
-				return
-	
-	
-	def build(self, name, packagesName=None, optionnal=False, actions=[]):
+	##
+	## @brief Build action on the target (execute specific actions on the modules...)
+	## @note Recursive call ...
+	## @param[in] self (handle) Class handle
+	## @param[in] name (string) Module to build
+	## @param[in] optionnal (bool) If the module is not accessible, this is not a probleme ==> optionnal dependency requested
+	## @param[in] actions ([string,...]) list of action to do. ex: build, gcov, dump, all, clean, install, uninstall, run, log
+	## @return (None|Module handle| ...) complicated return ...
+	##
+	def build(self, name, optionnal=False, actions=[]):
 		if    len(name.split("?")) != 1\
 		   or len(name.split("@")) != 1:
 			debug.error("need update")
@@ -497,12 +657,12 @@ class Target:
 			debug.info("build all")
 			self.load_all()
 			for mod in self.module_list:
-				if self.name=="Android":
-					if mod.type == "PACKAGE":
+				if self._name=="Android":
+					if mod.get_type() == "PACKAGE":
 						mod.build(self, None)
 				else:
-					if    mod.type == "BINARY" \
-					   or mod.type == "PACKAGE":
+					if    mod.get_type() == "BINARY" \
+					   or mod.get_type() == "PACKAGE":
 						mod.build(self, None)
 		elif name == "clean":
 			debug.info("clean all")
@@ -556,7 +716,8 @@ class Target:
 						ret = [heritage.HeritageList(), False]
 					else:
 						for mod in self.module_list:
-							if mod.name == module_name:
+							debug.verbose("compare " + mod.get_name() + " == " + module_name)
+							if mod.get_name() == module_name:
 								if action_name[:4] == "dump":
 									debug.info("dump module '" + module_name + "'")
 									if len(action_name) > 4:
@@ -605,6 +766,23 @@ class Target:
 			if len(action_list) == 1:
 				return ret
 	
+	##
+	## @brief Add action to do for package specific part when build upper element
+	## @param[in] name_of_state (string) a state to call action
+	##     - BINARY
+	##     - BINARY_SHARED
+	##     - BINARY_STAND_ALONE
+	##     - LIBRARY
+	##     - LIBRARY_DYNAMIC
+	##     - LIBRARY_STATIC
+	##     - PACKAGE
+	##     - PREBUILD
+	##     - DATA
+	## @param[in] level (int) Value order to apply action
+	## @param[in] name (string) Name of the action
+	## @param[in] action (function handle) Function to call to execure action
+	## @return None
+	##
 	def add_action(self, name_of_state="PACKAGE", level=5, name="no-name", action=None):
 		debug.verbose("add action : " + name)
 		if name_of_state not in self.action_on_state:
@@ -621,6 +799,7 @@ class Target:
 	## @param[in] static The package is build in static mode
 	##
 	def make_package(self, pkg_name, pkg_properties, base_pkg_path, heritage_list):
+		debug.debug("make_package [START]")
 		#The package generated depend of the type of the element:
 		end_point_module_name = heritage_list.list_heritage[-1].name
 		module = self.get_module(end_point_module_name)
@@ -642,6 +821,7 @@ class Target:
 		if module.get_type() == 'PACKAGE':
 			debug.info("Can not create package for package");
 			return
+		debug.debug("make_package [STOP]")
 		return
 	
 	##
@@ -654,6 +834,7 @@ class Target:
 	## @return False Nothing has been copied
 	##
 	def make_package_binary_data(self, path_package, pkg_name, base_pkg_path, heritage_list, static):
+		debug.debug("make_package_binary_data [START]")
 		target_shared_path = os.path.join(path_package, self.pkg_path_data)
 		if static == True:
 			path_package_data = os.path.join(target_shared_path, pkg_name)
@@ -688,6 +869,7 @@ class Target:
 		ret_copy = tools.copy_list(copy_list)
 		# remove unneded files (NOT folder ...)
 		ret_remove = tools.clean_directory(target_shared_path, copy_list)
+		debug.debug("make_package_binary_data [STOP]")
 		return ret_copy or ret_remove
 	
 	##
@@ -700,6 +882,7 @@ class Target:
 	## @return False Nothing has been copied
 	##
 	def make_package_binary_bin(self, path_package, pkg_name, base_pkg_path, heritage_list, static):
+		debug.debug("make_package_binary_bin [START]")
 		copy_list={}
 		path_package_bin = os.path.join(path_package, self.pkg_path_bin)
 		tools.create_directory_of_file(path_package_bin)
@@ -715,6 +898,7 @@ class Target:
 		if self.pkg_path_bin != "":
 			# remove unneded files (NOT folder ...)
 			ret_remove = tools.clean_directory(path_package_bin, copy_list)
+		debug.debug("make_package_binary_bin [STOP]")
 		return ret_copy or ret_remove
 	
 	##
@@ -727,6 +911,7 @@ class Target:
 	## @return False Nothing has been copied
 	##
 	def make_package_binary_lib(self, path_package, pkg_name, base_pkg_path, heritage_list, static):
+		debug.debug("make_package_binary_lib [START]")
 		copy_list={}
 		path_package_lib = os.path.join(path_package, self.pkg_path_lib)
 		if static == False:
@@ -750,10 +935,12 @@ class Target:
 		if self.pkg_path_lib != "":
 			# remove unneded files (NOT folder ...)
 			ret_remove = tools.clean_directory(path_package_lib, copy_list)
+		debug.debug("make_package_binary_lib [STOP]")
 		return ret_copy or ret_remove
 	
 	
 	def make_package_generic_files(self, path_package, pkg_properties, pkg_name, base_pkg_path, heritage_list, static):
+		debug.debug("make_package_generic_files [START]")
 		## Create version file:
 		ret_version = tools.file_write_data(os.path.join(path_package, self.pkg_path_version_file),
 		                                    tools.version_to_string(pkg_properties["VERSION"]),
@@ -814,6 +1001,7 @@ class Target:
 			ret_changelog = tools.file_write_data(change_log_file_dest,
 			                                      "No changelog data " + pkg_name + "\n",
 			                                      only_if_new=True)
+		debug.debug("make_package_generic_files [STOP]")
 		return    ret_version \
 		       or ret_maintainer \
 		       or ret_appl_name \
@@ -821,6 +1009,30 @@ class Target:
 		       or ret_readme \
 		       or ret_changelog
 	
+	def install_package(self, pkg_name):
+		debug.debug("------------------------------------------------------------------------")
+		debug.info("-- Install package '" + pkg_name + "'")
+		debug.debug("------------------------------------------------------------------------")
+		debug.error("action not implemented ...")
+	
+	def un_install_package(self, pkg_name):
+		debug.debug("------------------------------------------------------------------------")
+		debug.info("-- Un-Install package '" + pkg_name + "'")
+		debug.debug("------------------------------------------------------------------------")
+		debug.error("action not implemented ...")
+	
+	def run(self, pkg_name, option_list):
+		debug.debug("------------------------------------------------------------------------")
+		debug.info("-- Run package '" + pkg_name + "' + option: " + str(option_list))
+		debug.debug("------------------------------------------------------------------------")
+		debug.error("action not implemented ...")
+	
+	def show_log(self, pkg_name):
+		debug.debug("------------------------------------------------------------------------")
+		debug.info("-- Show log logcat '" + pkg_name + "'")
+		debug.debug("------------------------------------------------------------------------")
+		debug.error("action not implemented ...")
+	
 	##
 	## @brief convert a s list of string in a string separated by a ","
 	## @param[in] list List of element to transform
@@ -838,12 +1050,15 @@ class Target:
 		return result
 
 
-target_list=[]
+__target_list=[]
 __start_target_name="Target_"
 
-
+##
+## @brief Import all File that start with env.get_build_system_base_name() + __start_target_name + XXX and register in the list of Target
+## @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 target_list
+	global __target_list
 	global_base = env.get_build_system_base_name()
 	debug.debug("TARGET: Init with Files list:")
 	for elem in path_list:
@@ -861,18 +1076,21 @@ def import_path(path_list):
 		# Remove local patern
 		target_name = filename[len(__start_target_name):]
 		debug.verbose("TARGET:     Integrate: '" + target_name + "' from '" + elem + "'")
-		target_list.append([target_name, elem])
+		__target_list.append([target_name, elem])
 	debug.verbose("New list TARGET: ")
-	for elem in target_list:
+	for elem in __target_list:
 		debug.verbose("    " + str(elem[0]))
 
+##
+## @brief Load a specific target
+##
 def load_target(name, config):
-	global target_list
+	global __target_list
 	debug.debug("load target: " + name)
-	if len(target_list) == 0:
+	if len(__target_list) == 0:
 		debug.error("No target to compile !!!")
-	debug.debug("list target: " + str(target_list))
-	for mod in target_list:
+	debug.debug("list target: " + str(__target_list))
+	for mod in __target_list:
 		if mod[0] == name:
 			debug.verbose("add to path: '" + os.path.dirname(mod[1]) + "'")
 			sys.path.append(os.path.dirname(mod[1]))
@@ -884,16 +1102,16 @@ def load_target(name, config):
 	raise KeyError("No entry for : " + name)
 
 def list_all_target():
-	global target_list
+	global __target_list
 	tmpListName = []
-	for mod in target_list:
+	for mod in __target_list:
 		tmpListName.append(mod[0])
 	return tmpListName
 
 def list_all_target_with_desc():
-	global target_list
+	global __target_list
 	tmpList = []
-	for mod in target_list:
+	for mod in __target_list:
 		sys.path.append(os.path.dirname(mod[1]))
 		theTarget = __import__(env.get_build_system_base_name() + __start_target_name + mod[0])
 		try:

lutin/tools.py

@@ -316,6 +316,14 @@ def store_warning(file, output, err):
 	file2.flush()
 	file2.close()
 
+def get_type_string(in_type):
+	if type(in_type) == str:
+		return "string"
+	elif type(in_type) == list:
+		return "list"
+	elif type(in_type) == dict:
+		return "dict"
+	return "unknow"
 
 ## List tools:
 def list_append_and_check(listout, newElement, order):
@@ -339,13 +347,103 @@ def list_append_to(out_list, in_list, order=False):
 	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):
+def list_append_to_2(listout, module, in_list, order=False):
 	# sepcial cse of bool
-	if type(list) == bool:
-		listout[module] = list
+	if type(in_list) == bool:
+		listout[module] = in_list
 		return
 	# add list in the Map
 	if module not in listout:
 		listout[module] = []
 	# add elements...
-	list_append_to(listout[module], list, order)
+	list_append_to(listout[module], in_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 = ""
+	list_tiret = line.split('-')
+	if len(list_tiret) > 2:
+		debug.warning("more than one '-' in version file " + str(filename_or_version) + " : '" + str(list_tiret) + "' in '" + path_module + "'")
+	if len(list_tiret) >= 2:
+		dev_mode = list_tiret[1]
+		line = list_tiret[0]
+	out = []
+	list_elem = line.split('.')
+	for elem in list_elem:
+		out.append(int(elem))
+	if dev_mode != "":
+		out.append(dev_mode)
+	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
+
+
+
+def remove_element(data, to_remove):
+	base_data = []
+	for elem in data:
+		if type(elem) == list:
+			for elem2 in elem:
+				base_data.append(elem2)
+		else:
+			base_data.append(elem)
+	base_remove = []
+	for elem in to_remove:
+		if type(elem) == list:
+			for elem2 in elem:
+				base_remove.append(elem2)
+		else:
+			base_remove.append(elem)
+	out = []
+	for elem in base_data:
+		if elem not in base_remove:
+			out.append(elem)
+	return out;
+
+

lutin/z_builder/lutinBuilder_binary.py

@@ -58,7 +58,12 @@ def get_support_multithreading():
 ## @brief Commands for running gcc to link an executable.
 ##
 def link(file, binary, target, depancy, flags, name, basic_path, static = False):
-	file_src, file_dst, file_depend, file_cmd, file_warning = target.generate_file(binary, name, basic_path, file, "bin")
+	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 = []
@@ -95,10 +100,6 @@ def link(file, binary, target, depancy, flags, name, basic_path, static = False)
 		cmd.append(target.sysroot)
 	except:
 		pass
-	try:
-		cmd.append(target.global_sysroot)
-	except:
-		pass
 	try:
 		cmd.append(["-o", file_dst])
 	except:
@@ -127,6 +128,7 @@ def link(file, binary, target, depancy, flags, name, basic_path, static = False)
 				cmd.append("-Wl,-R$ORIGIN/../lib/")
 	except:
 		pass
+	cmd.append("-Wl,-rpath,\"\$ORIGIN/../lib\"")
 	try:
 		cmd.append(flags["local"]["link"])
 	except:
@@ -145,12 +147,20 @@ def link(file, binary, target, depancy, flags, name, basic_path, static = False)
 		for type in ["link-lib"]:
 			if type in flags[view]:
 				cmd.append([("-l" + sss).replace("-l/", "/") for sss in flags[view][type] ])
+		for type in ["link-bin"]:
+			if type in flags[view]:
+				cmd.append(flags[view][type])
 	for type in ["link-lib"]:
 		if type in depancy.flags:
 			cmd.append([("-l" + sss).replace("-l/", "/") for sss in depancy.flags[type] ])
 	for type in ["link-lib"]:
 		if type in target.global_flags:
 			cmd.append([("-l" + sss).replace("-l/", "/") for sss in target.global_flags[type] ])
+	for type in ["link-bin"]:
+		if type in target.global_flags:
+			cmd.append(target.global_flags[type])
+		if type in depancy.flags:
+			cmd.append(depancy.flags[type])
 	cmd_line = tools.list_to_str(cmd)
 	# check the dependency for this file :
 	if     depend.need_re_package(file_dst, file_src, True, file_cmd=file_cmd, cmd_line=cmd_line) == False \

lutin/z_builder/lutinBuilder_c.py

@@ -70,8 +70,7 @@ def compile(file, binary, target, depancy, flags, path, name, basic_path, module
 		target.cc,
 		"-o", file_dst,
 		target.arch,
-		target.sysroot,
-		target.global_include_cc]
+		target.sysroot]
 	for view in ["export", "local"]:
 		try:
 			cmd.append(tools.add_prefix("-I", path[view]["c"]))
@@ -81,23 +80,35 @@ def compile(file, binary, target, depancy, flags, path, name, basic_path, module
 		cmd.append(tools.add_prefix("-I", depancy.path["c"]))
 	except:
 		pass
+	cmd.append(target.global_include_cc)
 	try:
 		cmd.append(get_version_compilation_flags(flags, depancy.flags))
 	except:
 		pass
-	try:
-		cmd.append(target.global_flags["c"])
-	except:
-		pass
-	try:
-		cmd.append(depancy.flags["c"])
-	except:
-		pass
+	list_flags = [];
+	if "c" in target.global_flags:
+		list_flags.append(target.global_flags["c"])
+	if "c" in depancy.flags:
+		list_flags.append(depancy.flags["c"])
 	for view in ["local", "export"]:
-		try:
-			cmd.append(flags[view]["c"])
-		except:
-			pass
+		if view in flags:
+			if "c" in flags[view]:
+				list_flags.append(flags[view]["c"])
+	# get blacklist of flags
+	list_flags_blacklist = [];
+	if "c-remove" in target.global_flags:
+		list_flags_blacklist.append(target.global_flags["c-remove"])
+	if "c-remove" in depancy.flags:
+		list_flags_blacklist.append(depancy.flags["c-remove"])
+	for view in ["local", "export"]:
+		if view in flags:
+			if "c-remove" in flags[view]:
+				list_flags_blacklist.append(flags[view]["c-remove"])
+	# apply blacklisting of data and add it on the cmdLine
+	clean_flags = tools.remove_element(list_flags, list_flags_blacklist)
+	#debug.warning("plop " + str(list_flags_blacklist) + "       " + str(list_flags) + "  --> " + str(clean_flags) )
+	cmd.append(clean_flags);
+	
 	cmd.append("-c")
 	cmd.append("-MMD")
 	cmd.append("-MP")

lutin/z_builder/lutinBuilder_cpp.py

@@ -54,12 +54,6 @@ def get_output_type():
 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.
@@ -75,8 +69,7 @@ def compile(file, binary, target, depancy, flags, path, name, basic_path, module
 		target.xx,
 		"-o", file_dst,
 		target.arch,
-		target.sysroot,
-		target.global_include_cc
+		target.sysroot
 		]
 	for view in ["export", "local"]:
 		for type in ["c", "c++"]:
@@ -89,53 +82,42 @@ def compile(file, binary, target, depancy, flags, path, name, basic_path, module
 			cmd.append(tools.add_prefix("-I",depancy.path[type]))
 		except:
 			pass
+	cmd.append(target.global_include_cc)
 	try:
 		cmd.append(get_version_compilation_flags(flags, depancy.flags))
 	except:
 		pass
 	list_flags = [];
-	try:
+	if "c" in target.global_flags:
 		list_flags.append(target.global_flags["c"])
-	except:
-		pass
-	try:
+	if "c++" in target.global_flags:
 		list_flags.append(target.global_flags["c++"])
-	except:
-		pass
 	for type in ["c", "c++"]:
-		try:
+		if type in depancy.flags:
 			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
+		if view in flags:
+			for type in ["c", "c++"]:
+				if type in flags[view]:
+					list_flags.append(flags[view][type])
 	# get blacklist of flags
 	list_flags_blacklist = [];
-	try:
+	if "c-remove" in target.global_flags:
 		list_flags_blacklist.append(target.global_flags["c-remove"])
-	except:
-		pass
-	try:
+	if "c++-remove" in target.global_flags:
 		list_flags_blacklist.append(target.global_flags["c++-remove"])
-	except:
-		pass
 	for type in ["c-remove", "c++-remove"]:
-		try:
+		if type in depancy.flags:
 			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
+		if view in flags:
+			for type in ["c-remove", "c++-remove"]:
+				if type in flags[view]:
+					list_flags_blacklist.append(flags[view][type])
 	# apply blacklisting of data and add it on the cmdLine
-	cmd.append(remove_element(list_flags, list_flags_blacklist));
+	clean_flags = tools.remove_element(list_flags, list_flags_blacklist)
+	#debug.warning("plop " + str(list_flags_blacklist) + "       " + str(list_flags) + "  --> " + str(clean_flags) )
+	cmd.append(clean_flags);
 	cmd.append(["-c", "-MMD", "-MP"])
 	cmd.append(file_src)
 	# Create cmd line

lutin/z_builder/lutinBuilder_jar.py

@@ -57,7 +57,12 @@ def get_support_multithreading():
 ## @brief Commands for running gcc to link a shared library.
 ##
 def link(file, binary, target, depancy, flags, name, basic_path):
-	file_src, file_dst, file_depend, file_cmd, file_warning = target.generate_file(binary, name, basic_path, file, "jar")
+	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,

lutin/z_builder/lutinBuilder_libraryDynamic.py

@@ -57,7 +57,17 @@ def get_support_multithreading():
 ## @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_dst, file_depend, file_cmd, file_warning = target.generate_file(binary, name, basic_path, file, "lib-shared")
+	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:
@@ -87,7 +97,7 @@ def link(file, binary, target, depancy, flags, name, basic_path, static=False):
 	
 	cmd.append(["-o", file_dst])
 	try:
-		cmd.append(target.global_sysroot)
+		cmd.append(target.sysroot)
 	except:
 		pass
 	try:
@@ -155,7 +165,7 @@ def link(file, binary, target, depancy, flags, name, basic_path, static=False):
 		# get the file size of the non strip file
 		originSize = tools.file_size(file_dst);
 		debug.print_element("SharedLib(strip)", name, "", "")
-		if target.name == "MacOs":
+		if "MacOs" in target.get_type():
 			cmdLineStrip=tools.list_to_str([
 				target.strip,
 				"-u",

lutin/z_builder/lutinBuilder_libraryStatic.py

@@ -57,8 +57,17 @@ def get_support_multithreading():
 ## @brief Commands for running ar.
 ##
 def link(file, binary, target, depancy, flags, name, basic_path):
-	file_src, file_dst, file_depend, file_cmd, file_warning = target.generate_file(binary, name, basic_path, file, "lib-static")
-	#$(Q)$(TARGET_AR) $(TARGET_GLOBAL_ARFLAGS) $(PRIVATE_ARFLAGS) $@ $(PRIVATE_ALL_OBJECTS)
+	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
 		]

lutin/z_builder/lutinBuilder_m.py

@@ -87,25 +87,37 @@ def compile(file, binary, target, depancy, flags, path, name, basic_path, module
 		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
+	list_flags = [];
+	if "c" in target.global_flags:
+		list_flags.append(target.global_flags["c"])
+	if "m" in target.global_flags:
+		list_flags.append(target.global_flags["m"])
 	for type in ["c", "m"]:
-		try:
-			cmd.append(depancy.flags[type])
-		except:
-			pass
+		if type in depancy.flags:
+			list_flags.append(depancy.flags[type])
 	for view in ["local", "export"]:
-		for type in ["c", "m"]:
-			try:
-				cmd.append(flags[view][type])
-			except:
-				pass
+		if view in flags:
+			for type in ["c", "m"]:
+				if type in flags[view]:
+					list_flags.append(flags[view][type])
+	# get blacklist of flags
+	list_flags_blacklist = [];
+	if "c-remove" in target.global_flags:
+		list_flags_blacklist.append(target.global_flags["c-remove"])
+	if "m-remove" in target.global_flags:
+		list_flags_blacklist.append(target.global_flags["m-remove"])
+	for type in ["c-remove", "m-remove"]:
+		if type in depancy.flags:
+			list_flags_blacklist.append(depancy.flags[type])
+	for view in ["local", "export"]:
+		if view in flags:
+			for type in ["c-remove", "m-remove"]:
+				if type in flags[view]:
+					list_flags_blacklist.append(flags[view][type])
+	# apply blacklisting of data and add it on the cmdLine
+	clean_flags = tools.remove_element(list_flags, list_flags_blacklist)
+	#debug.warning("plop " + str(list_flags_blacklist) + "       " + str(list_flags) + "  --> " + str(clean_flags) )
+	cmd.append(clean_flags);
 	cmd.append("-c -MMD -MP")
 	cmd.append("-x objective-c")
 	cmd.append(file_src)

lutin/z_builder/lutinBuilder_mm.py

@@ -87,22 +87,45 @@ def compile(file, binary, target, depancy, flags, path, name, basic_path, module
 		cmd.append(local_ref_on_builder_cpp.get_version_compilation_flags(flags, depancy.flags))
 	except:
 		pass
+	list_flags = [];
+	if "c" in target.global_flags:
+		list_flags.append(target.global_flags["c"])
+	if "c++" in target.global_flags:
+		list_flags.append(target.global_flags["c++"])
+	if "m" in target.global_flags:
+		list_flags.append(target.global_flags["m"])
+	if "mm" in target.global_flags:
+		list_flags.append(target.global_flags["mm"])
 	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
+		if type in depancy.flags:
+			list_flags.append(depancy.flags[type])
+	for view in ["local", "export"]:
+		if view in flags:
+			for type in ["c", "c++", "m", "mm"]:
+				if type in flags[view]:
+					list_flags.append(flags[view][type])
+	# get blacklist of flags
+	list_flags_blacklist = [];
+	if "c-remove" in target.global_flags:
+		list_flags_blacklist.append(target.global_flags["c-remove"])
+	if "c++-remove" in target.global_flags:
+		list_flags_blacklist.append(target.global_flags["c++-remove"])
+	if "m-remove" in target.global_flags:
+		list_flags_blacklist.append(target.global_flags["m-remove"])
+	if "mm-remove" in target.global_flags:
+		list_flags_blacklist.append(target.global_flags["mm-remove"])
+	for type in ["c-remove", "c++-remove","m-remove", "mm-remove"]:
+		if type in depancy.flags:
+			list_flags_blacklist.append(depancy.flags[type])
+	for view in ["local", "export"]:
+		if view in flags:
+			for type in ["c-remove", "c++-remove","m-remove", "mm-remove"]:
+				if type in flags[view]:
+					list_flags_blacklist.append(flags[view][type])
+	# apply blacklisting of data and add it on the cmdLine
+	clean_flags = tools.remove_element(list_flags, list_flags_blacklist)
+	#debug.warning("plop " + str(list_flags_blacklist) + "       " + str(list_flags) + "  --> " + str(clean_flags) )
+	cmd.append(clean_flags);
 	cmd.append("-c -MMD -MP")
 	cmd.append("-x objective-c++")
 	cmd.append(file_src)

lutin/z_builder/lutinBuilder_s.py

@@ -49,3 +49,57 @@ def get_output_type():
 ##
 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/lutinSystem_Android_ADMOD.py

@@ -11,17 +11,18 @@
 from lutin import debug
 from lutin import system
 from lutin import tools
+from lutin import env
 import os
 
 class System(system.System):
 	def __init__(self, target):
 		system.System.__init__(self)
 		# create some HELP:
-		self.help="ADMOD: Android SDK ad-mod interface (auto-create interface for admod)\n"
+		self.set_help("ADMOD: Android SDK ad-mod interface (auto-create interface for admod)\n")
 		# todo : Check if present ...
-		self.valid = True
+		self.set_valid(True)
 		# todo : create a searcher of the presence of the library:
-		self.add_export_sources(target.path_sdk + "/extras/google/google_play_services/libproject/google-play-services_lib/libs/google-play-services.jar")
+		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)
 
 

lutin/z_system/lutinSystem_Android_SDK.py

@@ -11,21 +11,22 @@
 from lutin import debug
 from lutin import system
 from lutin import tools
+from lutin import env
 import os
 
 class System(system.System):
 	def __init__(self, target):
 		system.System.__init__(self)
 		# create some HELP:
-		self.help="SDK: Android SDK basic interface java\n"
+		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.valid = True
+		self.set_valid(True)
 		# todo : create a searcher of the presence of the library:
-		self.add_export_sources(jar_file_path)
-		self.add_export_flag("link-lib", "dl")
-		self.add_export_flag("link-lib", "log")
-		self.add_export_flag("link-lib", "android")
+		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

@@ -11,66 +11,67 @@
 from lutin import debug
 from lutin import system
 from lutin import tools
+from lutin import env
 import os
 
 class System(system.System):
 	def __init__(self, target):
 		system.System.__init__(self)
 		# create some HELP:
-		self.help = "CXX: Generic C++ library"
-		self.valid = True
+		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_export_flag("c++", "-D__STDCPP_LLVM__")
+			self.add_flag("c++", "-D__STDCPP_LLVM__")
 			# llvm is BSD-like licence
-			self.add_export_path(os.path.join(target.path_ndk, "sources", "cxx-stl", "llvm-libc++", "libcxx", "include"))
+			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_export_path(        os.path.join(stdCppBasePath, "include"))
-				self.add_export_flag("link", os.path.join(stdCppBasePath, "libc++_static.a"))
+				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_export_path(        os.path.join(stdCppBasePath + "include"))
-				self.add_export_flag("link", os.path.join(stdCppBasePath, "thumb", "libc++_static.a"))
+				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_export_path(        os.path.join(stdCppBasePath + "include"))
-				self.add_export_flag("link", os.path.join(stdCppBasePath + "libc++_static.a"))
+				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_export_path(        os.path.join(stdCppBasePath, "include"))
-				self.add_export_flag("link", os.path.join(stdCppBasePath, "libc++_static.a"))
+				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_export_flag("c++", "-D__STDCPP_GNU__")
-			self.add_export_flag("c++-remove","-nostdlib")
-			self.add_export_flag("need-libstdc++", True)
+			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_export_path(os.path.join(target.path_ndk, "sources", "cxx-stl", "gnu-libstdc++", target.compilator_version, "include"))
+			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_export_path(        os.path.join(stdCppBasePath, "include"))
-				self.add_export_flag("link", os.path.join(stdCppBasePath, "thumb", "libgnustl_static.a"))
-				self.add_export_flag("link", os.path.join(stdCppBasePath, "thumb", "libsupc++.a"))
+				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_export_path(        os.path.join(stdCppBasePath, "include"))
-				self.add_export_flag("link", os.path.join(stdCppBasePath, "thumb", "libgnustl_static.a"))
-				self.add_export_flag("link", os.path.join(stdCppBasePath, "thumb", "libsupc++.a"))
+				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_export_path(        os.path.join(stdCppBasePath, "include/"))
-				self.add_export_flag("link", os.path.join(stdCppBasePath, "libgnustl_static.a"))
-				self.add_export_flag("link", os.path.join(stdCppBasePath, "libsupc++.a"))
+				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_export_path(        os.path.join(stdCppBasePath, "include"))
-				self.add_export_flag("link", os.path.join(stdCppBasePath, "libgnustl_static.a"))
-				self.add_export_flag("link", os.path.join(stdCppBasePath, "libsupc++.a"))
+				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

@@ -11,16 +11,17 @@
 from lutin import debug
 from lutin import system
 from lutin import tools
+from lutin import env
 import os
 
 class System(system.System):
 	def __init__(self, target):
 		system.System.__init__(self)
 		# create some HELP:
-		self.help="M : m library \n base of std libs (availlagle in GNU C lib and bionic"
+		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.valid = True
+		self.set_valid(True)
 		# todo : create a searcher of the presence of the library:
-		self.add_export_flag("link-lib", "m")
+		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

@@ -11,19 +11,25 @@
 from lutin import debug
 from lutin import system
 from lutin import tools
+from lutin import env
 import os
 
 class System(system.System):
 	def __init__(self, target):
 		system.System.__init__(self)
 		# create some HELP:
-		self.help="PULSE : The Linux PulseAudio\n Can be install with the package:\n    - libpulse-dev"
+		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/pulse/pulseaudio.h"):
+		"""
+		if     not os.path.isfile("/usr/include/pthread.h"):
 			# we did not find the library reqiested (just return) (automaticly set at false)
 			return;
-		self.valid = True
+		"""
+		self.set_valid(True)
 		# todo : create a searcher of the presence of the library:
-		self.add_export_flag("link-lib", ["pulse-simple", "pulse"])
+		#self.add_flag("link-lib", "pthread")
+		self.add_depend([
+		    'c'
+		    ])
 
 

lutin/z_system/lutinSystem_Android_z.py

@@ -10,19 +10,20 @@
 from lutin import debug
 from lutin import system
 from lutin import tools
+from lutin import env
 import os
 
 class System(system.System):
 	def __init__(self, target):
 		system.System.__init__(self)
 		# create some HELP:
-		self.help="Z : z library \n Can be install with the package:\n    - zlib1g-dev"
+		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.valid = True
+		self.set_valid(True)
 		# todo : create a searcher of the presence of the library:
-		self.add_export_flag("link-lib", "z")
+		self.add_flag("link-lib", "z")
 
 

lutin/z_system/lutinSystem_IOs_CoreAudio.py

@@ -11,16 +11,17 @@
 from lutin import debug
 from lutin import system
 from lutin import tools
+from lutin import env
 import os
 
 class System(system.System):
 	def __init__(self, target):
 		system.System.__init__(self)
 		# create some HELP:
-		self.help="CoreAudio : Ios interface for audio (all time present, just system interface)"
-		self.valid = True
+		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_export_flag("link", "-framework CoreAudio")
-		self.add_export_flag("link", "-framework AudioToolbox")
+		self.add_flag("link", "-framework CoreAudio")
+		self.add_flag("link", "-framework AudioToolbox")
 
 

lutin/z_system/lutinSystem_IOs_CoreGraphics.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 core graphic (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 CoreGraphics")
+		self.add_depend("UIKit")
+
+

lutin/z_system/lutinSystem_IOs_Foundation.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 fundation (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 Foundation")
+		self.add_depend("QuartzCore")
+
+

lutin/z_system/lutinSystem_IOs_GLKit.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 openGL (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 GLKit")
+		self.add_depend("Foundation")
+
+

lutin/z_system/lutinSystem_IOs_QuartzCore.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 : Ios interface for core application (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 QuartzCore")
+
+

lutin/z_system/lutinSystem_IOs_UIKit.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 graphic UX (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 UIKit")
+		self.add_depend("GLKit")
+
+

lutin/z_system/lutinSystem_IOs_c.py

@@ -0,0 +1,24 @@
+#!/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.add_flag("c-remove","-nodefaultlibs")
+		self.set_valid(True)
+

lutin/z_system/lutinSystem_IOs_cxx.py

@@ -11,17 +11,18 @@
 from lutin import debug
 from lutin import system
 from lutin import tools
+from lutin import env
 import os
 
 class System(system.System):
 	def __init__(self, target):
 		system.System.__init__(self)
 		# create some HELP:
-		self.help = "CXX: Generic C++ library"
-		self.valid = True
+		self.set_help("CXX: Generic C++ library")
+		self.set_valid(True)
 		# no check needed ==> just add this:
-		self.add_export_flag("c++", "-D__STDCPP_LLVM__")
-		self.add_export_flag("c++-remove", "-nostdlib")
-		self.add_export_flag("need-libstdc++", True)
+		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

@@ -11,16 +11,17 @@
 from lutin import debug
 from lutin import system
 from lutin import tools
+from lutin import env
 import os
 
 class System(system.System):
 	def __init__(self, target):
 		system.System.__init__(self)
 		# create some HELP:
-		self.help="M : m library \n base of std libs (availlagle in GNU C lib and bionic"
+		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.valid = True
+		self.set_valid(True)
 		# todo : create a searcher of the presence of the library:
-		self.add_export_flag("link-lib", "m")
+		self.add_flag("link-lib", "m")
 
 

lutin/z_system/lutinSystem_IOs_opengl.py

@@ -0,0 +1,30 @@
+#!/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_flag('link', [
+		    "-framework OpenGLES"])
+	
+

lutin/z_system/lutinSystem_IOs_pthread.py

@@ -0,0 +1,44 @@
+#!/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_SDL.py

@@ -0,0 +1,44 @@
+#!/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("SDL: SDL Gui abstraction")
+		# check if the library exist:
+		if     not os.path.isfile("/usr/include/SDL/SDL.h"):
+			# we did not find the library reqiested (just return) (automaticly set at false)
+			return;
+		self.set_valid(True)
+		self.add_depend([
+		    'opengl',
+		    'c'
+		    ])
+		self.add_flag("link-lib", "SDL")
+		if env.get_isolate_system() == True:
+			self.add_header_file([
+			    "/usr/include/SDL/*",
+			    ],
+			    destination_path="SDL",
+			    recursive=True)
+			self.add_header_file([
+			    "/usr/include/SDL/*",
+			    ],
+			    destination_path="",
+			    recursive=True)
+
+

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

@@ -11,20 +11,36 @@
 from lutin import debug
 from lutin import system
 from lutin import tools
+from lutin import env
 import os
 
 class System(system.System):
 	def __init__(self, target):
 		system.System.__init__(self)
 		# create some HELP:
-		self.help="ALSA : Advanced Linux Sound Architecture\n Can be install with the package:\n    - libasound2-dev"
+		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.valid = True
-		# todo : create a searcher of the presence of the library:
-		self.add_export_flag("link-lib", "asound")
+		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

@@ -11,24 +11,35 @@
 from lutin import debug
 from lutin import system
 from lutin import tools
+from lutin import env
 import os
 
 class System(system.System):
 	def __init__(self, target):
 		system.System.__init__(self)
 		# create some HELP:
-		self.help="BOOST : Boost interface (need when we have not all c++ feature\n Can be install with the package:\n    - libboost-all-dev"
+		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.valid = True
-		# todo : create a searcher of the presence of the library:
-		self.add_export_flag("link-lib", [
-		    "boost_system",
-		    "boost_thread",
-		    "boost_chrono"
-		    ])
+		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

@@ -11,17 +11,40 @@
 from lutin import debug
 from lutin import system
 from lutin import tools
+from lutin import multiprocess
+from lutin import env
 import os
 
 class System(system.System):
 	def __init__(self, target):
 		system.System.__init__(self)
 		# create some HELP:
-		self.help = "CXX: Generic C++ library"
-		self.valid = True
+		self.set_help("CXX: Generic C++ library")
+		self.set_valid(True)
 		# no check needed ==> just add this:
-		self.add_export_flag("c++", "-D__STDCPP_GNU__")
-		self.add_export_flag("c++-remove", "-nostdlib")
-		self.add_export_flag("need-libstdc++", True)
+		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

@@ -11,19 +11,29 @@
 from lutin import debug
 from lutin import system
 from lutin import tools
+from lutin import env
 import os
 
 class System(system.System):
 	def __init__(self, target):
 		system.System.__init__(self)
 		# create some HELP:
-		self.help="JACK : Jack Low-Latency Audio Server\n Can be install with the package:\n    - libjack-jackd2-dev (new)\n    - libjack-dev (old)"
+		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.valid = True
-		# todo : create a searcher of the presence of the library:
-		self.add_export_flag("link-lib", "jack")
+		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

@@ -11,16 +11,27 @@
 from lutin import debug
 from lutin import system
 from lutin import tools
+from lutin import env
 import os
 
 class System(system.System):
 	def __init__(self, target):
 		system.System.__init__(self)
 		# create some HELP:
-		self.help="M : m library \n base of std libs (availlagle in GNU C lib and bionic"
+		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.valid = True
+		self.set_valid(True)
 		# todo : create a searcher of the presence of the library:
-		self.add_export_flag("link-lib", "m")
+		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,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("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)
+	
+
+

lutin/z_system/lutinSystem_Linux_oss.py

@@ -11,21 +11,22 @@
 from lutin import debug
 from lutin import system
 from lutin import tools
+from lutin import env
 import os
 
 class System(system.System):
 	def __init__(self, target):
 		system.System.__init__(self)
 		# create some HELP:
-		self.help="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("link-lib", "oss")
+		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_va.py

@@ -0,0 +1,42 @@
+#!/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("va : Video Acceleration")
+		# check if the library exist:
+		if not os.path.isfile("/usr/include/va/va.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)
+		self.add_depend([
+		    'X11'
+		    ])
+		self.add_flag("link-lib", ["va", "va-drm", "va-x11"])
+		if env.get_isolate_system() == True:
+			#self.add_flag("link-lib", "xns")
+			self.add_header_file([
+			    "/usr/include/va/*"
+			    ],
+			    destination_path="va",
+			    recursive=True)
+		
+
+
+

lutin/z_system/lutinSystem_Linux_vdpau.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("vdpau : Video decaudatge hardware Acceleration")
+		# check if the library exist:
+		if not os.path.isfile("/usr/include/vdpau/vdpau.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)
+		self.add_flag("link-lib", "vdpau")
+		self.add_depend([
+		    'X11'
+		    ])
+		if env.get_isolate_system() == True:
+			self.add_header_file([
+			    "/usr/include/vdpau/*"
+			    ],
+			    destination_path="vdpau",
+			    recursive=True)
+		
+
+
+

lutin/z_system/lutinSystem_Linux_z.py

@@ -11,19 +11,29 @@
 from lutin import debug
 from lutin import system
 from lutin import tools
+from lutin import env
 import os
 
 class System(system.System):
 	def __init__(self, target):
 		system.System.__init__(self)
 		# create some HELP:
-		self.help="Z : z library \n Can be install with the package:\n    - zlib1g-dev"
+		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.valid = True
+		self.set_valid(True)
 		# todo : create a searcher of the presence of the library:
-		self.add_export_flag("link-lib", "z")
+		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_AVFoundation.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("OpenGL: Generic graphic library")
+		self.set_valid(True)
+		# no check needed ==> just add this:
+		self.add_depend([
+		    'c'
+		    ])
+		self.add_flag('link', [
+		    "-framework AVFoundation"
+		    ])
+	
+
+

lutin/z_system/lutinSystem_MacOs_AppKit.py

@@ -0,0 +1,25 @@
+#!/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 application builder kit (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 AppKit")
+

lutin/z_system/lutinSystem_MacOs_Cocoa.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 basic cocoa graphic (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 Cocoa")
+		self.add_depend("QuartzCore")
+

lutin/z_system/lutinSystem_MacOs_CoreAudio.py

@@ -11,15 +11,16 @@
 from lutin import debug
 from lutin import system
 from lutin import tools
+from lutin import env
 import os
 
 class System(system.System):
 	def __init__(self, target):
 		system.System.__init__(self)
 		# create some HELP:
-		self.help="CoreAudio : MacOs interface for audio (all time present, just system interface)"
-		self.valid = True
+		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_export_flag("link", "-framework CoreAudio")
-		self.add_export_flag("link", "-framework CoreFoundation")
+		self.add_flag("link", "-framework CoreAudio")
+		self.add_flag("link", "-framework CoreFoundation")
 

lutin/z_system/lutinSystem_MacOs_CoreGraphics.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("OpenGL: Generic graphic library")
+		self.set_valid(True)
+		# no check needed ==> just add this:
+		self.add_depend([
+		    'c'
+		    ])
+		self.add_flag('link', [
+		    "-framework CoreGraphics"
+		    ])
+	
+
+

lutin/z_system/lutinSystem_MacOs_CoreMedia.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("OpenGL: Generic graphic library")
+		self.set_valid(True)
+		# no check needed ==> just add this:
+		self.add_depend([
+		    'c'
+		    ])
+		self.add_flag('link', [
+		    "-framework CoreMedia"
+		    ])
+	
+
+

lutin/z_system/lutinSystem_MacOs_CoreServices.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("OpenGL: Generic graphic library")
+		self.set_valid(True)
+		# no check needed ==> just add this:
+		self.add_depend([
+		    'c'
+		    ])
+		self.add_flag('link', [
+		    "-framework CoreServices"
+		    ])
+	
+
+

lutin/z_system/lutinSystem_MacOs_CoreVideo.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("OpenGL: Generic graphic library")
+		self.set_valid(True)
+		# no check needed ==> just add this:
+		self.add_depend([
+		    'c'
+		    ])
+		self.add_flag('link', [
+		    "-framework CoreVideo"
+		    ])
+	
+
+

lutin/z_system/lutinSystem_MacOs_Foundation.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 fundation (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 Foundation")
+		self.add_depend("QuartzCore")
+
+

lutin/z_system/lutinSystem_MacOs_QuartzCore.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("QuartzCore : MacOs interface for base application (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 QuartzCore")
+		self.add_depend("AppKit")
+

lutin/z_system/lutinSystem_MacOs_VideoDecodeAcceleration.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("OpenGL: Generic graphic library")
+		self.set_valid(True)
+		# no check needed ==> just add this:
+		self.add_depend([
+		    'c'
+		    ])
+		self.add_flag('link', [
+		    "-framework VideoDecodeAcceleration"
+		    ])
+	
+
+

lutin/z_system/lutinSystem_MacOs_c.py

@@ -0,0 +1,24 @@
+#!/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.add_flag("c-remove","-nodefaultlibs")
+		self.set_valid(True)
+

lutin/z_system/lutinSystem_MacOs_cxx.py

@@ -11,17 +11,19 @@
 from lutin import debug
 from lutin import system
 from lutin import tools
+from lutin import env
 import os
 
 class System(system.System):
 	def __init__(self, target):
 		system.System.__init__(self)
 		# create some HELP:
-		self.help = "CXX: Generic C++ library"
-		self.valid = True
+		self.set_help("CXX: Generic C++ library")
+		self.set_valid(True)
 		# no check needed ==> just add this:
-		self.add_export_flag("c++","-D__STDCPP_LLVM__")
-		self.add_export_flag("c++-remove","-nostdlib")
-		self.add_export_flag("need-libstdc++", True)
+		self.add_depend("c")
+		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

@@ -11,16 +11,17 @@
 from lutin import debug
 from lutin import system
 from lutin import tools
+from lutin import env
 import os
 
 class System(system.System):
 	def __init__(self, target):
 		system.System.__init__(self)
 		# create some HELP:
-		self.help="M : m library \n base of std libs (availlagle in GNU C lib and bionic"
+		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.valid = True
+		self.set_valid(True)
 		# todo : create a searcher of the presence of the library:
-		self.add_export_flag("link-lib", "m")
+		self.add_flag("link-lib", "m")
 
 

lutin/z_system/lutinSystem_MacOs_opengl.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("OpenGL: Generic graphic library")
+		self.set_valid(True)
+		# no check needed ==> just add this:
+		self.add_depend([
+		    'c'
+		    ])
+		self.add_flag('link', [
+		    "-framework OpenGL"
+		    ])
+	
+
+

lutin/z_system/lutinSystem_MacOs_pthread.py

@@ -0,0 +1,44 @@
+#!/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_Windows_advapi.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("advapi interface")
+		self.set_valid(True)
+		self.add_flag('link-lib', 'advapi32')
+		
+
+

lutin/z_system/lutinSystem_Windows_avicap.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("avicap interface")
+		self.set_valid(True)
+		self.add_flag('link-lib', 'avicap32')
+		
+
+

lutin/z_system/lutinSystem_Windows_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_Windows_cxx.py

@@ -11,23 +11,24 @@
 from lutin import debug
 from lutin import system
 from lutin import tools
+from lutin import env
 import os
 
 class System(system.System):
 	def __init__(self, target):
 		system.System.__init__(self)
 		# create some HELP:
-		self.help = "CXX: Generic C++ library"
-		self.valid = True
+		self.set_help("CXX: Generic C++ library")
+		self.set_valid(True)
 		# no check needed ==> just add this:
-		self.add_export_flag("c++","-D__STDCPP_GNU__")
-		self.add_export_flag("c++-remove","-nostdlib")
+		self.add_flag("c++","-D__STDCPP_GNU__")
+		self.add_flag("c++-remove","-nostdlib")
 		# force static link to prenvent many errors ...
-		self.add_export_flag("link", [
+		self.add_flag("link", [
 		    "-static-libgcc",
 		    "-static-libstdc++",
 		    "-static"
 		    ])
-		self.add_export_flag("need-libstdc++", True)
+		self.add_flag("need-libstdc++", True)
 
 

lutin/z_system/lutinSystem_Windows_ds.py

@@ -11,20 +11,21 @@
 from lutin import debug
 from lutin import system
 from lutin import tools
+from lutin import env
 import os
 
 class System(system.System):
 	def __init__(self, target):
 		system.System.__init__(self)
 		# create some HELP:
-		self.help="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("link-lib",[
+		self.add_flag("link-lib",[
 		    "dsound",
 		    "winmm",
 		    "ole32"

lutin/z_system/lutinSystem_Windows_gdi.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("OpenGL: Generic graphic library")
+		self.set_valid(True)
+		self.add_flag('link-lib', 'gdi32')
+		
+
+

lutin/z_system/lutinSystem_Windows_kernel.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("OpenGL: Generic graphic library")
+		self.set_valid(True)
+		self.add_flag('link-lib', 'kernel32')
+		
+
+

lutin/z_system/lutinSystem_Windows_m.py

@@ -11,16 +11,17 @@
 from lutin import debug
 from lutin import system
 from lutin import tools
+from lutin import env
 import os
 
 class System(system.System):
 	def __init__(self, target):
 		system.System.__init__(self)
 		# create some HELP:
-		self.help="M : m library \n base of std libs (availlagle in GNU C lib and bionic"
+		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.valid = True
+		self.set_valid(True)
 		# todo : create a searcher of the presence of the library:
-		self.add_export_flag("link-lib", "m")
+		self.add_flag("link-lib", "m")
 
 

lutin/z_system/lutinSystem_Windows_ole.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("ole interface")
+		self.set_valid(True)
+		self.add_flag('link-lib', 'ole32')
+		
+
+

lutin/z_system/lutinSystem_Windows_oleaut.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("oleaut interface")
+		self.set_valid(True)
+		self.add_flag('link-lib', 'oleaut32')
+		
+
+

lutin/z_system/lutinSystem_Windows_opengl.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("OpenGL: Generic graphic library")
+		self.set_valid(True)
+		self.add_depend([
+		    'c'
+		    ])
+		self.add_flag('link-lib', 'opengl32')
+		if env.get_isolate_system() == True:
+			self.add_header_file([
+			    "/usr/" + target.base_path + "/include/GL/*"
+			    ],
+			    destination_path="GL",
+			    recursive=True)
+
+

lutin/z_system/lutinSystem_Windows_psapi.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("psapi interface ")
+		self.set_valid(True)
+		self.add_flag('link-lib', 'psapi')
+		
+
+