Compare commits
No commits in common. "0.1" and "main" have entirely different histories.
9
.gitignore
vendored
Normal file
9
.gitignore
vendored
Normal file
@ -0,0 +1,9 @@
|
||||
# Compiled python modules.
|
||||
*.pyc
|
||||
|
||||
# Setuptools distribution folder.
|
||||
/dist/
|
||||
/build/
|
||||
|
||||
# Python egg metadata, regenerated from source files by setuptools.
|
||||
/*.egg-info
|
||||
34
.gitlab-ci.yml
Normal file
34
.gitlab-ci.yml
Normal file
@ -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
|
||||
74
.travis.yml
Normal file
74
.travis.yml
Normal file
@ -0,0 +1,74 @@
|
||||
language: cpp
|
||||
|
||||
#sudo: false
|
||||
sudo: required
|
||||
dist: trusty
|
||||
|
||||
branches:
|
||||
only:
|
||||
- master
|
||||
- dev
|
||||
|
||||
addons:
|
||||
apt:
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
packages:
|
||||
- g++-4.9
|
||||
- expect
|
||||
- binutils-mingw-w64-i686 # 32bit MinGW
|
||||
- gcc-mingw-w64-i686
|
||||
- g++-mingw-w64-i686
|
||||
- binutils-mingw-w64-x86-64 # 64bit MinGW
|
||||
- gcc-mingw-w64-x86-64
|
||||
- g++-mingw-w64-x86-64
|
||||
|
||||
matrix:
|
||||
include:
|
||||
- os: linux
|
||||
env: CONF=release BUILDER=gcc TARGET=Linux TAG=Linux COMPILATOR_OPTION="--compilator-version=4.9"
|
||||
compiler: gcc
|
||||
- os: linux
|
||||
env: CONF=debug BUILDER=clang TARGET=Linux
|
||||
compiler: clang
|
||||
- os: linux
|
||||
env: CONF=release BUILDER=gcc TARGET=Windows TAG=Mingw
|
||||
compiler: x86_64-w64-mingw32-gcc
|
||||
- os: linux
|
||||
env: CONF=release BUILDER=gcc TARGET=Android TAG=Android DISABLE_PACKAGE=-p
|
||||
compiler: gcc
|
||||
- os: osx
|
||||
env: CONF=release BUILDER=clang TARGET=MacOs TAG=MacOs
|
||||
compiler: clang
|
||||
- os: osx
|
||||
env: CONF=release BUILDER=clang TARGET=IOs TAG=IOs
|
||||
compiler: clang
|
||||
|
||||
install:
|
||||
- ./setup.py build
|
||||
- export PYTHONPATH=$PYTHONPATH:./lutin/build/lib.linux-x86_64-2.7/:./lutin/build/lib.linux-x86_64-2.7/lutin/:./lutin/build/lib:./lutin/build/lib/lutin/
|
||||
- cd ..
|
||||
# download NDK
|
||||
- if [ "$TAG" == "Android" ]; then
|
||||
git clone --depth 1 --branch master https://github.com/HeeroYui/android-download-tool;
|
||||
./android-download-tool/dl-android.sh;
|
||||
fi
|
||||
- git clone --depth 1 --branch master https://github.com/atria-soft/ci.git
|
||||
- cd -
|
||||
|
||||
before_script:
|
||||
- cd ..
|
||||
- pwd
|
||||
- ls -l
|
||||
- if [ "$TRAVIS_OS_NAME" == "osx" ]; then
|
||||
export PATH=$PATH:/Users/travis/Library/Python/2.7/bin/;
|
||||
fi
|
||||
- ./ci/build_send.py --tag=$TAG --status=START;
|
||||
|
||||
script:
|
||||
- ./lutin/build/scripts-2.7/lutin -w -j4 -C -P -t $TARGET -c $BUILDER $COMPILATOR_OPTION $BUS -m $CONF $GCOV $DISABLE_PACKAGE test-c; STATUS=$?
|
||||
- ./ci/build_send.py --tag=$TAG --status="$STATUS";
|
||||
|
||||
notifications:
|
||||
email:
|
||||
- yui.heero@gmail.com
|
||||
373
LICENSE
Normal file
373
LICENSE
Normal file
@ -0,0 +1,373 @@
|
||||
Mozilla Public License Version 2.0
|
||||
==================================
|
||||
|
||||
1. Definitions
|
||||
--------------
|
||||
|
||||
1.1. "Contributor"
|
||||
means each individual or legal entity that creates, contributes to
|
||||
the creation of, or owns Covered Software.
|
||||
|
||||
1.2. "Contributor Version"
|
||||
means the combination of the Contributions of others (if any) used
|
||||
by a Contributor and that particular Contributor's Contribution.
|
||||
|
||||
1.3. "Contribution"
|
||||
means Covered Software of a particular Contributor.
|
||||
|
||||
1.4. "Covered Software"
|
||||
means Source Code Form to which the initial Contributor has attached
|
||||
the notice in Exhibit A, the Executable Form of such Source Code
|
||||
Form, and Modifications of such Source Code Form, in each case
|
||||
including portions thereof.
|
||||
|
||||
1.5. "Incompatible With Secondary Licenses"
|
||||
means
|
||||
|
||||
(a) that the initial Contributor has attached the notice described
|
||||
in Exhibit B to the Covered Software; or
|
||||
|
||||
(b) that the Covered Software was made available under the terms of
|
||||
version 1.1 or earlier of the License, but not also under the
|
||||
terms of a Secondary License.
|
||||
|
||||
1.6. "Executable Form"
|
||||
means any form of the work other than Source Code Form.
|
||||
|
||||
1.7. "Larger Work"
|
||||
means a work that combines Covered Software with other material, in
|
||||
a separate file or files, that is not Covered Software.
|
||||
|
||||
1.8. "License"
|
||||
means this document.
|
||||
|
||||
1.9. "Licensable"
|
||||
means having the right to grant, to the maximum extent possible,
|
||||
whether at the time of the initial grant or subsequently, any and
|
||||
all of the rights conveyed by this License.
|
||||
|
||||
1.10. "Modifications"
|
||||
means any of the following:
|
||||
|
||||
(a) any file in Source Code Form that results from an addition to,
|
||||
deletion from, or modification of the contents of Covered
|
||||
Software; or
|
||||
|
||||
(b) any new file in Source Code Form that contains any Covered
|
||||
Software.
|
||||
|
||||
1.11. "Patent Claims" of a Contributor
|
||||
means any patent claim(s), including without limitation, method,
|
||||
process, and apparatus claims, in any patent Licensable by such
|
||||
Contributor that would be infringed, but for the grant of the
|
||||
License, by the making, using, selling, offering for sale, having
|
||||
made, import, or transfer of either its Contributions or its
|
||||
Contributor Version.
|
||||
|
||||
1.12. "Secondary License"
|
||||
means either the GNU General Public License, Version 2.0, the GNU
|
||||
Lesser General Public License, Version 2.1, the GNU Affero General
|
||||
Public License, Version 3.0, or any later versions of those
|
||||
licenses.
|
||||
|
||||
1.13. "Source Code Form"
|
||||
means the form of the work preferred for making modifications.
|
||||
|
||||
1.14. "You" (or "Your")
|
||||
means an individual or a legal entity exercising rights under this
|
||||
License. For legal entities, "You" includes any entity that
|
||||
controls, is controlled by, or is under common control with You. For
|
||||
purposes of this definition, "control" means (a) the power, direct
|
||||
or indirect, to cause the direction or management of such entity,
|
||||
whether by contract or otherwise, or (b) ownership of more than
|
||||
fifty percent (50%) of the outstanding shares or beneficial
|
||||
ownership of such entity.
|
||||
|
||||
2. License Grants and Conditions
|
||||
--------------------------------
|
||||
|
||||
2.1. Grants
|
||||
|
||||
Each Contributor hereby grants You a world-wide, royalty-free,
|
||||
non-exclusive license:
|
||||
|
||||
(a) under intellectual property rights (other than patent or trademark)
|
||||
Licensable by such Contributor to use, reproduce, make available,
|
||||
modify, display, perform, distribute, and otherwise exploit its
|
||||
Contributions, either on an unmodified basis, with Modifications, or
|
||||
as part of a Larger Work; and
|
||||
|
||||
(b) under Patent Claims of such Contributor to make, use, sell, offer
|
||||
for sale, have made, import, and otherwise transfer either its
|
||||
Contributions or its Contributor Version.
|
||||
|
||||
2.2. Effective Date
|
||||
|
||||
The licenses granted in Section 2.1 with respect to any Contribution
|
||||
become effective for each Contribution on the date the Contributor first
|
||||
distributes such Contribution.
|
||||
|
||||
2.3. Limitations on Grant Scope
|
||||
|
||||
The licenses granted in this Section 2 are the only rights granted under
|
||||
this License. No additional rights or licenses will be implied from the
|
||||
distribution or licensing of Covered Software under this License.
|
||||
Notwithstanding Section 2.1(b) above, no patent license is granted by a
|
||||
Contributor:
|
||||
|
||||
(a) for any code that a Contributor has removed from Covered Software;
|
||||
or
|
||||
|
||||
(b) for infringements caused by: (i) Your and any other third party's
|
||||
modifications of Covered Software, or (ii) the combination of its
|
||||
Contributions with other software (except as part of its Contributor
|
||||
Version); or
|
||||
|
||||
(c) under Patent Claims infringed by Covered Software in the absence of
|
||||
its Contributions.
|
||||
|
||||
This License does not grant any rights in the trademarks, service marks,
|
||||
or logos of any Contributor (except as may be necessary to comply with
|
||||
the notice requirements in Section 3.4).
|
||||
|
||||
2.4. Subsequent Licenses
|
||||
|
||||
No Contributor makes additional grants as a result of Your choice to
|
||||
distribute the Covered Software under a subsequent version of this
|
||||
License (see Section 10.2) or under the terms of a Secondary License (if
|
||||
permitted under the terms of Section 3.3).
|
||||
|
||||
2.5. Representation
|
||||
|
||||
Each Contributor represents that the Contributor believes its
|
||||
Contributions are its original creation(s) or it has sufficient rights
|
||||
to grant the rights to its Contributions conveyed by this License.
|
||||
|
||||
2.6. Fair Use
|
||||
|
||||
This License is not intended to limit any rights You have under
|
||||
applicable copyright doctrines of fair use, fair dealing, or other
|
||||
equivalents.
|
||||
|
||||
2.7. Conditions
|
||||
|
||||
Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
|
||||
in Section 2.1.
|
||||
|
||||
3. Responsibilities
|
||||
-------------------
|
||||
|
||||
3.1. Distribution of Source Form
|
||||
|
||||
All distribution of Covered Software in Source Code Form, including any
|
||||
Modifications that You create or to which You contribute, must be under
|
||||
the terms of this License. You must inform recipients that the Source
|
||||
Code Form of the Covered Software is governed by the terms of this
|
||||
License, and how they can obtain a copy of this License. You may not
|
||||
attempt to alter or restrict the recipients' rights in the Source Code
|
||||
Form.
|
||||
|
||||
3.2. Distribution of Executable Form
|
||||
|
||||
If You distribute Covered Software in Executable Form then:
|
||||
|
||||
(a) such Covered Software must also be made available in Source Code
|
||||
Form, as described in Section 3.1, and You must inform recipients of
|
||||
the Executable Form how they can obtain a copy of such Source Code
|
||||
Form by reasonable means in a timely manner, at a charge no more
|
||||
than the cost of distribution to the recipient; and
|
||||
|
||||
(b) You may distribute such Executable Form under the terms of this
|
||||
License, or sublicense it under different terms, provided that the
|
||||
license for the Executable Form does not attempt to limit or alter
|
||||
the recipients' rights in the Source Code Form under this License.
|
||||
|
||||
3.3. Distribution of a Larger Work
|
||||
|
||||
You may create and distribute a Larger Work under terms of Your choice,
|
||||
provided that You also comply with the requirements of this License for
|
||||
the Covered Software. If the Larger Work is a combination of Covered
|
||||
Software with a work governed by one or more Secondary Licenses, and the
|
||||
Covered Software is not Incompatible With Secondary Licenses, this
|
||||
License permits You to additionally distribute such Covered Software
|
||||
under the terms of such Secondary License(s), so that the recipient of
|
||||
the Larger Work may, at their option, further distribute the Covered
|
||||
Software under the terms of either this License or such Secondary
|
||||
License(s).
|
||||
|
||||
3.4. Notices
|
||||
|
||||
You may not remove or alter the substance of any license notices
|
||||
(including copyright notices, patent notices, disclaimers of warranty,
|
||||
or limitations of liability) contained within the Source Code Form of
|
||||
the Covered Software, except that You may alter any license notices to
|
||||
the extent required to remedy known factual inaccuracies.
|
||||
|
||||
3.5. Application of Additional Terms
|
||||
|
||||
You may choose to offer, and to charge a fee for, warranty, support,
|
||||
indemnity or liability obligations to one or more recipients of Covered
|
||||
Software. However, You may do so only on Your own behalf, and not on
|
||||
behalf of any Contributor. You must make it absolutely clear that any
|
||||
such warranty, support, indemnity, or liability obligation is offered by
|
||||
You alone, and You hereby agree to indemnify every Contributor for any
|
||||
liability incurred by such Contributor as a result of warranty, support,
|
||||
indemnity or liability terms You offer. You may include additional
|
||||
disclaimers of warranty and limitations of liability specific to any
|
||||
jurisdiction.
|
||||
|
||||
4. Inability to Comply Due to Statute or Regulation
|
||||
---------------------------------------------------
|
||||
|
||||
If it is impossible for You to comply with any of the terms of this
|
||||
License with respect to some or all of the Covered Software due to
|
||||
statute, judicial order, or regulation then You must: (a) comply with
|
||||
the terms of this License to the maximum extent possible; and (b)
|
||||
describe the limitations and the code they affect. Such description must
|
||||
be placed in a text file included with all distributions of the Covered
|
||||
Software under this License. Except to the extent prohibited by statute
|
||||
or regulation, such description must be sufficiently detailed for a
|
||||
recipient of ordinary skill to be able to understand it.
|
||||
|
||||
5. Termination
|
||||
--------------
|
||||
|
||||
5.1. The rights granted under this License will terminate automatically
|
||||
if You fail to comply with any of its terms. However, if You become
|
||||
compliant, then the rights granted under this License from a particular
|
||||
Contributor are reinstated (a) provisionally, unless and until such
|
||||
Contributor explicitly and finally terminates Your grants, and (b) on an
|
||||
ongoing basis, if such Contributor fails to notify You of the
|
||||
non-compliance by some reasonable means prior to 60 days after You have
|
||||
come back into compliance. Moreover, Your grants from a particular
|
||||
Contributor are reinstated on an ongoing basis if such Contributor
|
||||
notifies You of the non-compliance by some reasonable means, this is the
|
||||
first time You have received notice of non-compliance with this License
|
||||
from such Contributor, and You become compliant prior to 30 days after
|
||||
Your receipt of the notice.
|
||||
|
||||
5.2. If You initiate litigation against any entity by asserting a patent
|
||||
infringement claim (excluding declaratory judgment actions,
|
||||
counter-claims, and cross-claims) alleging that a Contributor Version
|
||||
directly or indirectly infringes any patent, then the rights granted to
|
||||
You by any and all Contributors for the Covered Software under Section
|
||||
2.1 of this License shall terminate.
|
||||
|
||||
5.3. In the event of termination under Sections 5.1 or 5.2 above, all
|
||||
end user license agreements (excluding distributors and resellers) which
|
||||
have been validly granted by You or Your distributors under this License
|
||||
prior to termination shall survive termination.
|
||||
|
||||
************************************************************************
|
||||
* *
|
||||
* 6. Disclaimer of Warranty *
|
||||
* ------------------------- *
|
||||
* *
|
||||
* Covered Software is provided under this License on an "as is" *
|
||||
* basis, without warranty of any kind, either expressed, implied, or *
|
||||
* statutory, including, without limitation, warranties that the *
|
||||
* Covered Software is free of defects, merchantable, fit for a *
|
||||
* particular purpose or non-infringing. The entire risk as to the *
|
||||
* quality and performance of the Covered Software is with You. *
|
||||
* Should any Covered Software prove defective in any respect, You *
|
||||
* (not any Contributor) assume the cost of any necessary servicing, *
|
||||
* repair, or correction. This disclaimer of warranty constitutes an *
|
||||
* essential part of this License. No use of any Covered Software is *
|
||||
* authorized under this License except under this disclaimer. *
|
||||
* *
|
||||
************************************************************************
|
||||
|
||||
************************************************************************
|
||||
* *
|
||||
* 7. Limitation of Liability *
|
||||
* -------------------------- *
|
||||
* *
|
||||
* Under no circumstances and under no legal theory, whether tort *
|
||||
* (including negligence), contract, or otherwise, shall any *
|
||||
* Contributor, or anyone who distributes Covered Software as *
|
||||
* permitted above, be liable to You for any direct, indirect, *
|
||||
* special, incidental, or consequential damages of any character *
|
||||
* including, without limitation, damages for lost profits, loss of *
|
||||
* goodwill, work stoppage, computer failure or malfunction, or any *
|
||||
* and all other commercial damages or losses, even if such party *
|
||||
* shall have been informed of the possibility of such damages. This *
|
||||
* limitation of liability shall not apply to liability for death or *
|
||||
* personal injury resulting from such party's negligence to the *
|
||||
* extent applicable law prohibits such limitation. Some *
|
||||
* jurisdictions do not allow the exclusion or limitation of *
|
||||
* incidental or consequential damages, so this exclusion and *
|
||||
* limitation may not apply to You. *
|
||||
* *
|
||||
************************************************************************
|
||||
|
||||
8. Litigation
|
||||
-------------
|
||||
|
||||
Any litigation relating to this License may be brought only in the
|
||||
courts of a jurisdiction where the defendant maintains its principal
|
||||
place of business and such litigation shall be governed by laws of that
|
||||
jurisdiction, without reference to its conflict-of-law provisions.
|
||||
Nothing in this Section shall prevent a party's ability to bring
|
||||
cross-claims or counter-claims.
|
||||
|
||||
9. Miscellaneous
|
||||
----------------
|
||||
|
||||
This License represents the complete agreement concerning the subject
|
||||
matter hereof. If any provision of this License is held to be
|
||||
unenforceable, such provision shall be reformed only to the extent
|
||||
necessary to make it enforceable. Any law or regulation which provides
|
||||
that the language of a contract shall be construed against the drafter
|
||||
shall not be used to construe this License against a Contributor.
|
||||
|
||||
10. Versions of the License
|
||||
---------------------------
|
||||
|
||||
10.1. New Versions
|
||||
|
||||
Mozilla Foundation is the license steward. Except as provided in Section
|
||||
10.3, no one other than the license steward has the right to modify or
|
||||
publish new versions of this License. Each version will be given a
|
||||
distinguishing version number.
|
||||
|
||||
10.2. Effect of New Versions
|
||||
|
||||
You may distribute the Covered Software under the terms of the version
|
||||
of the License under which You originally received the Covered Software,
|
||||
or under the terms of any subsequent version published by the license
|
||||
steward.
|
||||
|
||||
10.3. Modified Versions
|
||||
|
||||
If you create software not governed by this License, and you want to
|
||||
create a new license for such software, you may create and use a
|
||||
modified version of this License if you rename the license and remove
|
||||
any references to the name of the license steward (except to note that
|
||||
such modified license differs from this License).
|
||||
|
||||
10.4. Distributing Source Code Form that is Incompatible With Secondary
|
||||
Licenses
|
||||
|
||||
If You choose to distribute Source Code Form that is Incompatible With
|
||||
Secondary Licenses under the terms of this version of the License, the
|
||||
notice described in Exhibit B of this License must be attached.
|
||||
|
||||
Exhibit A - Source Code Form License Notice
|
||||
-------------------------------------------
|
||||
|
||||
This Source Code Form is subject to the terms of the Mozilla Public
|
||||
License, v. 2.0. If a copy of the MPL was not distributed with this
|
||||
file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
||||
|
||||
If it is not possible or desirable to put the notice in a particular
|
||||
file, then You may include the notice in a location (such as a LICENSE
|
||||
file in a relevant directory) where a recipient would be likely to look
|
||||
for such a notice.
|
||||
|
||||
You may add additional accurate notices of copyright ownership.
|
||||
|
||||
Exhibit B - "Incompatible With Secondary Licenses" Notice
|
||||
---------------------------------------------------------
|
||||
|
||||
This Source Code Form is "Incompatible With Secondary Licenses", as
|
||||
defined by the Mozilla Public License, v. 2.0.
|
||||
2
MANIFEST.in
Normal file
2
MANIFEST.in
Normal file
@ -0,0 +1,2 @@
|
||||
include README.rst
|
||||
include bash-autocompletion/lutin
|
||||
@ -1,66 +0,0 @@
|
||||
|
||||
|
||||
PROJECT_PACKAGE=$(PROJECT_NAME)package
|
||||
JAVA_FOLDER=src/com/$(PROJECT_VENDOR)/$(PROJECT_NAME)
|
||||
EWOL_JAVA_FOLDER=src/org/ewol
|
||||
|
||||
|
||||
all:
|
||||
@echo "------------------------------------------------------------------------"
|
||||
@echo ' Project name : $(PROJECT_NAME)'
|
||||
@echo ' Project Vendor : $(PROJECT_VENDOR)'
|
||||
@echo ' Build date : $(BUILD_TIME) '
|
||||
@echo ' Tag : $(PROJECT_VERSION_TAG) '
|
||||
@echo "------------------------------------------------------------------------"
|
||||
|
||||
@rm -rf bin
|
||||
|
||||
@echo " (sh) Clear previous sources "
|
||||
@rm -rf src jni/ewolAndroidAbstraction.cpp
|
||||
@echo " (sh) Create folder : $(JAVA_FOLDER)/ & $(EWOL_JAVA_FOLDER)"
|
||||
@mkdir -p $(JAVA_FOLDER)/
|
||||
@mkdir -p $(EWOL_JAVA_FOLDER)/
|
||||
|
||||
@echo " (sh) copy the java Files & Replace __XXX__ element with project properties"
|
||||
@cp $(EWOL_FOLDER)/Java/PROJECT_NAME.java $(JAVA_FOLDER)/$(PROJECT_NAME).java
|
||||
@sed -i "s|__PROJECT_VENDOR__|$(PROJECT_VENDOR)|" $(JAVA_FOLDER)/$(PROJECT_NAME).java
|
||||
@sed -i "s|__PROJECT_NAME__|$(PROJECT_NAME)|" $(JAVA_FOLDER)/$(PROJECT_NAME).java
|
||||
@sed -i "s|__PROJECT_PACKAGE__|$(PROJECT_PACKAGE)|" $(JAVA_FOLDER)/$(PROJECT_NAME).java
|
||||
# copy the Ewol java files :
|
||||
@cp $(EWOL_FOLDER)/Java/interfaceJNI.java $(EWOL_JAVA_FOLDER)/
|
||||
@cp $(EWOL_FOLDER)/Java/interfaceOpenGL.java $(EWOL_JAVA_FOLDER)/
|
||||
@cp $(EWOL_FOLDER)/Java/interfaceSurfaceView.java $(EWOL_JAVA_FOLDER)/
|
||||
@cp $(EWOL_FOLDER)/Java/interfaceAudio.java $(EWOL_JAVA_FOLDER)/
|
||||
|
||||
@echo " (sh) copy the cpp for jni File : $(EWOL_FOLDER)/SourcesJava/ewolAndroidAbstraction.cpp"
|
||||
@cp $(EWOL_FOLDER)/Java/ewolAndroidAbstraction.cpp jni/
|
||||
@sed -i "s|__PROJECT_VENDOR__|$(PROJECT_VENDOR)|" jni/ewolAndroidAbstraction.cpp
|
||||
@sed -i "s|__PROJECT_NAME__|$(PROJECT_NAME)|" jni/ewolAndroidAbstraction.cpp
|
||||
@sed -i "s|__PROJECT_PACKAGE__|$(PROJECT_PACKAGE)|" jni/ewolAndroidAbstraction.cpp
|
||||
|
||||
@echo " (ndk-build) build native code"
|
||||
cd $(PROJECT_NDK) ; NDK_PROJECT_PATH=$(PROJECT_PATH) NDK_MODULE_PATH=$(PROJECT_MODULE) ./ndk-build
|
||||
@echo " (ant) build java code"
|
||||
PATH=$(PROJECT_SDK)/tools/:$(PROJECT_SDK)/platform-tools/:$(PATH) ant -Dsdk.dir=$(PROJECT_SDK) debug
|
||||
@echo " (sh) Clear previous sources "
|
||||
@rm -rf src jni/ewolAndroidAbstraction.cpp
|
||||
|
||||
install: all
|
||||
@echo "------------------------------------------------------------------------"
|
||||
@echo ' INSTALL : ./bin/$(PROJECT_NAME)-debug.apk'
|
||||
@echo "------------------------------------------------------------------------"
|
||||
@# $(PROJECT_SDK)/platform-tools/adb kill-server
|
||||
@# install application
|
||||
sudo $(PROJECT_SDK)/platform-tools/adb install -r ./bin/$(PROJECT_NAME)-debug.apk
|
||||
|
||||
clean:
|
||||
@echo "------------------------------------------------------------------------"
|
||||
@echo ' CLEANING : bin libs gen obj'
|
||||
@echo "------------------------------------------------------------------------"
|
||||
cd $(PROJECT_NDK) ; NDK_PROJECT_PATH=$(PROJECT_PATH) NDK_MODULE_PATH=$(PROJECT_MODULE) ./ndk-build clean
|
||||
|
||||
localclean:
|
||||
@echo "------------------------------------------------------------------------"
|
||||
@echo ' Remove : bin libs gen obj'
|
||||
@echo "------------------------------------------------------------------------"
|
||||
rm -rf bin libs gen obj
|
||||
@ -1,37 +0,0 @@
|
||||
|
||||
USER_PACKAGES += $(EWOL_FOLDER)/Sources/
|
||||
|
||||
include $(EWOL_FOLDER)/Build/coreLinux/main.mk
|
||||
|
||||
|
||||
# http://alp.developpez.com/tutoriels/debian/creer-paquet/
|
||||
#package: .encadrer
|
||||
# @echo 'Create Folders ...'
|
||||
# @mkdir -p package/$(PROJECT_NAME)/DEBIAN/
|
||||
# @mkdir -p package/$(PROJECT_NAME)/usr/bin/
|
||||
# @mkdir -p package/$(PROJECT_NAME)/usr/share/doc/
|
||||
# @mkdir -p package/$(PROJECT_NAME)/usr/share/edn/
|
||||
# # Create the control file
|
||||
# @echo "Package: "$(PROJECT_NAME) > package/$(PROJECT_NAME)/DEBIAN/control
|
||||
# @echo "Version: "$(VERSION_TAG_SHORT) >> package/$(PROJECT_NAME)/DEBIAN/control
|
||||
# @echo "Section: Development,Editors" >> package/$(PROJECT_NAME)/DEBIAN/control
|
||||
# @echo "Priority: optional" >>package/$(PROJECT_NAME)/DEBIAN/control
|
||||
# @echo "Architecture: all" >> package/$(PROJECT_NAME)/DEBIAN/control
|
||||
# @echo "Depends: bash" >> package/$(PROJECT_NAME)/DEBIAN/control
|
||||
# @echo "Maintainer: Mr DUPIN Edouard <yui.heero@gmail.com>" >> package/$(PROJECT_NAME)/DEBIAN/control
|
||||
# @echo "Description: Text editor for sources code with ctags management" >> package/$(PROJECT_NAME)/DEBIAN/control
|
||||
# @echo "" >> package/$(PROJECT_NAME)/DEBIAN/control
|
||||
# # Create the PostRm
|
||||
# @echo "#!/bin/bash" > package/$(PROJECT_NAME)/DEBIAN/postrm
|
||||
# @echo "rm ~/."$(PROJECT_NAME) >> package/$(PROJECT_NAME)/DEBIAN/postrm
|
||||
# @echo "" >> package/$(PROJECT_NAME)/DEBIAN/postrm
|
||||
# # Enable Execution in script
|
||||
# @chmod 755 package/$(PROJECT_NAME)/DEBIAN/post*
|
||||
# @#chmod 755 package/$(PROJECT_NAME)/DEBIAN/pre*
|
||||
# # copy licence and information :
|
||||
# @cp README package/$(PROJECT_NAME)/usr/share/doc/README
|
||||
# @cp licence.txt package/$(PROJECT_NAME)/usr/share/doc/copyright
|
||||
# @echo "First generation in progress" >> package/$(PROJECT_NAME)/usr/share/doc/changelog
|
||||
# @cp -vf $(PROJECT_NAME) package/$(PROJECT_NAME)/usr/bin/
|
||||
# @cp -vf data/*.xml package/$(PROJECT_NAME)/usr/share/edn/
|
||||
# @cd package; dpkg-deb --build $(PROJECT_NAME)
|
||||
35
Makefile.mk
35
Makefile.mk
@ -1,35 +0,0 @@
|
||||
|
||||
###############################################################################
|
||||
### Platform specificity : ###
|
||||
###############################################################################
|
||||
SUPPORTED_PLATFORM=Linux CygWin MacOS IOS Android
|
||||
DEFAULT_PLATFORM=Linux
|
||||
|
||||
# default platform can be overridden
|
||||
PLATFORM?=$(DEFAULT_PLATFORM)
|
||||
|
||||
PROJECT_PATH=$(shell pwd)
|
||||
|
||||
PROJECT_MODULE=$(PROJECT_PATH)/../
|
||||
|
||||
ifeq ($(PLATFORM), Linux)
|
||||
PROJECT_NDK?=$(realpath $(PROJECT_MODULE)/ewol/)
|
||||
else ifeq ($(PLATFORM), MacOS)
|
||||
|
||||
else ifeq ($(PLATFORM), IOS)
|
||||
|
||||
else ifeq ($(PLATFORM), CygWin)
|
||||
|
||||
else ifeq ($(PLATFORM), Android)
|
||||
PROJECT_NDK:=$(PROJECT_MODULE)/android/ndk/
|
||||
PROJECT_SDK:=$(PROJECT_MODULE)/android/sdk/
|
||||
else
|
||||
$(error you must specify a corect platform : make PLATFORM=$(SUPPORTED_PLATFORM))
|
||||
endif
|
||||
|
||||
# get the compilation date and time :
|
||||
BUILD_TIME=$(shell date)
|
||||
|
||||
EWOL_FOLDER?=$(realpath $(PROJECT_MODULE)/ewol)
|
||||
|
||||
include $(EWOL_FOLDER)/Build/Makefile.$(PLATFORM).mk
|
||||
86
README.rst
Normal file
86
README.rst
Normal file
@ -0,0 +1,86 @@
|
||||
Lutin
|
||||
=====
|
||||
|
||||
`lutin` is a generic builder and package maker is a FREE software tool.
|
||||
|
||||
|
||||
.. image:: https://badge.fury.io/py/lutin.png
|
||||
:target: https://pypi.python.org/pypi/lutin
|
||||
|
||||
Release (master)
|
||||
----------------
|
||||
|
||||
.. image:: https://travis-ci.org/HeeroYui/lutin.svg?branch=master
|
||||
:target: https://travis-ci.org/HeeroYui/lutin
|
||||
|
||||
|
||||
|
||||
Developement (dev)
|
||||
------------------
|
||||
|
||||
.. image:: https://travis-ci.org/HeeroYui/lutin.svg?branch=dev
|
||||
:target: https://travis-ci.org/HeeroYui/lutin
|
||||
|
||||
|
||||
Instructions
|
||||
------------
|
||||
|
||||
This is a tool to generate the binary, shared library, static library and package independently of the OS
|
||||
|
||||
This software builds C, C++, m, m++, to object file and generate associated libraries (.so & .a) end create final Executable file
|
||||
|
||||
This tool can generate package for Linux, MacOs, Android
|
||||
|
||||
|
||||
Lutin is under a FREE license that can be found in the COPYING file.
|
||||
Any contribution is more than welcome ;)
|
||||
|
||||
git repository
|
||||
--------------
|
||||
|
||||
http://github.com/HeeroYui/lutin/
|
||||
|
||||
Documentation
|
||||
-------------
|
||||
|
||||
http://HeeroYui.github.io/lutin/
|
||||
|
||||
Installation
|
||||
------------
|
||||
|
||||
Requirements: ``Python >= 2.7`` and ``pip``
|
||||
|
||||
Just run:
|
||||
|
||||
pip install lutin
|
||||
|
||||
Install pip on debian/ubuntu:
|
||||
|
||||
sudo apt-get install pip
|
||||
|
||||
Install pip on ARCH-linux:
|
||||
|
||||
sudo pacman -S pip
|
||||
|
||||
Install pip on MacOs:
|
||||
|
||||
sudo easy_install pip
|
||||
|
||||
|
||||
License (MPL v2.0)
|
||||
---------------------
|
||||
|
||||
Copyright lutin Edouard DUPIN
|
||||
|
||||
Licensed under the Mozilla Public 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
|
||||
|
||||
https://www.mozilla.org/MPL/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.
|
||||
|
||||
90
bash-autocompletion/lutin
Executable file
90
bash-autocompletion/lutin
Executable file
@ -0,0 +1,90 @@
|
||||
_lutin()
|
||||
{
|
||||
local cur prev optshorts opts renameprev listmodule
|
||||
COMPREPLY=()
|
||||
cur="${COMP_WORDS[COMP_CWORD]}"
|
||||
prev="${COMP_WORDS[COMP_CWORD-1]}"
|
||||
optshorts="-h -v -C -f -P -j -s -t -c -m -r -p"
|
||||
opts="--help --verbose --color --force --pretty --jobs --force-strip --target --compilator --mode --prj --package --simulation"
|
||||
|
||||
renameprev=${prev}
|
||||
case "${renameprev}" in
|
||||
-h)
|
||||
renameprev="--help"
|
||||
;;
|
||||
-v)
|
||||
renameprev="--verbose"
|
||||
;;
|
||||
-C)
|
||||
renameprev="--color"
|
||||
;;
|
||||
-f)
|
||||
renameprev="--force"
|
||||
;;
|
||||
-P)
|
||||
renameprev="--pretty"
|
||||
;;
|
||||
-j)
|
||||
renameprev="--jobs"
|
||||
;;
|
||||
-s)
|
||||
renameprev="--force-strip"
|
||||
;;
|
||||
-t)
|
||||
renameprev="--target"
|
||||
;;
|
||||
-c)
|
||||
renameprev="--compilator"
|
||||
;;
|
||||
-m)
|
||||
renameprev="--mode"
|
||||
;;
|
||||
-r)
|
||||
renameprev="--prj"
|
||||
;;
|
||||
-p)
|
||||
renameprev="--package"
|
||||
;;
|
||||
esac
|
||||
#
|
||||
# Complete the arguments to some of the basic commands.
|
||||
#
|
||||
case "${renameprev}" in
|
||||
--compilator)
|
||||
local names="clang gcc"
|
||||
COMPREPLY=( $(compgen -W "${names}" -- ${cur}) )
|
||||
return 0
|
||||
;;
|
||||
--jobs)
|
||||
local names="1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20"
|
||||
COMPREPLY=( $(compgen -W "${names}" -- ${cur}) )
|
||||
return 0
|
||||
;;
|
||||
--target)
|
||||
local names=`lutin --list-target`
|
||||
COMPREPLY=( $(compgen -W "${names}" -- ${cur}) )
|
||||
return 0
|
||||
;;
|
||||
--mode)
|
||||
local names="debug release"
|
||||
COMPREPLY=( $(compgen -W "${names}" -- ${cur}) )
|
||||
return 0
|
||||
;;
|
||||
*)
|
||||
;;
|
||||
esac
|
||||
|
||||
if [[ ${cur} == --* ]] ; then
|
||||
COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
|
||||
return 0
|
||||
fi
|
||||
if [[ ${cur} == -* ]] ; then
|
||||
COMPREPLY=( $(compgen -W "${optshorts}" -- ${cur}) )
|
||||
return 0
|
||||
fi
|
||||
listmodule=`lutin --list-module`
|
||||
COMPREPLY=( $(compgen -W "${listmodule}" -- ${cur}) )
|
||||
return 0
|
||||
}
|
||||
|
||||
complete -F _lutin lutin
|
||||
6
bash-autocompletion/readme
Normal file
6
bash-autocompletion/readme
Normal file
@ -0,0 +1,6 @@
|
||||
|
||||
to install autocompletion for lutin :
|
||||
|
||||
sudo cp bash-autocompletion/lutin /etc/bash_completion.d
|
||||
|
||||
==> and restart bash ...
|
||||
453
bin/lutin
Executable file
453
bin/lutin
Executable file
@ -0,0 +1,453 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
# for path inspection:
|
||||
import sys
|
||||
import os
|
||||
import copy
|
||||
from realog import debug as debug
|
||||
import lutin
|
||||
import death.Arguments as arguments
|
||||
import death.ArgElement as arg_element
|
||||
import lutin.host as host
|
||||
import lutin.module as module
|
||||
import lutin.target as target
|
||||
import lutin.env as env
|
||||
import lutin.multiprocess as multiprocess
|
||||
import lutin.tools as tools
|
||||
import lutin.host as lutinHost
|
||||
import lutin.tools as lutinTools
|
||||
|
||||
myArgs = arguments.Arguments()
|
||||
myArgs.add("h", "help", desc="Display this help")
|
||||
myArgs.add("H", "HELP", desc="Display this help (with all compleate information)")
|
||||
myArgs.add_section("option", "Can be set one time in all case")
|
||||
myArgs.add("v", "verbose", list=[["0","None"],["1","error"],["2","warning"],["3","info"],["4","debug"],["5","verbose"],["6","extreme_verbose"]], desc="display makefile debug level (verbose) default =2")
|
||||
myArgs.add("C", "color", desc="Display makefile output in color")
|
||||
myArgs.add("B", "force-build", desc="Force the rebuild without checking the dependency")
|
||||
myArgs.add("P", "pretty", desc="Print the debug has pretty display")
|
||||
myArgs.add("j", "jobs", haveParam=True, desc="Specifies the number of jobs (commands) to run simultaneously")
|
||||
myArgs.add("d", "depth", haveParam=True, desc="Depth of the search of sub element lutin_*.py (default=" + str(env.get_parse_depth()) + ")")
|
||||
myArgs.add("s", "force-strip", desc="Force the stripping of the compile elements")
|
||||
myArgs.add("o", "force-optimisation", desc="Force optimisation of the build")
|
||||
myArgs.add("w", "warning", desc="Store warning in a file build file")
|
||||
myArgs.add("i", "isolate-system", desc="Isolate system build (copy header of c and c++ system lib to not include unneeded external libs) EXPERIMENTAL (archlinux)")
|
||||
myArgs.add("K", "ccache", desc="Enable the ccache interface")
|
||||
|
||||
myArgs.add_section("properties", "keep in the sequency of the cible")
|
||||
myArgs.add("t", "target", haveParam=True, desc="Select a target (by default the platform is the computer that compile this) To know list : 'lutin.py --list-target'")
|
||||
myArgs.add("c", "compilator", list=[["clang",""],["gcc",""]], desc="Compile with clang or Gcc mode (by default " + 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()
|
||||
|
||||
"""
|
||||
display the help of this makefile
|
||||
"""
|
||||
def usage(full=False):
|
||||
color = debug.get_color_set()
|
||||
# generic argument displayed :
|
||||
myArgs.display()
|
||||
print(" All target can finish with '?clean' '?dump' '?gcov' ... ?action (@ can replace ?)" )
|
||||
print(" " + color['green'] + "all" + color['default'])
|
||||
print(" build all (only for the current selected board) (bynary and packages)")
|
||||
print(" " + color['green'] + "clean" + color['default'])
|
||||
print(" clean all (same as previous)")
|
||||
print(" " + color['green'] + "dump" + color['default'])
|
||||
print(" Dump all the module dependency and properties")
|
||||
print(" " + color['green'] + "dependency" + color['default'])
|
||||
print(" generate a file dependency.dot that represent all the dependency link")
|
||||
print(" Select what in included: 'dependency:LPBDK'")
|
||||
print(" L: Library")
|
||||
print(" P: Pre-build")
|
||||
print(" D: Data")
|
||||
print(" B: Binary")
|
||||
print(" K: Package")
|
||||
print(" eg: lutin dependency:LD ; dot -Tsvg dependency.dot -o dependency.svg ; firefox dependency.svg")
|
||||
print(" " + color['green'] + "gcov" + color['default'])
|
||||
print(" Parse all the code of the library with the gcov resolution")
|
||||
listOfAllModule = module.list_all_module_with_desc()
|
||||
for mod in listOfAllModule:
|
||||
data_print = " "
|
||||
if full == False:
|
||||
if mod["type"] != None \
|
||||
and mod["type"][:6] == "BINARY":
|
||||
data_print += color['blue']
|
||||
if mod["sub-type"] == "":
|
||||
data_print += "* "
|
||||
elif mod["sub-type"] == "TEST":
|
||||
data_print += "T "
|
||||
elif mod["sub-type"] == "TOOLS":
|
||||
data_print += "U "
|
||||
elif mod["sub-type"] == "SAMPLE":
|
||||
data_print += "S "
|
||||
else:
|
||||
data_print += " "
|
||||
elif mod["type"] != None \
|
||||
and mod["type"] == "PACKAGE":
|
||||
data_print += color['red'] + "# "
|
||||
elif mod["type"] != None \
|
||||
and mod["type"][:7] == "LIBRARY":
|
||||
data_print += color['yellow'] + " "
|
||||
else:
|
||||
data_print += color['default'] + " "
|
||||
else:
|
||||
data_print += color['green']
|
||||
data_print += mod["name"] + color['default']
|
||||
if full == False:
|
||||
data_print += "\r\t\t\t\t\t\t\t"
|
||||
if mod["license"] != None \
|
||||
and mod["license"] != "":
|
||||
data_print += color['yellow'] + " [" + mod["license"] + "]" + color['default']
|
||||
if mod["version"] != None \
|
||||
and mod["version"] != []:
|
||||
version_ID = tools.version_to_string(mod["version"])
|
||||
data_print += color['blue'] + " (" + version_ID + ")" + color['default']
|
||||
"""
|
||||
if mod["compagny-type"] != "" \
|
||||
and mod["compagny-name"] != "":
|
||||
data_print += color['purple'] + " " + mod["compagny-type"] + "/" + mod["compagny-name"] + color['default']
|
||||
elif mod["compagny-name"] != "":
|
||||
data_print += color['purple'] + " " + mod["compagny-name"] + color['default']
|
||||
"""
|
||||
|
||||
print(data_print)
|
||||
if mod["description"] != "":
|
||||
print(" " + mod["description"])
|
||||
if full == True:
|
||||
if mod["type"] != None \
|
||||
and mod["type"] != "":
|
||||
print(" Type: " + mod["type"])
|
||||
if mod["sub-type"] != None \
|
||||
and mod["sub-type"] != "":
|
||||
print(" Sub-Type: " + mod["sub-type"])
|
||||
if mod["version"] != None \
|
||||
and mod["version"] != []:
|
||||
version_ID = ""
|
||||
for id in mod["version"]:
|
||||
if len(version_ID) != 0:
|
||||
if type(id) == str:
|
||||
version_ID+="-"
|
||||
else:
|
||||
version_ID+="."
|
||||
version_ID += str(id)
|
||||
print(" version: " + color['blue'] + version_ID + color['default'])
|
||||
if mod["compagny-type"] != None \
|
||||
and mod["compagny-name"] != None \
|
||||
and mod["compagny-type"] != "" \
|
||||
and mod["compagny-name"] != "":
|
||||
print(" compagny: " + color['purple'] + mod["compagny-type"] + "/" + mod["compagny-name"] + color['default'])
|
||||
elif mod["compagny-name"] != None \
|
||||
and mod["compagny-name"] != "":
|
||||
print(" compagny: " + color['purple'] + mod["compagny-name"] + color['default'])
|
||||
if mod["license"] != None \
|
||||
and mod["license"] != "":
|
||||
print(" license: " + color['yellow'] + mod["license"] + color['default'])
|
||||
if mod["maintainer"] != None \
|
||||
and mod["maintainer"] != []:
|
||||
print(" maintainers:")
|
||||
for elem in mod["maintainer"]:
|
||||
print(" " + str(elem))
|
||||
print(" ex simple 1: " + sys.argv[0])
|
||||
print(" ex simple 2: " + sys.argv[0] + " -t Windows")
|
||||
print(" ex multiple platform : " + sys.argv[0] + " all --target=Android all -t Windows -m debug all")
|
||||
print(" ex complex arguments : " + sys.argv[0] + " -cclang -mdebug zeus-package-base?build?run%zeus-launcher:--srv=user:--elog-level=5")
|
||||
print(" ex gcov: " + sys.argv[0] + " -cgcc --gcov -mdebug etk-test?build?run etk?gcov")
|
||||
print(" ex gcov with output: " + sys.argv[0] + " -cgcc --gcov -mdebug etk-test?build?run etk?gcov:output")
|
||||
exit(0)
|
||||
|
||||
def check_boolean(value):
|
||||
if value == "" \
|
||||
or value == "1" \
|
||||
or value == "true" \
|
||||
or value == "True" \
|
||||
or value == True:
|
||||
return True
|
||||
return False
|
||||
|
||||
# preparse the argument to get the verbose element for debug mode
|
||||
def parseGenericArg(argument, active):
|
||||
debug.extreme_verbose("parse arg : " + argument.get_option_name() + " " + argument.get_arg() + " active=" + str(active))
|
||||
if argument.get_option_name() == "help":
|
||||
if active == False:
|
||||
usage()
|
||||
return True
|
||||
if argument.get_option_name() == "HELP":
|
||||
if active == False:
|
||||
usage(True)
|
||||
return True
|
||||
if argument.get_option_name() == "list-module":
|
||||
if active == False:
|
||||
list_of_module = module.list_all_module()
|
||||
retValue = ""
|
||||
for moduleName in list_of_module:
|
||||
if retValue != "":
|
||||
retValue += " "
|
||||
retValue += moduleName
|
||||
print(retValue)
|
||||
exit(0)
|
||||
return True
|
||||
if argument.get_option_name() == "list-target":
|
||||
if active == False:
|
||||
list_of_target = target.list_all_target()
|
||||
retValue = ""
|
||||
for targetName in list_of_target:
|
||||
if retValue != "":
|
||||
retValue += " "
|
||||
retValue += targetName
|
||||
print(retValue)
|
||||
exit(0)
|
||||
return True
|
||||
elif argument.get_option_name()=="jobs":
|
||||
if active == True:
|
||||
multiprocess.set_core_number(int(argument.get_arg()))
|
||||
return True
|
||||
elif argument.get_option_name()=="depth":
|
||||
if active == True:
|
||||
env.set_parse_depth(int(argument.get_arg()))
|
||||
return True
|
||||
elif argument.get_option_name()=="ccache":
|
||||
if active == True:
|
||||
if check_boolean(argument.get_arg()) == True:
|
||||
env.set_ccache(True)
|
||||
else:
|
||||
env.set_ccache(False)
|
||||
return True
|
||||
elif argument.get_option_name() == "verbose":
|
||||
if active == True:
|
||||
debug.set_level(int(argument.get_arg()))
|
||||
return True
|
||||
elif argument.get_option_name() == "color":
|
||||
if active == True:
|
||||
if check_boolean(argument.get_arg()) == True:
|
||||
debug.enable_color()
|
||||
else:
|
||||
debug.disable_color()
|
||||
return True
|
||||
elif argument.get_option_name() == "force-build":
|
||||
if active == True:
|
||||
if check_boolean(argument.get_arg()) == True:
|
||||
env.set_force_mode(True)
|
||||
else:
|
||||
env.set_force_mode(False)
|
||||
return True
|
||||
elif argument.get_option_name() == "pretty":
|
||||
if active == True:
|
||||
if check_boolean(argument.get_arg()) == True:
|
||||
env.set_print_pretty_mode(True)
|
||||
else:
|
||||
env.set_print_pretty_mode(False)
|
||||
return True
|
||||
elif argument.get_option_name() == "force-optimisation":
|
||||
if active == True:
|
||||
if check_boolean(argument.get_arg()) == True:
|
||||
env.set_force_optimisation(True)
|
||||
else:
|
||||
env.set_force_optimisation(False)
|
||||
return True
|
||||
elif argument.get_option_name() == "isolate-system":
|
||||
if active == True:
|
||||
if check_boolean(argument.get_arg()) == True:
|
||||
env.set_isolate_system(True)
|
||||
else:
|
||||
env.set_isolate_system(False)
|
||||
return True
|
||||
elif argument.get_option_name() == "force-strip":
|
||||
if active == True:
|
||||
if check_boolean(argument.get_arg()) == True:
|
||||
env.set_force_strip_mode(True)
|
||||
else:
|
||||
env.set_force_strip_mode(False)
|
||||
return True
|
||||
elif argument.get_option_name() == "warning":
|
||||
if active == True:
|
||||
if check_boolean(argument.get_arg()) == True:
|
||||
env.set_warning_mode(True)
|
||||
else:
|
||||
env.set_warning_mode(False)
|
||||
return True
|
||||
return False
|
||||
|
||||
|
||||
# open configuration of lutin:
|
||||
config_file_name = "lutinConfig.py"
|
||||
config_file = os.path.join(tools.get_run_path(), config_file_name)
|
||||
if os.path.isfile(config_file) == True:
|
||||
sys.path.append(os.path.dirname(config_file))
|
||||
debug.debug("Find basic configuration file: '" + config_file + "'")
|
||||
# the file exist, we can open it and get the initial configuration:
|
||||
configuration_file = __import__(config_file_name[:-3])
|
||||
|
||||
if "get_exclude_path" in dir(configuration_file):
|
||||
data = configuration_file.get_exclude_path()
|
||||
debug.debug(" get default config 'get_exclude_path' val='" + str(data) + "'")
|
||||
env.set_exclude_search_path(data)
|
||||
|
||||
if "get_parsing_depth" in dir(configuration_file):
|
||||
data = configuration_file.get_parsing_depth()
|
||||
debug.debug(" get default config 'get_parsing_depth' val='" + str(data) + "'")
|
||||
parseGenericArg(arg_element.ArgElement("depth", str(data)), True)
|
||||
|
||||
if "get_ccache" in dir(configuration_file):
|
||||
data = configuration_file.get_ccache()
|
||||
debug.debug(" get default config 'get_ccache' val='" + str(data) + "'")
|
||||
parseGenericArg(arg_element.ArgElement("ccache", 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(arg_element.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(arg_element.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(arg_element.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(arg_element.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(arg_element.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(arg_element.ArgElement("isolate-system", str(data)), True)
|
||||
|
||||
|
||||
|
||||
# parse default unique argument:
|
||||
for argument in localArgument:
|
||||
parseGenericArg(argument, True)
|
||||
|
||||
# initialize the system ...
|
||||
lutin.init()
|
||||
|
||||
#available target : Linux / MacOs / Windows / Android ...
|
||||
targetName = host.OS
|
||||
config = {
|
||||
"compilator":lutinHost.HOST_DEFAULT_COMPILATOR,
|
||||
"mode":"release",
|
||||
"bus-size":"auto",
|
||||
"arch":"auto",
|
||||
"generate-package":True,
|
||||
"simulation":False,
|
||||
"gcov":False,
|
||||
"compilator-version":""
|
||||
}
|
||||
# load the default target :
|
||||
my_target = None
|
||||
actionDone=False
|
||||
# parse all argument
|
||||
for argument in localArgument:
|
||||
if parseGenericArg(argument, False) == True:
|
||||
continue
|
||||
elif argument.get_option_name() == "compilator-version":
|
||||
config["compilator-version"] = argument.get_arg()
|
||||
elif argument.get_option_name() == "package":
|
||||
config["generate-package"]=False
|
||||
elif argument.get_option_name() == "simulation":
|
||||
config["simulation"]=True
|
||||
elif argument.get_option_name() == "gcov":
|
||||
config["gcov"]=True
|
||||
elif argument.get_option_name() == "bus":
|
||||
config["bus-size"]=argument.get_arg()
|
||||
elif argument.get_option_name() == "arch":
|
||||
config["arch"]=argument.get_arg()
|
||||
elif argument.get_option_name() == "compilator":
|
||||
if config["compilator"] != argument.get_arg():
|
||||
debug.debug("change compilator ==> " + argument.get_arg())
|
||||
config["compilator"] = argument.get_arg()
|
||||
#remove previous target
|
||||
my_target = None
|
||||
elif argument.get_option_name() == "target":
|
||||
# No check input ==> this will be verify automaticly chen the target will be loaded
|
||||
if targetName != argument.get_arg():
|
||||
targetName = argument.get_arg()
|
||||
debug.debug("change target ==> '" + targetName + "' & reset mode : gcc&release")
|
||||
#reset properties by defauult:
|
||||
config = {
|
||||
"compilator":lutinHost.HOST_DEFAULT_COMPILATOR,
|
||||
"mode":"release",
|
||||
"bus-size":"auto",
|
||||
"arch":"auto",
|
||||
"generate-package":True,
|
||||
"simulation":False,
|
||||
"gcov":False,
|
||||
"compilator-version":""
|
||||
}
|
||||
#remove previous target
|
||||
my_target = None
|
||||
elif argument.get_option_name() == "mode":
|
||||
if config["mode"] != argument.get_arg():
|
||||
config["mode"] = argument.get_arg()
|
||||
debug.debug("change mode ==> " + config["mode"])
|
||||
#remove previous target
|
||||
my_target = None
|
||||
else:
|
||||
argument_value = argument.get_arg()
|
||||
debug.debug("something request : '" + argument_value + "'")
|
||||
if argument.get_option_name() != "":
|
||||
debug.warning("Can not understand argument : '" + argument.get_option_name() + "'")
|
||||
usage()
|
||||
break;
|
||||
name2 = argument_value.replace("@", "?")
|
||||
gettedElement = name2.split("?")
|
||||
module_name = gettedElement[0]
|
||||
action_list = gettedElement[1:]
|
||||
if len(action_list) == 0:
|
||||
action_list = "build"
|
||||
debug.debug("requested: '" + module_name + "' ? actions:'" + str(action_list) + "'")
|
||||
multiple_module_list = []
|
||||
if module_name[-1] == "*":
|
||||
base_name = module_name[:-1]
|
||||
for mod in module.list_all_module():
|
||||
if mod[:len(base_name)] == base_name:
|
||||
debug.verbose("need do it for: " + mod);
|
||||
multiple_module_list.append(mod)
|
||||
else:
|
||||
multiple_module_list.append(module_name)
|
||||
debug.debug("Will do: '" + str(multiple_module_list) + "' ? actions:'" + str(action_list) + "'")
|
||||
for module_name in multiple_module_list:
|
||||
#load the target if needed :
|
||||
if my_target == None:
|
||||
my_target = target.load_target(targetName, copy.deepcopy(config))
|
||||
my_target.build(module_name, actions=action_list)
|
||||
actionDone=True
|
||||
|
||||
# if no action done : we do "all" ...
|
||||
if actionDone==False:
|
||||
#load the target if needed :
|
||||
if my_target == None:
|
||||
my_target = target.load_target(targetName, config)
|
||||
my_target.build("all")
|
||||
|
||||
# stop all started threads;
|
||||
multiprocess.un_init()
|
||||
|
||||
|
||||
@ -1,17 +0,0 @@
|
||||
###############################################################################
|
||||
## @file clearvars.mk
|
||||
## @author Y.M. Morgan
|
||||
## @date 2011/05/14
|
||||
##
|
||||
## Clear out values of all variables used by rule templates.
|
||||
###############################################################################
|
||||
|
||||
# Do NOT clear LOCAL_PATH, it is set BEFORE including this makefile
|
||||
|
||||
$(call clear-vars, $(filter-out LOCAL_PATH,$(modules-LOCALS:%=LOCAL_%)))
|
||||
|
||||
# Trim MAKEFILE_LIST so that $(call my-dir) doesn't need to
|
||||
# iterate over thousands of entries every time.
|
||||
# Leave the current makefile to make sure we don't break anything
|
||||
# that expects to be able to find the name of the current makefile.
|
||||
MAKEFILE_LIST := $(lastword $(MAKEFILE_LIST))
|
||||
BIN
coreLinux/conf
BIN
coreLinux/conf
Binary file not shown.
@ -1,330 +0,0 @@
|
||||
###############################################################################
|
||||
## @file config.mk
|
||||
## @author Y.M. Morgan
|
||||
## @date 2012/07/09
|
||||
##
|
||||
## Configuration management.
|
||||
###############################################################################
|
||||
|
||||
# Tools (absolute path)
|
||||
CONF := KCONFIG_NOTIMESTAMP=1 $(call fullpath,$(BUILD_SYSTEM)/conf)
|
||||
QCONF := KCONFIG_NOTIMESTAMP=1 $(call fullpath,$(BUILD_SYSTEM)/qconf)
|
||||
|
||||
# Directory where original configurations are stored
|
||||
CONFIG_ORIG_DIR := $(TOP_DIR)/config-ymm
|
||||
|
||||
# File where global configuration is stored
|
||||
CONFIG_GLOBAL_FILE := $(CONFIG_ORIG_DIR)/global.config
|
||||
|
||||
###############################################################################
|
||||
## Begin conf/qconf by copying configuration file to a temp .config file.
|
||||
## $1 : configuration file.
|
||||
###############################################################################
|
||||
__begin-conf = \
|
||||
__tmpconfdir=$$(mktemp --directory); \
|
||||
__tmpconf=$${__tmpconfdir}/.config; \
|
||||
if [ -f $1 ]; then \
|
||||
cp -pf $1 $${__tmpconf}; \
|
||||
fi;
|
||||
|
||||
###############################################################################
|
||||
## End conf/qconf by copying temp .config file to configuration file.
|
||||
## $1 : configuration file.
|
||||
###############################################################################
|
||||
__end-conf = \
|
||||
if [ -f $${__tmpconf} ]; then \
|
||||
mv -f $${__tmpconf} $1; \
|
||||
fi; \
|
||||
rm -rf $${__tmpconfdir};
|
||||
|
||||
###############################################################################
|
||||
## Exceute qconf/conf.
|
||||
## $1 : Config.in file.
|
||||
## $2 : options.
|
||||
###############################################################################
|
||||
__exec-conf = (cd $$(dirname $${__tmpconf}) && $(CONF) $2 $1);
|
||||
__exec-qconf = (cd $$(dirname $${__tmpconf}) && $(QCONF) $2 $1);
|
||||
|
||||
###############################################################################
|
||||
## Get the name of the configuration file of a module.
|
||||
## $1 : module name.
|
||||
###############################################################################
|
||||
__get_module-config = $(CONFIG_ORIG_DIR)/$1.config
|
||||
|
||||
###############################################################################
|
||||
## Get the list of path to Config.in files of a module.
|
||||
## $1 : module name.
|
||||
## Remark : should be called only after the module database have been built.
|
||||
###############################################################################
|
||||
__get_module-config-in-files = \
|
||||
$(eval __path := $(__modules.$1.PATH)) \
|
||||
$(eval __files := $(__modules.$1.CONFIG_FILES)) \
|
||||
$(addprefix $(__path)/,$(__files))
|
||||
|
||||
###############################################################################
|
||||
## Begin the update/check operation by creating a temp diff file.
|
||||
###############################################################################
|
||||
__begin-diff = \
|
||||
__tmpdiff=$$(mktemp); \
|
||||
|
||||
###############################################################################
|
||||
## End the update/check operation.
|
||||
## $1 : 1 to exit, 0 or empty to continue.
|
||||
###############################################################################
|
||||
__end-diff = \
|
||||
if [ "$$(stat -c %s $${__tmpdiff})" != "0" ]; then \
|
||||
echo "Configuration diff can be found in $${__tmpdiff}"; \
|
||||
if [ "$1" == "1" ]; then exit 1; fi; \
|
||||
else \
|
||||
rm -f $${__tmpdiff}; \
|
||||
fi;
|
||||
|
||||
###############################################################################
|
||||
## Generate Config.in for global configuration.
|
||||
## $1 : destination file.
|
||||
###############################################################################
|
||||
define __generate-config-in-global
|
||||
rm -f $1; \
|
||||
mkdir -p $(dir $1); \
|
||||
touch $1; \
|
||||
echo "menu Modules" >> $1; \
|
||||
$(foreach __mod,$(__modules), \
|
||||
$(eval __build := BUILD_$(call get-define,$(__mod))) \
|
||||
echo "config $(__build)" >> $1; \
|
||||
echo " bool 'Build $(__mod)'" >> $1; \
|
||||
echo " default y" >> $1; \
|
||||
echo " help" >> $1; \
|
||||
echo " Build $(__mod)" >> $1; \
|
||||
) \
|
||||
echo "endmenu" >> $1;
|
||||
endef
|
||||
|
||||
###############################################################################
|
||||
## Generate Config.in for one module.
|
||||
## $1 : destination file.
|
||||
## $2 : module name.
|
||||
## $3 : list of path to Config.in files.
|
||||
###############################################################################
|
||||
define __generate-config-in-module
|
||||
rm -f $1; \
|
||||
mkdir -p $(dir $1); \
|
||||
touch $1; \
|
||||
echo "menu $2" >> $1; \
|
||||
$(if $(strip $3), \
|
||||
$(foreach __f,$3, \
|
||||
echo "source $(call fullpath,$(__f))" >> $1; \
|
||||
) \
|
||||
) \
|
||||
echo "endmenu" >> $1;
|
||||
endef
|
||||
|
||||
###############################################################################
|
||||
## Update a configuration automatically.
|
||||
## $1 Config.in input file.
|
||||
## $2 current config file.
|
||||
## $3 update config file (can be the same as $2).
|
||||
###############################################################################
|
||||
define __update-config-internal
|
||||
$(call __begin-conf,$2,) \
|
||||
(yes "" | $(call __exec-conf,$1,-o)) > /dev/null; \
|
||||
$(call __end-conf,$3)
|
||||
endef
|
||||
|
||||
###############################################################################
|
||||
## Update a configuration automatically.
|
||||
## $1 Config.in input file.
|
||||
## $2 current config file.
|
||||
###############################################################################
|
||||
define __update-config
|
||||
__tmpcheck=$$(mktemp); \
|
||||
$(call __update-config-internal,$1,$2,$${__tmpcheck}) \
|
||||
if ! cmp -s $2 $${__tmpcheck}; then \
|
||||
cp -pf $${__tmpcheck} $2; \
|
||||
echo "Configuration file $2 has been updated"; \
|
||||
fi; \
|
||||
rm -f $${__tmpcheck};
|
||||
endef
|
||||
|
||||
###############################################################################
|
||||
## Check a configuration.
|
||||
## $1 Config.in input file.
|
||||
## $2 current config file.
|
||||
###############################################################################
|
||||
define __check-config
|
||||
__tmpcheck=$$(mktemp); \
|
||||
if [ ! -f $2 ]; then \
|
||||
echo "Configuration file $2 does not exist" | tee $${__tmpdiff}; \
|
||||
else \
|
||||
$(call __update-config-internal,$1,$2,$${__tmpcheck}) \
|
||||
if ! cmp -s $2 $${__tmpcheck}; then \
|
||||
echo "Configuration file $2 is not up to date"; \
|
||||
diff -u $2 $${__tmpcheck} >> $${__tmpdiff}; \
|
||||
fi; \
|
||||
fi; \
|
||||
rm -f $${__tmpcheck};
|
||||
endef
|
||||
|
||||
###############################################################################
|
||||
## Load configuration of a module.
|
||||
###############################################################################
|
||||
|
||||
# Do NOT check the config if a config is explicitely requested
|
||||
define __load-config-internal
|
||||
$(eval __config := $(call __get_module-config,$1))
|
||||
-include $(__config)
|
||||
ifeq ("$(findstring config,$(MAKECMDGOALS))","")
|
||||
$(__config): __config-modules-check-$1
|
||||
endif
|
||||
endef
|
||||
|
||||
###############################################################################
|
||||
## Load configuration of a module.
|
||||
## Simply evaluate a call to simplify job of caller.
|
||||
###############################################################################
|
||||
load-config = $(eval $(call __load-config-internal,$(LOCAL_MODULE)))
|
||||
|
||||
###############################################################################
|
||||
## Rules.
|
||||
###############################################################################
|
||||
|
||||
# Update everything
|
||||
.PHONY: config-update
|
||||
config-update: config-global-update config-modules-update
|
||||
|
||||
# Check everything
|
||||
.PHONY: config-check
|
||||
config-check: config-global-check config-modules-check
|
||||
|
||||
# Display the global configuration
|
||||
.PHONY: config-global
|
||||
config-global:
|
||||
@( \
|
||||
__tmpconfigin=$$(mktemp); \
|
||||
$(eval __config := $(CONFIG_GLOBAL_FILE)) \
|
||||
$(call __generate-config-in-global,$${__tmpconfigin}) \
|
||||
$(call __begin-conf,$(__config)) \
|
||||
$(call __exec-qconf,$${__tmpconfigin}) \
|
||||
$(call __end-conf,$(__config)) \
|
||||
rm -f $${__tmpconfigin}; \
|
||||
)
|
||||
|
||||
# Update the global configuration by selecting new option at their default value
|
||||
.PHONY: config-global-update
|
||||
config-global-update:
|
||||
@( \
|
||||
__tmpconfigin=$$(mktemp); \
|
||||
$(eval __config := $(CONFIG_GLOBAL_FILE)) \
|
||||
$(call __generate-config-in-global,$${__tmpconfigin}) \
|
||||
$(call __update-config,$${__tmpconfigin},$(__config)) \
|
||||
rm -f $${__tmpconfigin}; \
|
||||
)
|
||||
|
||||
# Check the global configuration
|
||||
.PHONY: config-global-check
|
||||
config-global-check:
|
||||
@( \
|
||||
__tmpconfigin=$$(mktemp); \
|
||||
$(eval __config := $(CONFIG_GLOBAL_FILE)) \
|
||||
$(call __generate-config-in-global,$${__tmpconfigin}) \
|
||||
$(call __check-config,$${__tmpconfigin},$(__config)) \
|
||||
rm -f $${__tmpconfigin}; \
|
||||
)
|
||||
@echo "Global configuration is up to date";
|
||||
|
||||
# Update all module configurations by selecting new option at their default value
|
||||
.PHONY: config-modules-update
|
||||
config-modules-update:
|
||||
@( \
|
||||
$(foreach __mod,$(__modules), \
|
||||
$(eval __config := $(call __get_module-config,$(__mod))) \
|
||||
$(eval __files := $(call __get_module-config-in-files,$(__mod))) \
|
||||
if [ "$(__files)" != "" ]; then \
|
||||
__tmpconfigin=$$(mktemp); \
|
||||
$(call __generate-config-in-module,$${__tmpconfigin},$(__mod),$(__files)) \
|
||||
$(call __update-config,$${__tmpconfigin},$(__config)) \
|
||||
rm -f $${__tmpconfigin}; \
|
||||
fi; \
|
||||
) \
|
||||
)
|
||||
|
||||
# Update a specific module configuration by selecting new option at their default value
|
||||
.PHONY: config-modules-update-%
|
||||
config-modules-update-%:
|
||||
@( \
|
||||
$(eval __mod := $*) \
|
||||
$(eval __config := $(call __get_module-config,$(__mod))) \
|
||||
$(eval __files := $(call __get_module-config-in-files,$(__mod))) \
|
||||
if [ "$(__files)" != "" ]; then \
|
||||
__tmpconfigin=$$(mktemp); \
|
||||
$(call __generate-config-in-module,$${__tmpconfigin},$(__mod),$(__files)) \
|
||||
$(call __update-config,$${__tmpconfigin},$(__config)) \
|
||||
rm -f $${__tmpconfigin}; \
|
||||
fi; \
|
||||
)
|
||||
|
||||
# Check if module configurations are OK
|
||||
.PHONY: config-modules-check
|
||||
config-modules-check: __config-modules-check
|
||||
@echo "Modules configuration are up to date";
|
||||
|
||||
# Internal version with no message
|
||||
.PHONY: __config-modules-check
|
||||
__config-modules-check:
|
||||
@( \
|
||||
$(call __begin-diff) \
|
||||
$(foreach __mod,$(__modules), \
|
||||
$(eval __config := $(call __get_module-config,$(__mod))) \
|
||||
$(eval __files := $(call __get_module-config-in-files,$(__mod))) \
|
||||
if [ "$(__files)" != "" ]; then \
|
||||
__tmpconfigin=$$(mktemp); \
|
||||
$(call __generate-config-in-module,$${__tmpconfigin},$(__mod),$(__files)) \
|
||||
$(call __check-config,$${__tmpconfigin},$(__config)) \
|
||||
rm -f $${__tmpconfigin}; \
|
||||
fi; \
|
||||
) \
|
||||
$(call __end-diff,1) \
|
||||
)
|
||||
|
||||
# Check if a specific module configuration is OK
|
||||
.PHONY: config-modules-check-%
|
||||
config-modules-check-%: __config-modules-check-%
|
||||
$(eval __mod := $*)
|
||||
@echo "Configuration of $(__mod) is up to date";
|
||||
|
||||
# Internal version with no message
|
||||
.PHONY: __config-modules-check-%
|
||||
__config-modules-check-%:
|
||||
@( \
|
||||
$(call __begin-diff) \
|
||||
$(eval __mod := $*) \
|
||||
$(eval __config := $(call __get_module-config,$(__mod))) \
|
||||
$(eval __files := $(call __get_module-config-in-files,$(__mod))) \
|
||||
if [ "$(__files)" != "" ]; then \
|
||||
__tmpconfigin=$$(mktemp); \
|
||||
$(call __generate-config-in-module,$${__tmpconfigin},$(__mod),$(__files)) \
|
||||
$(call __check-config,$${__tmpconfigin},$(__config)) \
|
||||
rm -f $${__tmpconfigin}; \
|
||||
fi; \
|
||||
$(call __end-diff,1) \
|
||||
)
|
||||
|
||||
# Configure a module specifically
|
||||
.PHONY: config-modules-%
|
||||
config-modules-%:
|
||||
@( \
|
||||
$(eval __mod := $*) \
|
||||
$(eval __config := $(call __get_module-config,$(__mod))) \
|
||||
$(eval __files := $(call __get_module-config-in-files,$(__mod))) \
|
||||
if [ "$(__files)" == "" ]; then \
|
||||
echo "Nothing to configure for $(__mod)"; \
|
||||
else \
|
||||
__tmpconfigin=$$(mktemp); \
|
||||
$(call __generate-config-in-module,$${__tmpconfigin},$(__mod),$(__files)) \
|
||||
$(call __begin-conf,$(__config)) \
|
||||
$(call __exec-qconf,$${__tmpconfigin}) \
|
||||
$(call __end-conf,$(__config)) \
|
||||
rm -f $${__tmpconfigin}; \
|
||||
echo "Configuration of $(__mod) saved in $(__config)"; \
|
||||
fi; \
|
||||
)
|
||||
|
||||
@ -1,553 +0,0 @@
|
||||
###############################################################################
|
||||
## @file defs.mk
|
||||
## @author Y.M. Morgan
|
||||
## @date 2011/05/14
|
||||
##
|
||||
## This file contains macros used by other makefiles.
|
||||
###############################################################################
|
||||
|
||||
###############################################################################
|
||||
## Some useful macros.
|
||||
###############################################################################
|
||||
empty :=
|
||||
space := $(empty) $(empty)
|
||||
space4 := $(space)$(space)$(space)$(space)
|
||||
|
||||
# Return the first element of a list.
|
||||
# $ 1 : input list.
|
||||
first = $(firstword $1)
|
||||
|
||||
# Return the list with the first element removed.
|
||||
# $ 1 : input list.
|
||||
rest = $(wordlist 2,$(words $1),$1)
|
||||
|
||||
# Get a path relative to top directory.
|
||||
# $1 : full path to convert.
|
||||
path-from-top = $(patsubst $(TOP_DIR)%,.%,$1)
|
||||
|
||||
# Translate characters.
|
||||
# $1 : text to convert.
|
||||
# $2 : characters to convert from.
|
||||
# $3 : characters to convert to.
|
||||
tr = $(shell echo $1 | tr $2 $3)
|
||||
|
||||
# Convert to upper case.
|
||||
# $1 : text to convert.
|
||||
upcase = $(shell echo $1 | tr [:lower:] [:upper:])
|
||||
|
||||
# Convert to lower case.
|
||||
# $1 : text to convert.
|
||||
locase = $(shell echo $1 | tr [:upper:] [:lower:])
|
||||
|
||||
# Replace '-' by '_' and convert to upper case.
|
||||
# $1 : text to convert.
|
||||
get-define = $(strip $(call upcase,$(call tr,$1,-,_)))
|
||||
|
||||
# Remove quotes from string
|
||||
remove-quotes = $(strip $(subst ",,$1))
|
||||
#"
|
||||
|
||||
# Check that the current directory is the top directory
|
||||
check-pwd-is-top-dir = \
|
||||
$(if $(patsubst $(TOP_DIR)%,%,$(shell pwd)), \
|
||||
$(error Not at the top directory))
|
||||
|
||||
###############################################################################
|
||||
## Use some colors if requested.
|
||||
###############################################################################
|
||||
ifeq ("$(USE_COLORS)","1")
|
||||
CLR_DEFAULT := $(shell echo -e "\033[00m")
|
||||
CLR_RED := $(shell echo -e "\033[31m")
|
||||
CLR_GREEN := $(shell echo -e "\033[32m")
|
||||
CLR_YELLOW := $(shell echo -e "\033[33m")
|
||||
CLR_BLUE := $(shell echo -e "\033[34m")
|
||||
CLR_PURPLE := $(shell echo -e "\033[35m")
|
||||
CLR_CYAN := $(shell echo -e "\033[36m")
|
||||
else
|
||||
CLR_DEFAULT :=
|
||||
CLR_RED :=
|
||||
CLR_GREEN :=
|
||||
CLR_YELLOW :=
|
||||
CLR_BLUE :=
|
||||
CLR_PURPLE :=
|
||||
CLR_CYAN :=
|
||||
endif
|
||||
|
||||
###############################################################################
|
||||
## Modules database.
|
||||
## For each module 'mod', __modules.mod.<field> is used to store
|
||||
## module-specific information.
|
||||
###############################################################################
|
||||
__modules := $(empty)
|
||||
|
||||
###############################################################################
|
||||
## Clear a list of variables.
|
||||
###############################################################################
|
||||
clear-vars = $(foreach __varname,$1,$(eval $(__varname) := $(empty)))
|
||||
|
||||
###############################################################################
|
||||
## List of LOCAL_XXX variables that can be set by makefiles.
|
||||
###############################################################################
|
||||
modules-LOCALS :=
|
||||
|
||||
# Path of the root of module
|
||||
modules-LOCALS += PATH
|
||||
|
||||
# Name of what's supposed to be generated
|
||||
modules-LOCALS += MODULE
|
||||
|
||||
# Override the name of what will be generated
|
||||
modules-LOCALS += MODULE_FILENAME
|
||||
|
||||
# Source files to compile
|
||||
# All files are relative to LOCAL_PATH
|
||||
modules-LOCALS += SRC_FILES
|
||||
|
||||
# Static libraries that you want to include in your module
|
||||
# Names of modules in the build system, without path/prefix/suffix
|
||||
modules-LOCALS += STATIC_LIBRARIES
|
||||
|
||||
# Static libraries that you want to include as a whole in your module
|
||||
# To generate a .so for ex
|
||||
# Names of modules in the build system, without path/prefix/suffix
|
||||
modules-LOCALS += WHOLE_STATIC_LIBRARIES
|
||||
|
||||
# Libraries you directly link against
|
||||
# Names of modules in the build system, without path/prefix/suffix
|
||||
modules-LOCALS += SHARED_LIBRARIES
|
||||
|
||||
# External libraries (not built directly by the build system rules)
|
||||
# Used as dependencies to trigger indirect build.
|
||||
modules-LOCALS += EXTERNAL_LIBRARIES
|
||||
|
||||
# Additional include directories to pass into the C/C++ compilers
|
||||
# Format : -I<fullpath>
|
||||
modules-LOCALS += C_INCLUDES
|
||||
|
||||
# Additional flags to pass into the C or C++ compiler
|
||||
modules-LOCALS += CFLAGS
|
||||
|
||||
# Additional flags to pass into only the C++ compiler
|
||||
modules-LOCALS += CPPFLAGS
|
||||
|
||||
# Additional flags to pass into the static library generator
|
||||
modules-LOCALS += ARFLAGS
|
||||
|
||||
# Additional flags to pass into the linker
|
||||
modules-LOCALS += LDFLAGS
|
||||
|
||||
# Additional libraries to pass into the linker
|
||||
# Format : -l<name>
|
||||
modules-LOCALS += LDLIBS
|
||||
|
||||
# Precompiled file
|
||||
# Relative to LOCAL_PATH
|
||||
modules-LOCALS += PRECOMPILED_FILE
|
||||
|
||||
# Arm compilation mode (arm or thumb)
|
||||
modules-LOCALS += ARM_MODE
|
||||
|
||||
# Paths to config.in files to configure the module
|
||||
# Relative to LOCAL_PATH
|
||||
modules-LOCALS += CONFIG_FILES
|
||||
|
||||
# List of prerequisites for all objects
|
||||
modules-LOCALS += PREREQUISITES
|
||||
|
||||
# Exported stuff (will be added in modules depending on this one)
|
||||
modules-LOCALS += EXPORT_C_INCLUDES
|
||||
modules-LOCALS += EXPORT_CFLAGS
|
||||
modules-LOCALS += EXPORT_CPPFLAGS
|
||||
modules-LOCALS += EXPORT_LDLIBS
|
||||
modules-LOCALS += EXPORT_PREREQUISITES
|
||||
|
||||
# Module class : STATIC_LIBRARY SHARED_LIBRARY EXECUTABLE
|
||||
modules-LOCALS += MODULE_CLASS
|
||||
|
||||
# Other variables used internally
|
||||
modules-LOCALS += BUILD_MODULE
|
||||
modules-LOCALS += STAGING_MODULE
|
||||
modules-LOCALS += DESTDIR
|
||||
modules-LOCALS += TARGETS
|
||||
|
||||
# the list of managed fields per module
|
||||
modules-fields := \
|
||||
depends \
|
||||
$(modules-LOCALS)
|
||||
|
||||
###############################################################################
|
||||
## Dump all module information. Only use this for debugging.
|
||||
###############################################################################
|
||||
modules-dump-database = \
|
||||
$(info Modules: $(__modules)) \
|
||||
$(foreach __mod,$(__modules), \
|
||||
$(info $(space4)$(__mod):) \
|
||||
$(foreach __field,$(modules-fields), \
|
||||
$(eval __fieldval := $(strip $(__modules.$(__mod).$(__field)))) \
|
||||
$(if $(__fieldval), \
|
||||
$(if $(filter 1,$(words $(__fieldval))), \
|
||||
$(info $(space4)$(space4)$(__field): $(__fieldval)), \
|
||||
$(info $(space4)$(space4)$(__field): ) \
|
||||
$(foreach __fielditem,$(__fieldval), \
|
||||
$(info $(space4)$(space4)$(space4)$(__fielditem)) \
|
||||
) \
|
||||
) \
|
||||
) \
|
||||
) \
|
||||
) \
|
||||
$(info --- end of modules list)
|
||||
|
||||
###############################################################################
|
||||
## Add a module in the build system and save its LOCAL_xxx variables.
|
||||
## $1 : name of module to add. All LOCAL_xxx variables will be saved in
|
||||
## module database.
|
||||
###############################################################################
|
||||
module-add = \
|
||||
$(eval __modules += $1) \
|
||||
$(foreach __local,$(modules-LOCALS), \
|
||||
$(eval __modules.$1.$(__local) := $(LOCAL_$(__local))) \
|
||||
)
|
||||
|
||||
###############################################################################
|
||||
## Restore the recorded LOCAL_XXX definitions for a given module. Called
|
||||
## for each module once they have all been registered and their dependencies
|
||||
## have been computed to actually define rules.
|
||||
## $1 : name of module to restore.
|
||||
###############################################################################
|
||||
module-restore-locals = \
|
||||
$(foreach __local,$(modules-LOCALS), \
|
||||
$(eval LOCAL_$(__local) := $(__modules.$1.$(__local))) \
|
||||
)
|
||||
|
||||
###############################################################################
|
||||
## Used to recompute all dependencies once all module information has been
|
||||
## recorded.
|
||||
###############################################################################
|
||||
|
||||
# Compute dependencies of all modules
|
||||
modules-compute-dependencies = \
|
||||
$(foreach __mod,$(__modules), \
|
||||
$(eval __modules.$(__mod).depends := ) \
|
||||
$(call __module-compute-depends,$(__mod)) \
|
||||
)
|
||||
|
||||
# Compute dependencies of a single module
|
||||
# $1 : module name.
|
||||
__module-compute-depends = \
|
||||
$(call __module-add-depends,$1,$(__modules.$1.STATIC_LIBRARIES)) \
|
||||
$(call __module-add-depends,$1,$(__modules.$1.WHOLE_STATIC_LIBRARIES)) \
|
||||
$(call __module-add-depends,$1,$(__modules.$1.SHARED_LIBRARIES)) \
|
||||
$(call __module-add-depends,$1,$(__modules.$1.EXTERNAL_LIBRARIES))
|
||||
|
||||
# Add dependencies to a module
|
||||
# $1 : module name.
|
||||
# $2 : list of modules to add in dependency list.
|
||||
__module-add-depends = \
|
||||
$(eval __modules.$1.depends += $(filter-out $(__modules.$1.depends),$2))
|
||||
|
||||
###############################################################################
|
||||
## Automatic extraction from dependencies of a module.
|
||||
###############################################################################
|
||||
|
||||
# Return the recorded value of LOCAL_EXPORT_$2, if any, for module $1.
|
||||
# $1 : module name.
|
||||
# $2 : export variable name without LOCAL_EXPORT_ prefix (e.g. 'CFLAGS').
|
||||
module-get-export = $(__modules.$1.EXPORT_$2)
|
||||
|
||||
# Return the recorded value of LOCAL_EXPORT_$2, if any, for modules listed in $1.
|
||||
# $1 : list of module names.
|
||||
# $2 : export variable name without LOCAL_EXPORT_ prefix (e.g. 'CFLAGS').
|
||||
module-get-listed-export = \
|
||||
$(strip $(foreach __mod,$1, \
|
||||
$(call module-get-export,$(__mod),$2) \
|
||||
))
|
||||
|
||||
# Return the autoconf.h file, if any, for module $1.
|
||||
# $1 : module name.
|
||||
module-get-autoconf = \
|
||||
$(if $(__modules.$1.CONFIG_FILES),$(TARGET_OUT_BUILD)/$1/autoconf-$1.h)
|
||||
|
||||
# Return the autoconf.h files, if any, for modules listed in $1.
|
||||
# $1 : list of module names.
|
||||
module-get-listed-autoconf = \
|
||||
$(strip $(foreach __mod,$1, \
|
||||
$(call module-get-autoconf,$(__mod)) \
|
||||
))
|
||||
|
||||
###############################################################################
|
||||
## Dependecy management
|
||||
###############################################################################
|
||||
|
||||
# Return list all the <local-type> modules $1 depends on transitively.
|
||||
# $1 : list of module names.
|
||||
# $2 : local module type (e.g. SHARED_LIBRARIES).
|
||||
module-get-depends = $(strip $(call __modules-get-closure,$1,$2))
|
||||
|
||||
# Return list of all the modules $1 depends on transitively.
|
||||
# $1: list of module names.
|
||||
module-get-all-dependencies = \
|
||||
$(strip $(call __modules-get-closure,$1,depends))
|
||||
|
||||
# Recursively get dependency of a modules
|
||||
__modules-get-closure = \
|
||||
$(eval __closure_deps := $(strip $1)) \
|
||||
$(if $(__closure_deps), \
|
||||
$(eval __closure_wq := $(__closure_deps)) \
|
||||
$(eval __closure_field := $(strip $2)) \
|
||||
$(call __modules-closure)) \
|
||||
$(__closure_deps)
|
||||
|
||||
# Used internally by modules-get-all-dependencies. Note the tricky use of
|
||||
# conditional recursion to work around the fact that the GNU Make language does
|
||||
# not have any conditional looping construct like 'while'.
|
||||
__modules-closure = \
|
||||
$(eval __closure_mod := $(call first,$(__closure_wq))) \
|
||||
$(eval __closure_wq := $(call rest,$(__closure_wq))) \
|
||||
$(eval __closure_val := $(__modules.$(__closure_mod).$(__closure_field))) \
|
||||
$(eval __closure_new := $(filter-out $(__closure_deps),$(__closure_val))) \
|
||||
$(eval __closure_deps += $(__closure_new)) \
|
||||
$(eval __closure_wq := $(strip $(__closure_wq) $(__closure_new))) \
|
||||
$(if $(__closure_wq),$(call __modules-closure)) \
|
||||
|
||||
###############################################################################
|
||||
## Get path of module main target file (in build or staging directory).
|
||||
## $1 : module name.
|
||||
###############################################################################
|
||||
module-get-build-dir = \
|
||||
$(TARGET_OUT_BUILD)/$1
|
||||
|
||||
module-get-build-filename = \
|
||||
$(TARGET_OUT_BUILD)/$1/$(__modules.$1.MODULE_FILENAME)
|
||||
|
||||
module-get-staging-filename = \
|
||||
$(TARGET_OUT_STAGING)/$(__modules.$1.DESTDIR)/$(__modules.$1.MODULE_FILENAME)
|
||||
|
||||
###############################################################################
|
||||
## Generate autoconf.h file from config file.
|
||||
## $1 : input config file.
|
||||
## $2 : output autoconf.h file.
|
||||
##
|
||||
## Remove CONFIG_ prefix.
|
||||
## Remove CONFIG_ in commented lines.
|
||||
## Put lines begining with '#' between '/*' '*/'.
|
||||
## Replace 'key=value' by '#define key value'.
|
||||
## Replace leading ' y' by ' 1'.
|
||||
## Remove leading and trailing quotes from string.
|
||||
## Replace '\"' by '"'.
|
||||
###############################################################################
|
||||
define generate-autoconf-file
|
||||
echo "Generating $(call path-from-top,$2) from $(call path-from-top,$1)"; \
|
||||
mkdir -p $(dir $2); \
|
||||
sed \
|
||||
-e 's/^CONFIG_//' \
|
||||
-e 's/^\# CONFIG_/\# /' \
|
||||
-e 's/^\#\(.*\)/\/*\1 *\//' \
|
||||
-e 's/\(.*\)=\(.*\)/\#define \1 \2/' \
|
||||
-e 's/ y$$/ 1/' \
|
||||
-e 's/\"\(.*\)\"/\1/' \
|
||||
-e 's/\\\"/\"/g' \
|
||||
$1 > $2;
|
||||
endef
|
||||
|
||||
###############################################################################
|
||||
## Print some banners.
|
||||
## $1 : operation.
|
||||
## $2 : module.
|
||||
## $3 : file.
|
||||
###############################################################################
|
||||
|
||||
CLR_TOOL := $(CLR_PURPLE)
|
||||
CLR_MODULE := $(CLR_CYAN)
|
||||
CLR_FILE := $(CLR_YELLOW)
|
||||
|
||||
print-banner1 = \
|
||||
@echo "$(CLR_TOOL)$1:$(CLR_DEFAULT) $(CLR_MODULE)$2$(CLR_DEFAULT) <= $(CLR_FILE)$3$(CLR_DEFAULT)"
|
||||
|
||||
print-banner2 = \
|
||||
@echo "$(CLR_TOOL)$1:$(CLR_DEFAULT) $(CLR_MODULE)$2$(CLR_DEFAULT) => $(CLR_FILE)$3$(CLR_DEFAULT)"
|
||||
|
||||
###############################################################################
|
||||
## Commands for running gcc to generate a precompiled file.
|
||||
###############################################################################
|
||||
|
||||
define transform-h-to-gch
|
||||
@mkdir -p $(dir $@)
|
||||
$(call print-banner1,"Precompile",$(PRIVATE_MODULE),$(call path-from-top,$<))
|
||||
$(call check-pwd-is-top-dir)
|
||||
$(Q)$(CCACHE) $(GXX) \
|
||||
$(TARGET_GLOBAL_C_INCLUDES) $(PRIVATE_C_INCLUDES) \
|
||||
$(TARGET_GLOBAL_CFLAGS) $(TARGET_GLOBAL_CPPFLAGS) $(GXX_FLAGS_WARNINGS) \
|
||||
$(PRIVATE_CFLAGS) $(PRIVATE_CPPFLAGS) \
|
||||
$(TARGET_PCH_FLAGS) -MMD -MP -o $@ \
|
||||
$(call path-from-top,$<)
|
||||
endef
|
||||
|
||||
###############################################################################
|
||||
## Commands for running gcc to compile a C++ file.
|
||||
###############################################################################
|
||||
|
||||
define transform-cpp-to-o
|
||||
@mkdir -p $(dir $@)
|
||||
$(call print-banner1,"$(PRIVATE_ARM_MODE) CPP",$(PRIVATE_MODULE),$(call path-from-top,$<))
|
||||
$(call check-pwd-is-top-dir)
|
||||
$(Q)$(CCACHE) $(GXX) \
|
||||
$(TARGET_GLOBAL_C_INCLUDES) $(PRIVATE_C_INCLUDES) \
|
||||
$(TARGET_GLOBAL_CFLAGS_$(PRIVATE_ARM_MODE)) \
|
||||
$(TARGET_GLOBAL_CFLAGS) $(TARGET_GLOBAL_CPPFLAGS) $(GXX_FLAGS_WARNINGS) \
|
||||
$(PRIVATE_CFLAGS) $(PRIVATE_CPPFLAGS) \
|
||||
-c -MMD -MP -o $@ \
|
||||
$(call path-from-top,$<)
|
||||
endef
|
||||
|
||||
###############################################################################
|
||||
## Commands for running gcc to compile a C file.
|
||||
###############################################################################
|
||||
|
||||
define transform-c-to-o
|
||||
$(call print-banner1,"$(PRIVATE_ARM_MODE) C",$(PRIVATE_MODULE),$(call path-from-top,$<))
|
||||
$(call check-pwd-is-top-dir)
|
||||
@mkdir -p $(dir $@)
|
||||
$(Q)$(CCACHE) $(GCC) \
|
||||
$(TARGET_GLOBAL_C_INCLUDES) $(PRIVATE_C_INCLUDES) \
|
||||
$(TARGET_GLOBAL_CFLAGS_$(PRIVATE_ARM_MODE)) \
|
||||
$(TARGET_GLOBAL_CFLAGS) $(GCC_FLAGS_WARNINGS) \
|
||||
$(PRIVATE_CFLAGS) \
|
||||
-c -MMD -MP -o $@ \
|
||||
$(call path-from-top,$<)
|
||||
endef
|
||||
|
||||
###############################################################################
|
||||
## Commands for running gcc to compile a S file.
|
||||
###############################################################################
|
||||
|
||||
define transform-s-to-o
|
||||
$(call print-banner1,"ASM",$(PRIVATE_MODULE),$(call path-from-top,$<))
|
||||
$(call check-pwd-is-top-dir)
|
||||
@mkdir -p $(dir $@)
|
||||
$(Q)$(CCACHE) $(GCC) \
|
||||
$(TARGET_GLOBAL_C_INCLUDES) $(PRIVATE_C_INCLUDES) \
|
||||
$(TARGET_GLOBAL_CFLAGS_$(PRIVATE_ARM_MODE)) \
|
||||
$(TARGET_GLOBAL_CFLAGS) $(GCC_FLAGS_WARNINGS) \
|
||||
$(PRIVATE_CFLAGS) \
|
||||
-c -MMD -MP -o $@ \
|
||||
$(call path-from-top,$<)
|
||||
endef
|
||||
|
||||
###############################################################################
|
||||
## Commands for running ar.
|
||||
###############################################################################
|
||||
|
||||
# Explicitly delete the archive first so that ar doesn't
|
||||
# try to add to an existing archive.
|
||||
define transform-o-to-static-lib
|
||||
@mkdir -p $(dir $@)
|
||||
$(call print-banner2,"StaticLib",$(PRIVATE_MODULE),$(call path-from-top,$@))
|
||||
$(call check-pwd-is-top-dir)
|
||||
@rm -f $@
|
||||
$(Q)$(AR) $(TARGET_GLOBAL_ARFLAGS) $(PRIVATE_ARFLAGS) $@ $(PRIVATE_ALL_OBJECTS)
|
||||
endef
|
||||
|
||||
###############################################################################
|
||||
## Commands for running gcc to link a shared library.
|
||||
###############################################################################
|
||||
|
||||
define transform-o-to-shared-lib
|
||||
@mkdir -p $(dir $@)
|
||||
$(call print-banner2,"SharedLib",$(PRIVATE_MODULE),$(call path-from-top,$@))
|
||||
$(call check-pwd-is-top-dir)
|
||||
$(Q)$(GXX) \
|
||||
$(TARGET_GLOBAL_LDFLAGS_SHARED) \
|
||||
-Wl,-Map -Wl,$(basename $@).map \
|
||||
-shared \
|
||||
-Wl,-soname -Wl,$(notdir $@) \
|
||||
-Wl,--no-undefined \
|
||||
$(PRIVATE_LDFLAGS) \
|
||||
$(PRIVATE_ALL_OBJECTS) \
|
||||
-Wl,--whole-archive \
|
||||
$(PRIVATE_ALL_WHOLE_STATIC_LIBRARIES) \
|
||||
-Wl,--no-whole-archive \
|
||||
-Wl,--as-needed \
|
||||
$(PRIVATE_ALL_STATIC_LIBRARIES) \
|
||||
$(PRIVATE_ALL_SHARED_LIBRARIES) \
|
||||
-o $@ \
|
||||
$(PRIVATE_LDLIBS) \
|
||||
$(TARGET_GLOBAL_LDLIBS_SHARED)
|
||||
endef
|
||||
|
||||
###############################################################################
|
||||
## Commands for running gcc to link an executable.
|
||||
###############################################################################
|
||||
|
||||
define transform-o-to-executable
|
||||
@mkdir -p $(dir $@)
|
||||
$(call print-banner2,"Executable",$(PRIVATE_MODULE),$(call path-from-top,$@))
|
||||
$(call check-pwd-is-top-dir)
|
||||
$(Q)$(GXX) \
|
||||
$(TARGET_GLOBAL_LDFLAGS) \
|
||||
-Wl,-Map -Wl,$(basename $@).map \
|
||||
-Wl,-rpath-link=$(TARGET_OUT_STAGING)/lib \
|
||||
-Wl,-rpath-link=$(TARGET_OUT_STAGING)/usr/lib \
|
||||
$(PRIVATE_LDFLAGS) \
|
||||
$(PRIVATE_ALL_OBJECTS) \
|
||||
-Wl,--whole-archive \
|
||||
$(PRIVATE_ALL_WHOLE_STATIC_LIBRARIES) \
|
||||
-Wl,--no-whole-archive \
|
||||
-Wl,--as-needed \
|
||||
$(PRIVATE_ALL_STATIC_LIBRARIES) \
|
||||
$(PRIVATE_ALL_SHARED_LIBRARIES) \
|
||||
-o $@ \
|
||||
$(PRIVATE_LDLIBS) \
|
||||
$(TARGET_GLOBAL_LDLIBS)
|
||||
endef
|
||||
|
||||
###############################################################################
|
||||
## Commands for copying files.
|
||||
###############################################################################
|
||||
|
||||
# Copy a single file from one place to another, preserving permissions and
|
||||
# overwriting any existing file.
|
||||
define copy-file-to-target
|
||||
@mkdir -p $(dir $@)
|
||||
$(Q)cp -fp $< $@
|
||||
endef
|
||||
|
||||
# Define a rule to copy a file. For use via $(eval).
|
||||
# $(1) : source file
|
||||
# $(2) : destination file
|
||||
define copy-one-file
|
||||
$(2): $(1)
|
||||
@echo "$(CLR_TOOL)Copy: $(CLR_FILE)$$(call path-from-top,$$@)$(CLR_DEFAULT)"
|
||||
$$(copy-file-to-target)
|
||||
endef
|
||||
|
||||
###############################################################################
|
||||
## Default rules for a module.
|
||||
## $1 : module name.
|
||||
###############################################################################
|
||||
|
||||
define def-rules
|
||||
|
||||
.PHONY: $1
|
||||
$1: $(call module-get-build-filename,$1)
|
||||
|
||||
.PHONY: clean-$1
|
||||
clean-$1:
|
||||
@rm -f $(call module-get-build-filename,$1)
|
||||
@rm -rf $(call module-get-build-dir,$1)
|
||||
|
||||
endef
|
||||
|
||||
###############################################################################
|
||||
## Commands callable from user makefiles.
|
||||
###############################################################################
|
||||
|
||||
# Get local path
|
||||
local-get-path = $(call my-dir)
|
||||
|
||||
# Get build directory
|
||||
local-get-build-dir = $(call module-get-build-dir,$(LOCAL_MODULE))
|
||||
|
||||
# Register module
|
||||
local-add-module = \
|
||||
$(call module-add,$(LOCAL_MODULE)) \
|
||||
$(eval $(call def-rules,$(LOCAL_MODULE)))
|
||||
@ -1,16 +0,0 @@
|
||||
###############################################################################
|
||||
## @file executable.mk
|
||||
## @author Y.M. Morgan
|
||||
## @date 2011/05/14
|
||||
##
|
||||
## Build an executable.
|
||||
###############################################################################
|
||||
|
||||
LOCAL_MODULE_CLASS := EXECUTABLE
|
||||
LOCAL_DESTDIR := usr/bin
|
||||
|
||||
ifndef LOCAL_MODULE_FILENAME
|
||||
LOCAL_MODULE_FILENAME := $(LOCAL_MODULE)$(TARGET_EXE_SUFFIX)
|
||||
endif
|
||||
|
||||
$(call module-add,$(LOCAL_MODULE))
|
||||
@ -1,220 +0,0 @@
|
||||
###############################################################################
|
||||
## @file main.mk
|
||||
## @author Y.M. Morgan
|
||||
## @date 2011/05/14
|
||||
##
|
||||
## Main Makefile.
|
||||
###############################################################################
|
||||
|
||||
###############################################################################
|
||||
## General setup.
|
||||
###############################################################################
|
||||
|
||||
# Make sure SHELL is correctly set
|
||||
SHELL := /bin/bash
|
||||
|
||||
# Turns off suffix rules built into make
|
||||
.SUFFIXES:
|
||||
|
||||
# Tools for target
|
||||
GCC ?= $(CROSS)gcc
|
||||
GXX ?= $(CROSS)g++
|
||||
AR ?= $(CROSS)ar
|
||||
LD ?= $(CROSS)ld
|
||||
NM ?= $(CROSS)nm
|
||||
STRIP ?= $(CROSS)strip
|
||||
|
||||
# Tools for host
|
||||
HOST_GCC ?= gcc
|
||||
HOST_GXX ?= g++
|
||||
HOST_AR ?= ar
|
||||
HOST_LD ?= ld
|
||||
HOST_STRIP ?= strip
|
||||
|
||||
# Overridable settings
|
||||
V := 0
|
||||
W := 0
|
||||
DEBUG := 0
|
||||
USE_CLANG := 0
|
||||
USE_CCACHE := 0
|
||||
|
||||
# Quiet command if V is 0
|
||||
ifeq ("$(V)","0")
|
||||
Q := @
|
||||
endif
|
||||
|
||||
# This is the default target. It must be the first declared target.
|
||||
all:
|
||||
|
||||
# Target global variables
|
||||
TARGET_GLOBAL_C_INCLUDES ?=
|
||||
TARGET_GLOBAL_CFLAGS ?=
|
||||
TARGET_GLOBAL_CPPFLAGS ?=
|
||||
TARGET_GLOBAL_RCFLAGS ?=
|
||||
TARGET_GLOBAL_ARFLAGS ?= rcs
|
||||
TARGET_GLOBAL_LDFLAGS ?=
|
||||
TARGET_GLOBAL_LDFLAGS_SHARED ?=
|
||||
TARGET_GLOBAL_LDLIBS ?=
|
||||
TARGET_GLOBAL_LDLIBS_SHARED ?=
|
||||
TARGET_PCH_FLAGS ?=
|
||||
TARGET_DEFAULT_ARM_MODE ?= THUMB
|
||||
TARGET_GLOBAL_CFLAGS_ARM ?=
|
||||
TARGET_GLOBAL_CFLAGS_THUMB ?=
|
||||
|
||||
###############################################################################
|
||||
## The folowing 2 macros can NOT be put in defs.mk as it will be included
|
||||
## only after.
|
||||
###############################################################################
|
||||
|
||||
# Get full path.
|
||||
# $1 : path to extend.
|
||||
fullpath = $(shell readlink -m -n $1)
|
||||
|
||||
# Figure out where we are
|
||||
# It returns the full path without trailing '/'
|
||||
my-dir = $(call fullpath,$(patsubst %/,%,$(dir $(lastword $(MAKEFILE_LIST)))))
|
||||
|
||||
###############################################################################
|
||||
## Build system setup.
|
||||
###############################################################################
|
||||
|
||||
# Directories (full path)
|
||||
TOP_DIR := $(shell pwd)
|
||||
BUILD_SYSTEM := $(call my-dir)
|
||||
|
||||
# Setup configuration
|
||||
include $(BUILD_SYSTEM)/setup.mk
|
||||
|
||||
# Setup macros definitions
|
||||
include $(BUILD_SYSTEM)/defs.mk
|
||||
|
||||
# Setup warnings flags
|
||||
include $(BUILD_SYSTEM)/warnings.mk
|
||||
|
||||
# Load configuration
|
||||
include $(BUILD_SYSTEM)/config.mk
|
||||
|
||||
# Names of makefiles that can be included by user Makefiles
|
||||
CLEAR_VARS := $(BUILD_SYSTEM)/clearvars.mk
|
||||
BUILD_STATIC_LIBRARY := $(BUILD_SYSTEM)/static.mk
|
||||
BUILD_SHARED_LIBRARY := $(BUILD_SYSTEM)/shared.mk
|
||||
BUILD_EXECUTABLE := $(BUILD_SYSTEM)/executable.mk
|
||||
RULES := $(BUILD_SYSTEM)/rules.mk
|
||||
|
||||
###############################################################################
|
||||
## Makefile scan and includes.
|
||||
###############################################################################
|
||||
ifeq ("$(DEBUG)","1")
|
||||
BUILD_DIRECTORY_MODE := debug
|
||||
else
|
||||
BUILD_DIRECTORY_MODE := release
|
||||
endif
|
||||
|
||||
TARGET_OUT_BUILD ?= $(shell pwd)/out_$(TARGET_OS)/$(BUILD_DIRECTORY_MODE)/obj
|
||||
TARGET_OUT_STAGING ?= $(shell pwd)/out_$(TARGET_OS)/$(BUILD_DIRECTORY_MODE)/obj
|
||||
TARGET_OUT_FINAL ?= $(shell pwd)/out_$(TARGET_OS)/$(BUILD_DIRECTORY_MODE)/bin
|
||||
|
||||
# Makefile with the list of all makefiles available and include them
|
||||
SCAN_TARGET := scan
|
||||
#TODO : change this in function of the platform ...
|
||||
USER_MAKEFILE_NAME := Linux.mk
|
||||
USER_MAKEFILES:=$(TARGET_OUT_BUILD)/makefiles.mk
|
||||
|
||||
# Include makefile containing all available makefile
|
||||
# If it does not exists, it will trigger its creation
|
||||
ifeq ("$(findstring $(SCAN_TARGET),$(MAKECMDGOALS))","")
|
||||
include $(USER_MAKEFILES)
|
||||
endif
|
||||
$(info mydir="$(my-dir)")
|
||||
$(info pwd="$(shell pwd)")
|
||||
$(info TOP_DIR="$(TOP_DIR)")
|
||||
$(info USER_PACKAGES="$(USER_PACKAGES)")
|
||||
# Create a file that will contain all user makefiles available
|
||||
define create-user-makefiles-file
|
||||
rm -f $(USER_MAKEFILES); \
|
||||
mkdir -p $(dir $(USER_MAKEFILES)); \
|
||||
touch $(USER_MAKEFILES); \
|
||||
echo "Scanning $(TOP_DIR) for makefiles..."; \
|
||||
for f in `find $(USER_PACKAGES) -name $(USER_MAKEFILE_NAME)`; do \
|
||||
echo "$$f"; \
|
||||
echo "include $$f" >> $(USER_MAKEFILES); \
|
||||
done;
|
||||
endef
|
||||
|
||||
# Rule that will trigger creation of list of makefiles when needed
|
||||
$(USER_MAKEFILES):
|
||||
@$(create-user-makefiles-file)
|
||||
|
||||
# Rule to force creation of list of makefiles
|
||||
.PHONY: $(SCAN_TARGET)
|
||||
$(SCAN_TARGET):
|
||||
@$(create-user-makefiles-file)
|
||||
|
||||
###############################################################################
|
||||
# Module dependencies generation.
|
||||
###############################################################################
|
||||
|
||||
# Recompute all dependencies between modules
|
||||
$(call modules-compute-dependencies)
|
||||
|
||||
# Now, really build the modules, the second pass allows to deal with exported values
|
||||
$(foreach __mod,$(__modules), \
|
||||
$(eval LOCAL_MODULE := $(__mod)) \
|
||||
$(eval include $(BUILD_SYSTEM)/module.mk) \
|
||||
)
|
||||
|
||||
###############################################################################
|
||||
# Rule to merge autoconf.h files.
|
||||
###############################################################################
|
||||
|
||||
# List of all available autoconf.h files
|
||||
__autoconf-list := $(foreach __mod,$(__modules),$(call module-get-autoconf,$(__mod)))
|
||||
|
||||
# Concatenate all in one
|
||||
AUTOCONF_MERGE_FILE := $(TARGET_OUT_BUILD)/autoconf-merge.h
|
||||
$(AUTOCONF_MERGE_FILE): $(__autoconf-list)
|
||||
@echo "Generating autoconf-merge.h"
|
||||
@mkdir -p $(dir $@)
|
||||
@rm -f $@
|
||||
@for f in $^; do cat $$f >> $@; done
|
||||
|
||||
###############################################################################
|
||||
# Main rules.
|
||||
###############################################################################
|
||||
|
||||
.PHONY: all
|
||||
all: $(foreach __mod,$(__modules),$(__mod)) $(AUTOCONF_MERGE_FILE)
|
||||
|
||||
.PHONY: clean
|
||||
clean: $(foreach __mod,$(__modules),clean-$(__mod))
|
||||
@rm -f $(AUTOCONF_MERGE_FILE)
|
||||
@rm -f $(USER_MAKEFILES)
|
||||
|
||||
# Generate final tree
|
||||
.PHONY: final
|
||||
final: all
|
||||
@echo "Generating final tree..."
|
||||
@$(BUILD_SYSTEM)/make-final.py \
|
||||
--strip="$(STRIP)" \
|
||||
$(TARGET_OUT_STAGING) $(TARGET_OUT_FINAL)
|
||||
@echo "Done generating final tree"
|
||||
|
||||
# Dump the module database for debuging the build system
|
||||
.PHONY: dump
|
||||
dump:
|
||||
$(call modules-dump-database)
|
||||
|
||||
###############################################################################
|
||||
# Display configuration.
|
||||
###############################################################################
|
||||
msg = $(info $(CLR_CYAN)$1$(CLR_DEFAULT))
|
||||
$(info ----------------------------------------------------------------------)
|
||||
$(call msg, + HOST_OS = $(HOST_OS))
|
||||
$(call msg, + TARGET_OS = $(TARGET_OS))
|
||||
$(call msg, + TARGET_ARCH = $(TARGET_ARCH))
|
||||
$(call msg, + TARGET_OUT_BUILD = $(TARGET_OUT_BUILD))
|
||||
$(call msg, + TARGET_OUT_STAGING = $(TARGET_OUT_STAGING))
|
||||
$(call msg, + TARGET_OUT_FINAL = $(TARGET_OUT_FINAL))
|
||||
$(call msg, + GCC_PATH = $(GCC_PATH))
|
||||
$(call msg, + GCC_VERSION = $(GCC_VERSION))
|
||||
$(info ----------------------------------------------------------------------)
|
||||
@ -1,24 +0,0 @@
|
||||
#!/bin/bash
|
||||
|
||||
if [ "$#" != "2" ]; then
|
||||
echo "Usage : $0 <input> <output>"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# Remove CONFIG_ prefix
|
||||
# Put lines beginig with '#' between '/*' '*/'
|
||||
# Replace 'key=value' by '#define key value'
|
||||
# Replace leading ' y' by ' 1'
|
||||
# Remove leading and trailing quotes from string
|
||||
# Replace '\"' by '"'
|
||||
sed \
|
||||
-e 's/^CONFIG_//' \
|
||||
-e 's/^# CONFIG_/# /' \
|
||||
-e "s/^#\(.*\)/\/*\1 *\//" \
|
||||
-e 's/\(.*\)=\(.*\)/#define \1 \2 /' \
|
||||
-e 's/ y$/ 1/' \
|
||||
-e 's/\"\(.*\)\"/\1/' \
|
||||
-e 's/\\\"/\"/g' \
|
||||
$1 > $2
|
||||
|
||||
|
||||
@ -1,141 +0,0 @@
|
||||
#!/usr/bin/env python
|
||||
#
|
||||
# @file make-final.py
|
||||
# @author Y.M. Morgan
|
||||
# @date 2012/07/09
|
||||
#
|
||||
# Generate the final directory by copying files from staging directories
|
||||
#
|
||||
|
||||
import sys, os, logging
|
||||
import optparse
|
||||
import shutil
|
||||
|
||||
#===============================================================================
|
||||
# Global variables.
|
||||
#===============================================================================
|
||||
|
||||
# Directories to exclude
|
||||
EXCLUDE_DIRS = ["include", "man"]
|
||||
|
||||
# Extension to exclude
|
||||
EXCLUDE_FILTERS = [".a", ".la"]
|
||||
|
||||
#===============================================================================
|
||||
# Determine if a file is an executable.
|
||||
#===============================================================================
|
||||
def isExec(filePath):
|
||||
result = False
|
||||
try:
|
||||
file = open(filePath, "r")
|
||||
header = str(file.read(4))
|
||||
if header.find("ELF") >= 0:
|
||||
result = True
|
||||
file.close()
|
||||
except IOError as ex:
|
||||
logging.error("Unable to open %s ([err=%d] %s)",
|
||||
filePath, ex.errno, ex.strerror)
|
||||
return result
|
||||
|
||||
#===============================================================================
|
||||
# Main function.
|
||||
#===============================================================================
|
||||
def main():
|
||||
(options, args) = parseArgs()
|
||||
setupLog(options)
|
||||
|
||||
# get parameters
|
||||
stagingDir = args[0]
|
||||
finalDir = args[1]
|
||||
logging.info("staging-dir : %s", stagingDir)
|
||||
logging.info("final-dir : %s", finalDir)
|
||||
|
||||
# check that staging directory exists
|
||||
if not os.path.isdir(stagingDir):
|
||||
logging.error("%s is not a directory", stagingDir)
|
||||
|
||||
# browse staging directory
|
||||
for (dirPath, dirNames, fileNames) in os.walk(stagingDir):
|
||||
# exclude some directories
|
||||
for dirName in EXCLUDE_DIRS:
|
||||
if dirName in dirNames:
|
||||
logging.debug("Exclude directory : %s",
|
||||
os.path.relpath(os.path.join(dirPath, dirName), stagingDir))
|
||||
dirNames.remove(dirName)
|
||||
for fileName in fileNames:
|
||||
# skip dome extensions
|
||||
srcFileName = os.path.join(dirPath, fileName)
|
||||
relPath = os.path.relpath(srcFileName, stagingDir)
|
||||
if os.path.splitext(srcFileName)[1] in EXCLUDE_FILTERS:
|
||||
logging.debug("Exclude file : %s", relPath)
|
||||
continue
|
||||
logging.info("File : %s", relPath)
|
||||
# destination
|
||||
dstFileName = os.path.join(finalDir, relPath)
|
||||
dstDirName = os.path.split(dstFileName)[0]
|
||||
if not os.path.exists(dstDirName):
|
||||
os.makedirs(dstDirName, 0755)
|
||||
# copy and strip executables
|
||||
if isExec(srcFileName):
|
||||
os.system("%s -o %s %s" % (options.strip, dstFileName, srcFileName))
|
||||
else:
|
||||
shutil.copy2(srcFileName, dstFileName)
|
||||
|
||||
#===============================================================================
|
||||
# Setup option parser and parse command line.
|
||||
#===============================================================================
|
||||
def parseArgs():
|
||||
usage = "usage: %prog [options] <staging-dir> <final-dir>"
|
||||
parser = optparse.OptionParser(usage = usage)
|
||||
parser.add_option("--strip",
|
||||
dest="strip",
|
||||
default=None,
|
||||
help="strip program to use to remove symbols")
|
||||
parser.add_option("-q",
|
||||
dest="quiet",
|
||||
action="store_true",
|
||||
default=False,
|
||||
help="be quiet")
|
||||
parser.add_option("-v",
|
||||
dest="verbose",
|
||||
action="count",
|
||||
default=0,
|
||||
help="verbose output (more verbose if specified twice)")
|
||||
|
||||
(options, args) = parser.parse_args()
|
||||
if len(args) > 2:
|
||||
parser.error("Too many parameters")
|
||||
elif len(args) < 2:
|
||||
parser.error("Not enough parameters")
|
||||
if options.strip == None:
|
||||
parser.error("Missing strip option")
|
||||
return (options, args)
|
||||
|
||||
#===============================================================================
|
||||
# Setup logging system.
|
||||
#===============================================================================
|
||||
def setupLog(options):
|
||||
logging.basicConfig(
|
||||
level=logging.WARNING,
|
||||
format="[%(levelname)s] %(message)s",
|
||||
stream=sys.stderr)
|
||||
logging.addLevelName(logging.CRITICAL, "C")
|
||||
logging.addLevelName(logging.ERROR, "E")
|
||||
logging.addLevelName(logging.WARNING, "W")
|
||||
logging.addLevelName(logging.INFO, "I")
|
||||
logging.addLevelName(logging.DEBUG, "D")
|
||||
|
||||
# setup log level
|
||||
if options.quiet == True:
|
||||
logging.getLogger().setLevel(logging.CRITICAL)
|
||||
elif options.verbose >= 2:
|
||||
logging.getLogger().setLevel(logging.DEBUG)
|
||||
elif options.verbose >= 1:
|
||||
logging.getLogger().setLevel(logging.INFO)
|
||||
|
||||
#===============================================================================
|
||||
# Entry point.
|
||||
#===============================================================================
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
|
||||
@ -1,66 +0,0 @@
|
||||
###############################################################################
|
||||
## @file module.mk
|
||||
## @author Y.M. Morgan
|
||||
## @date 2012/04/17
|
||||
##
|
||||
## Build a module.
|
||||
###############################################################################
|
||||
|
||||
# Bring back all LOCAL_XXX variables defined by LOCAL_MODULE
|
||||
$(call module-restore-locals,$(LOCAL_MODULE))
|
||||
|
||||
copy_to_staging := 0
|
||||
|
||||
###############################################################################
|
||||
## Static library.
|
||||
###############################################################################
|
||||
|
||||
ifeq ("$(LOCAL_MODULE_CLASS)","STATIC_LIBRARY")
|
||||
|
||||
include $(RULES)
|
||||
|
||||
$(LOCAL_BUILD_MODULE): $(all_objects)
|
||||
$(transform-o-to-static-lib)
|
||||
|
||||
copy_to_staging := 1
|
||||
|
||||
endif
|
||||
|
||||
###############################################################################
|
||||
## Shared library.
|
||||
###############################################################################
|
||||
|
||||
ifeq ("$(LOCAL_MODULE_CLASS)","SHARED_LIBRARY")
|
||||
|
||||
include $(RULES)
|
||||
|
||||
$(LOCAL_BUILD_MODULE): $(all_objects) $(all_libraries)
|
||||
$(transform-o-to-shared-lib)
|
||||
|
||||
copy_to_staging := 1
|
||||
|
||||
endif
|
||||
|
||||
###############################################################################
|
||||
## Executable.
|
||||
###############################################################################
|
||||
|
||||
ifeq ("$(LOCAL_MODULE_CLASS)","EXECUTABLE")
|
||||
|
||||
include $(RULES)
|
||||
|
||||
$(LOCAL_BUILD_MODULE): $(all_objects) $(all_libraries)
|
||||
$(transform-o-to-executable)
|
||||
|
||||
copy_to_staging := 1
|
||||
|
||||
endif
|
||||
|
||||
###############################################################################
|
||||
## Copy to staging dir
|
||||
###############################################################################
|
||||
|
||||
ifeq ("$(copy_to_staging)","1")
|
||||
$(eval $(call copy-one-file,$(LOCAL_BUILD_MODULE),$(LOCAL_STAGING_MODULE)))
|
||||
endif
|
||||
|
||||
BIN
coreLinux/qconf
BIN
coreLinux/qconf
Binary file not shown.
@ -1,307 +0,0 @@
|
||||
###############################################################################
|
||||
## @file rules.mk
|
||||
## @author Y.M. Morgan
|
||||
## @date 2011/05/14
|
||||
##
|
||||
## Generate rules for building an executable or library.
|
||||
###############################################################################
|
||||
|
||||
# Make sure LOCAL_MODULE is defined and not empty
|
||||
LOCAL_MODULE := $(strip $(LOCAL_MODULE))
|
||||
ifeq ("$(LOCAL_MODULE)","")
|
||||
$(error $(LOCAL_PATH): LOCAL_MODULE is not defined)
|
||||
endif
|
||||
|
||||
# Intermediate/Build directory
|
||||
build_dir := $(TARGET_OUT_BUILD)/$(LOCAL_MODULE)
|
||||
|
||||
# Full path to build module
|
||||
LOCAL_BUILD_MODULE := $(call module-get-build-filename,$(LOCAL_MODULE))
|
||||
|
||||
# Full path to staging module
|
||||
LOCAL_STAGING_MODULE := $(call module-get-staging-filename,$(LOCAL_MODULE))
|
||||
|
||||
# Assemble the list of targets to create PRIVATE_ variables for.
|
||||
LOCAL_TARGETS += $(LOCAL_BUILD_MODULE)
|
||||
|
||||
# Prepend some directories in include list
|
||||
LOCAL_C_INCLUDES := -I$(build_dir) -I$(LOCAL_PATH) $(LOCAL_C_INCLUDES)
|
||||
|
||||
###############################################################################
|
||||
## ARM specific checks.
|
||||
###############################################################################
|
||||
ifeq ("$(TARGET_ARCH)","ARM")
|
||||
|
||||
# Make sure LOCAL_ARM_MODE is valid
|
||||
# If not set, use default mode
|
||||
# Convert to upper case for further use
|
||||
LOCAL_ARM_MODE := $(call upcase,$(strip $(LOCAL_ARM_MODE)))
|
||||
ifeq ("$(LOCAL_ARM_MODE)","")
|
||||
LOCAL_ARM_MODE := $(TARGET_DEFAULT_ARM_MODE)
|
||||
endif
|
||||
ifneq ("$(LOCAL_ARM_MODE)","ARM")
|
||||
ifneq ("$(LOCAL_ARM_MODE)","THUMB")
|
||||
$(error $(LOCAL_PATH): LOCAL_ARM_MODE is not valid : $(LOCAL_ARM_MODE))
|
||||
endif
|
||||
endif
|
||||
|
||||
## Check that compilation flags do not include forbidden stuff.
|
||||
check-flags-arm-mode := -marm -mthumb
|
||||
check-flags = \
|
||||
$(foreach flags,$1, \
|
||||
$(if $(findstring $($3),$(flags)), \
|
||||
$(error $(LOCAL_PATH): $3 contains $(flags) : $2) \
|
||||
) \
|
||||
)
|
||||
|
||||
# Check that -marm or -mthumb is not forced in compilation flags
|
||||
flags-arm-mode := -marm -mthumb
|
||||
check-message := please use LOCAL_ARM_MODE
|
||||
check-flags-arm-mode = $(call check-flags,$(flags-arm-mode),$(check-message),$1)
|
||||
$(call check-flags-arm-mode,LOCAL_CFLAGS)
|
||||
$(call check-flags-arm-mode,LOCAL_CPPFLAGS)
|
||||
$(call check-flags-arm-mode,LOCAL_EXPORT_CFLAGS)
|
||||
$(call check-flags-arm-mode,LOCAL_EXPORT_CPPFLAGS)
|
||||
|
||||
endif
|
||||
|
||||
###############################################################################
|
||||
## List of sources, objects and libraries.
|
||||
###############################################################################
|
||||
|
||||
cpp_sources := $(filter %.cpp,$(LOCAL_SRC_FILES))
|
||||
cpp_objects := $(addprefix $(build_dir)/,$(cpp_sources:.cpp=.o))
|
||||
|
||||
cxx_sources := $(filter %.cxx,$(LOCAL_SRC_FILES))
|
||||
cxx_objects := $(addprefix $(build_dir)/,$(cxx_sources:.cxx=.o))
|
||||
|
||||
c_sources := $(filter %.c,$(LOCAL_SRC_FILES))
|
||||
c_objects := $(addprefix $(build_dir)/,$(c_sources:.c=.o))
|
||||
|
||||
s_sources := $(filter %.s,$(LOCAL_SRC_FILES))
|
||||
s_objects := $(addprefix $(build_dir)/,$(s_sources:.s=.o))
|
||||
|
||||
S_sources := $(filter %.S,$(LOCAL_SRC_FILES))
|
||||
S_objects := $(addprefix $(build_dir)/,$(S_sources:.S=.o))
|
||||
|
||||
all_objects := \
|
||||
$(cpp_objects) \
|
||||
$(cxx_objects) \
|
||||
$(c_objects) \
|
||||
$(s_objects) \
|
||||
$(S_objects) \
|
||||
|
||||
# Get all static libraries this module depends on
|
||||
LOCAL_STATIC_LIBRARIES := \
|
||||
$(call module-get-depends,$(LOCAL_STATIC_LIBRARIES),STATIC_LIBRARIES)
|
||||
LOCAL_WHOLE_STATIC_LIBRARIES := \
|
||||
$(call module-get-depends,$(LOCAL_WHOLE_STATIC_LIBRARIES),WHOLE_STATIC_LIBRARIES)
|
||||
|
||||
# Also get shared libraries used by static libraries
|
||||
LOCAL_SHARED_LIBRARIES += \
|
||||
$(call module-get-depends,$(LOCAL_STATIC_LIBRARIES),SHARED_LIBRARIES)
|
||||
LOCAL_SHARED_LIBRARIES += \
|
||||
$(call module-get-depends,$(LOCAL_WHOLE_STATIC_LIBRARIES),SHARED_LIBRARIES)
|
||||
|
||||
# Get path
|
||||
all_shared_libraries := \
|
||||
$(foreach lib,$(LOCAL_SHARED_LIBRARIES), \
|
||||
$(call module-get-staging-filename,$(lib)))
|
||||
all_static_libraries := \
|
||||
$(foreach lib,$(LOCAL_STATIC_LIBRARIES), \
|
||||
$(call module-get-staging-filename,$(lib)))
|
||||
all_whole_static_libraries := \
|
||||
$(foreach lib,$(LOCAL_WHOLE_STATIC_LIBRARIES), \
|
||||
$(call module-get-staging-filename,$(lib)))
|
||||
|
||||
all_external_libraries := \
|
||||
$(foreach lib,$(LOCAL_EXTERNAL_LIBRARIES), \
|
||||
$(TARGET_OUT_BUILD)/$(lib)/$(lib).done)
|
||||
|
||||
# all_libraries is used for the dependencies.
|
||||
all_libraries := \
|
||||
$(all_shared_libraries) \
|
||||
$(all_static_libraries) \
|
||||
$(all_whole_static_libraries) \
|
||||
$(all_external_libraries) \
|
||||
|
||||
###############################################################################
|
||||
## Import of dependencies.
|
||||
###############################################################################
|
||||
|
||||
# Get all modules we depend on
|
||||
all_depends := $(call module-get-all-dependencies,$(LOCAL_MODULE))
|
||||
all_depends := $(filter-out $(LOCAL_MODULE),$(all_depends))
|
||||
|
||||
# Get list of exported stuff by our dependencies
|
||||
imported_CFLAGS := $(call module-get-listed-export,$(all_depends),CFLAGS)
|
||||
imported_CPPFLAGS := $(call module-get-listed-export,$(all_depends),CPPFLAGS)
|
||||
imported_C_INCLUDES := $(call module-get-listed-export,$(all_depends),C_INCLUDES)
|
||||
imported_LDLIBS := $(call module-get-listed-export,$(all_depends),LDLIBS)
|
||||
imported_PREREQUISITES := $(call module-get-listed-export,$(all_depends),PREREQUISITES)
|
||||
|
||||
# The imported/exported compiler flags are prepended to their LOCAL_XXXX value
|
||||
# (this allows the module to override them).
|
||||
LOCAL_CFLAGS := $(strip $(imported_CFLAGS) $(LOCAL_EXPORT_CFLAGS) $(LOCAL_CFLAGS))
|
||||
LOCAL_CPPFLAGS := $(strip $(imported_CPPFLAGS) $(LOCAL_EXPORT_CPPFLAGS) $(LOCAL_CPPFLAGS))
|
||||
|
||||
# The imported/exported include directories are appended to their LOCAL_XXX value
|
||||
# (this allows the module to override them)
|
||||
LOCAL_C_INCLUDES := $(sort $(strip $(subst -I-I,-I,$(addprefix -I,$(LOCAL_C_INCLUDES) $(LOCAL_EXPORT_C_INCLUDES) $(imported_C_INCLUDES)))))
|
||||
#$(info LOCAL_C_INCLUDES=$(LOCAL_C_INCLUDES))
|
||||
#$(info -----)
|
||||
|
||||
# Similarly, you want the imported/exported flags to appear _after_ the LOCAL_LDLIBS
|
||||
# due to the way Unix linkers work (depending libraries must appear before
|
||||
# dependees on final link command).
|
||||
LOCAL_LDLIBS := $(strip $(LOCAL_LDLIBS) $(LOCAL_EXPORT_LDLIBS) $(imported_LDLIBS))
|
||||
|
||||
# Get all autoconf files that we depend on, don't forget to add ourself
|
||||
all_autoconf := \
|
||||
$(call module-get-listed-autoconf,$(all_depends)) \
|
||||
$(call module-get-autoconf,$(LOCAL_MODULE))
|
||||
|
||||
# Force their inclusion (space after -include and before comma is important)
|
||||
LOCAL_CFLAGS += $(addprefix -include ,$(all_autoconf))
|
||||
|
||||
# List of all prerequisites (ours + dependencies)
|
||||
all_prerequisites := \
|
||||
$(LOCAL_PREREQUISITES) \
|
||||
$(LOCAL_EXPORT_PREREQUISITES) \
|
||||
$(imported_PREREQUISITES)
|
||||
|
||||
# All autoconf files are prerequisites
|
||||
all_prerequisites += $(all_autoconf)
|
||||
|
||||
# User makefile is also a prerequisite
|
||||
all_prerequisites += $(LOCAL_PATH)/$(USER_MAKEFILE_NAME)
|
||||
|
||||
# Notify that we build with dependencies
|
||||
LOCAL_CFLAGS += $(foreach __mod,$(all_depends), \
|
||||
-DBUILD_$(call get-define,$(__mod)))
|
||||
|
||||
###############################################################################
|
||||
## Actual rules.
|
||||
###############################################################################
|
||||
|
||||
# cpp files
|
||||
ifneq ("$(strip $(cpp_objects))","")
|
||||
$(cpp_objects): $(build_dir)/%.o: $(LOCAL_PATH)/%.cpp
|
||||
$(transform-cpp-to-o)
|
||||
-include $(cpp_objects:%.o=%.d)
|
||||
endif
|
||||
|
||||
# cxx files
|
||||
ifneq ("$(strip $(cxx_objects))","")
|
||||
$(cxx_objects): $(build_dir)/%.o: $(LOCAL_PATH)/%.cxx
|
||||
$(transform-cpp-to-o)
|
||||
-include $(cxx_objects:%.o=%.d)
|
||||
endif
|
||||
|
||||
# c files
|
||||
ifneq ("$(strip $(c_objects))","")
|
||||
$(c_objects): $(build_dir)/%.o: $(LOCAL_PATH)/%.c
|
||||
$(transform-c-to-o)
|
||||
-include $(c_objects:%.o=%.d)
|
||||
endif
|
||||
|
||||
# s files
|
||||
# There is NO dependency files for raw asm code...
|
||||
ifneq ("$(strip $(s_objects))","")
|
||||
$(s_objects): $(build_dir)/%.o: $(LOCAL_PATH)/%.s
|
||||
$(transform-s-to-o)
|
||||
endif
|
||||
|
||||
# S files
|
||||
# There are dependency files for asm code...
|
||||
ifneq ("$(strip $(S_objects))","")
|
||||
$(S_objects): $(build_dir)/%.o: $(LOCAL_PATH)/%.S
|
||||
$(transform-s-to-o)
|
||||
-include $(S_objects:%.o=%.d)
|
||||
endif
|
||||
|
||||
# clean- targets
|
||||
cleantarget := clean-$(LOCAL_MODULE)
|
||||
$(cleantarget) : PRIVATE_MODULE := $(LOCAL_MODULE)
|
||||
$(cleantarget) : PRIVATE_CLEAN_FILES := \
|
||||
$(LOCAL_BUILD_MODULE) \
|
||||
$(LOCAL_STAGING_MODULE) \
|
||||
$(build_dir)
|
||||
$(cleantarget)::
|
||||
@echo "Clean: $(PRIVATE_MODULE)"
|
||||
$(Q)rm -rf $(PRIVATE_CLEAN_FILES)
|
||||
|
||||
## Provide a short-hand for building this module.
|
||||
.PHONY: $(LOCAL_MODULE)
|
||||
$(LOCAL_MODULE): $(LOCAL_BUILD_MODULE) $(LOCAL_STAGING_MODULE)
|
||||
|
||||
# Make sure external libraries are built first
|
||||
# Do NOT force rebuild at each check (order prerequisite)
|
||||
# TODO : check why order prerequisite
|
||||
#$(all_objects): | $(external_libraries)
|
||||
|
||||
# Make sure all prerequisites files are generated first
|
||||
ifneq ("$(all_prerequisites)","")
|
||||
$(all_objects): $(all_prerequisites)
|
||||
endif
|
||||
|
||||
###############################################################################
|
||||
## autoconf.h file generation.
|
||||
###############################################################################
|
||||
|
||||
autoconf_file := $(call module-get-autoconf,$(LOCAL_MODULE))
|
||||
ifneq ("$(autoconf_file)","")
|
||||
|
||||
# autoconf.h file depends on module config
|
||||
$(autoconf_file): $(call __get_module-config,$(LOCAL_MODULE))
|
||||
@$(call generate-autoconf-file,$<,$@)
|
||||
|
||||
endif
|
||||
|
||||
###############################################################################
|
||||
## Precompiled headers.
|
||||
###############################################################################
|
||||
|
||||
LOCAL_PRECOMPILED_FILE := $(strip $(LOCAL_PRECOMPILED_FILE))
|
||||
ifneq ("$(LOCAL_PRECOMPILED_FILE)","")
|
||||
|
||||
gch_file := $(build_dir)/$(LOCAL_PRECOMPILED_FILE).gch
|
||||
|
||||
# All objects will depends on the precompiled file
|
||||
$(all_objects): $(gch_file)
|
||||
|
||||
# Make sure all prerequisites files are generated first
|
||||
ifneq ("$(all_prerequisites)","")
|
||||
$(gch_file): $(all_prerequisites)
|
||||
endif
|
||||
|
||||
# Generate the precompiled file
|
||||
$(gch_file): $(LOCAL_PATH)/$(LOCAL_PRECOMPILED_FILE)
|
||||
$(transform-h-to-gch)
|
||||
-include $(gch_file:%.gch=%.d)
|
||||
|
||||
# Make sure external libraries are built first (order prerequisite)
|
||||
# TODO : check why order prerequisite
|
||||
#$(gch_file): | $(external_libraries)
|
||||
|
||||
endif
|
||||
|
||||
###############################################################################
|
||||
# Rule-specific variable definitions.
|
||||
###############################################################################
|
||||
|
||||
$(LOCAL_TARGETS): PRIVATE_PATH := $(LOCAL_PATH)
|
||||
$(LOCAL_TARGETS): PRIVATE_MODULE := $(LOCAL_MODULE)
|
||||
$(LOCAL_TARGETS): PRIVATE_CFLAGS := $(LOCAL_CFLAGS)
|
||||
$(LOCAL_TARGETS): PRIVATE_C_INCLUDES := $(LOCAL_C_INCLUDES)
|
||||
$(LOCAL_TARGETS): PRIVATE_CPPFLAGS := $(LOCAL_CPPFLAGS)
|
||||
$(LOCAL_TARGETS): PRIVATE_ARFLAGS := $(LOCAL_ARFLAGS)
|
||||
$(LOCAL_TARGETS): PRIVATE_LDFLAGS := $(LOCAL_LDFLAGS)
|
||||
$(LOCAL_TARGETS): PRIVATE_LDLIBS := $(LOCAL_LDLIBS)
|
||||
$(LOCAL_TARGETS): PRIVATE_ARM_MODE := $(LOCAL_ARM_MODE)
|
||||
$(LOCAL_TARGETS): PRIVATE_ALL_SHARED_LIBRARIES := $(all_shared_libraries)
|
||||
$(LOCAL_TARGETS): PRIVATE_ALL_STATIC_LIBRARIES := $(all_static_libraries)
|
||||
$(LOCAL_TARGETS): PRIVATE_ALL_WHOLE_STATIC_LIBRARIES := $(all_whole_static_libraries)
|
||||
$(LOCAL_TARGETS): PRIVATE_ALL_EXTERNAL_LIBRARIES := $(all_external_libraries)
|
||||
$(LOCAL_TARGETS): PRIVATE_ALL_OBJECTS := $(all_objects)
|
||||
|
||||
@ -1,115 +0,0 @@
|
||||
###############################################################################
|
||||
## @file config.mk
|
||||
## @author Y.M. Morgan
|
||||
## @date 2011/05/14
|
||||
###############################################################################
|
||||
|
||||
###############################################################################
|
||||
## Make sure that there are no spaces in the absolute path; the build system
|
||||
## can't deal with them.
|
||||
###############################################################################
|
||||
|
||||
ifneq ("$(words $(shell pwd))","1")
|
||||
$(error Top directory contains space characters)
|
||||
endif
|
||||
|
||||
###############################################################################
|
||||
## Host/Target OS.
|
||||
###############################################################################
|
||||
|
||||
# Host OS
|
||||
ifneq ("$(shell echo $$OSTYPE | grep msys)","")
|
||||
HOST_OS := MINGW32
|
||||
HOST_EXE_SUFFIX := .exe
|
||||
HOST_SHARED_LIB_SUFFIX := .dll
|
||||
else
|
||||
HOST_OS := LINUX
|
||||
HOST_EXE_SUFFIX :=
|
||||
HOST_SHARED_LIB_SUFFIX := .so
|
||||
endif
|
||||
|
||||
# Target OS : default to HOST_OS unless set
|
||||
ifndef TARGET_OS
|
||||
TARGET_OS := $(HOST_OS)
|
||||
endif
|
||||
|
||||
# Exe/dll suffix under mingw
|
||||
TARGET_STATIC_LIB_SUFFIX := .a
|
||||
ifeq ("$(TARGET_OS)","MINGW32")
|
||||
DIR_SUFFIX := _mingw32
|
||||
TARGET_EXE_SUFFIX := .exe
|
||||
TARGET_SHARED_LIB_SUFFIX := .dll
|
||||
else
|
||||
DIR_SUFFIX :=
|
||||
TARGET_EXE_SUFFIX :=
|
||||
TARGET_SHARED_LIB_SUFFIX := .so
|
||||
endif
|
||||
|
||||
ifeq ("$(TARGET_OS)","MINGW32")
|
||||
# may be overridden in make command line
|
||||
STATIC := 1
|
||||
TARGET_GLOBAL_CFLAGS += -D__MINGW_FEATURES__=0
|
||||
TARGET_GLOBAL_LDFLAGS += -Wl,--enable-auto-import
|
||||
ifeq ("$(STATIC)","1")
|
||||
TARGET_GLOBAL_LDFLAGS += -Wl,-Bstatic
|
||||
endif
|
||||
endif
|
||||
|
||||
# To be able to use ccache with pre-complied headers, some env variables are required
|
||||
CCACHE :=
|
||||
ifeq ("$(USE_CCACHE)","1")
|
||||
ifneq ("$(shell which ccache)","")
|
||||
CCACHE := CCACHE_SLOPPINESS=time_macros ccache
|
||||
TARGET_GLOBAL_CFLAGS += -fpch-preprocess
|
||||
endif
|
||||
endif
|
||||
|
||||
# Pre-compiled header generation flag
|
||||
ifneq ("$(USE_CLANG)","1")
|
||||
TARGET_PCH_FLAGS := -c
|
||||
else
|
||||
TARGET_PCH_FLAGS := -x c++-header
|
||||
endif
|
||||
|
||||
# Architecture
|
||||
#ifndef TARGET_ARCH
|
||||
# ifneq ("$(shell $(GCC) -dumpmachine | grep 64)","")
|
||||
# TARGET_ARCH := AMD64
|
||||
# else
|
||||
# TARGET_ARCH := X86
|
||||
# endif
|
||||
#endif
|
||||
|
||||
# Update flags based on architecture
|
||||
# 64-bit requires -fPIC to build shared libraries
|
||||
#ifeq ("$(TARGET_ARCH)","AMD64")
|
||||
# TARGET_GLOBAL_CFLAGS += -m64 -fPIC
|
||||
#else
|
||||
# TARGET_GLOBAL_CFLAGS += -m32
|
||||
#endif
|
||||
|
||||
###############################################################################
|
||||
## Variables based on DEBUG/STATIC.
|
||||
###############################################################################
|
||||
|
||||
#ifeq ("$(DEBUG)","0")
|
||||
# TARGET_GLOBAL_CFLAGS += -O2 -g -DNDEBUG
|
||||
# TARGET_OUT_INTERMEDIATES := $(TOP_DIR)/build_gcc$(DIR_SUFFIX)/release
|
||||
# TARGET_OUT := $(TOP_DIR)/out_gcc$(DIR_SUFFIX)/release
|
||||
#else
|
||||
# TARGET_GLOBAL_CFLAGS += -O0 -g -DDEBUG -D_DEBUG
|
||||
# TARGET_OUT_INTERMEDIATES := $(TOP_DIR)/build_gcc$(DIR_SUFFIX)/debug
|
||||
# TARGET_OUT := $(TOP_DIR)/out_gcc$(DIR_SUFFIX)/debug
|
||||
#endif
|
||||
|
||||
###############################################################################
|
||||
## Determine gcc path and version.
|
||||
###############################################################################
|
||||
|
||||
GCC_PATH := $(shell which $(GCC))
|
||||
|
||||
ifneq ("$(USE_CLANG)","1")
|
||||
GCC_VERSION := $(shell $(GCC) --version | head -1 | sed "s/.*\([0-9]\.[0-9]\.[0-9]\).*/\1/")
|
||||
else
|
||||
GCC_VERSION := 0.0.0
|
||||
endif
|
||||
@ -1,16 +0,0 @@
|
||||
###############################################################################
|
||||
## @file shared.mk
|
||||
## @author Y.M. Morgan
|
||||
## @date 2011/05/14
|
||||
##
|
||||
## Build a shared library.
|
||||
###############################################################################
|
||||
|
||||
LOCAL_MODULE_CLASS := SHARED_LIBRARY
|
||||
LOCAL_DESTDIR := usr/lib
|
||||
|
||||
ifndef LOCAL_MODULE_FILENAME
|
||||
LOCAL_MODULE_FILENAME := $(LOCAL_MODULE)$(TARGET_SHARED_LIB_SUFFIX)
|
||||
endif
|
||||
|
||||
$(call module-add,$(LOCAL_MODULE))
|
||||
@ -1,16 +0,0 @@
|
||||
###############################################################################
|
||||
## @file static.mk
|
||||
## @author Y.M. Morgan
|
||||
## @date 2011/05/14
|
||||
##
|
||||
## Build a static library.
|
||||
###############################################################################
|
||||
|
||||
LOCAL_MODULE_CLASS := STATIC_LIBRARY
|
||||
LOCAL_DESTDIR := usr/lib
|
||||
|
||||
ifndef LOCAL_MODULE_FILENAME
|
||||
LOCAL_MODULE_FILENAME := $(LOCAL_MODULE)$(TARGET_STATIC_LIB_SUFFIX)
|
||||
endif
|
||||
|
||||
$(call module-add,$(LOCAL_MODULE))
|
||||
@ -1,68 +0,0 @@
|
||||
###############################################################################
|
||||
## @file warnings.mk
|
||||
## @author Y.M. Morgan
|
||||
## @date 2012/06/09
|
||||
##
|
||||
## Setup warning flags.
|
||||
###############################################################################
|
||||
|
||||
COMMON_FLAGS_WARNINGS :=
|
||||
GCC_FLAGS_WARNINGS :=
|
||||
GXX_FLAGS_WARNINGS :=
|
||||
|
||||
# show option associated with warning (gcc >= 4.0.0)
|
||||
ifneq (0,$(shell expr $(GCC_VERSION) \>= 4.0.0))
|
||||
COMMON_FLAGS_WARNINGS += -fdiagnostics-show-option
|
||||
endif
|
||||
|
||||
COMMON_FLAGS_WARNINGS += -Wall
|
||||
#COMMON_FLAGS_WARNINGS += -Wextra
|
||||
COMMON_FLAGS_WARNINGS += -Wno-unused -Wno-unused-parameter -Wunused-value -Wunused-variable -Wunused-label
|
||||
#COMMON_FLAGS_WARNINGS += -Wshadow
|
||||
#COMMON_FLAGS_WARNINGS += -Wswitch-default
|
||||
#COMMON_FLAGS_WARNINGS += -Wwrite-strings
|
||||
#COMMON_FLAGS_WARNINGS += -Wundef
|
||||
#COMMON_FLAGS_WARNINGS += -Wpointer-arith
|
||||
#COMMON_FLAGS_WARNINGS += -Wformat-nonliteral
|
||||
#COMMON_FLAGS_WARNINGS += -Wformat-security
|
||||
#COMMON_FLAGS_WARNINGS += -Winit-self
|
||||
|
||||
# C specific
|
||||
#GCC_FLAGS_WARNINGS += -Wmissing-declarations
|
||||
#GCC_FLAGS_WARNINGS += -Wmissing-prototypes
|
||||
#GCC_FLAGS_WARNINGS += -Wjump-misses-init
|
||||
|
||||
# c++ specific
|
||||
#GXX_FLAGS_WARNINGS += -Wctor-dtor-privacy
|
||||
#GXX_FLAGS_WARNINGS += -Wnon-virtual-dtor
|
||||
#GXX_FLAGS_WARNINGS += -Wreorder
|
||||
#GXX_FLAGS_WARNINGS += -Woverloaded-virtual
|
||||
|
||||
# gcc >= 4.5.0 (too many false positives with previous versions)
|
||||
ifneq (0,$(shell expr $(GCC_VERSION) \>= 4.5.0))
|
||||
#COMMON_FLAGS_WARNINGS += -Wunreachable-code
|
||||
endif
|
||||
|
||||
# gcc >= 4.5.2
|
||||
ifneq (0,$(shell expr $(GCC_VERSION) \>= 4.5.2))
|
||||
#COMMON_FLAGS_WARNINGS += -Wlogical-op
|
||||
endif
|
||||
|
||||
# Extra warnings
|
||||
ifeq ("$(W)","1")
|
||||
|
||||
COMMON_FLAGS_WARNINGS += -Wconversion
|
||||
COMMON_FLAGS_WARNINGS += -Wswitch-enum
|
||||
COMMON_FLAGS_WARNINGS += -Wcast-qual
|
||||
|
||||
# gcc >= 4.4.0
|
||||
ifneq (0,$(shell expr $(GCC_VERSION) \>= 4.4.0))
|
||||
COMMON_FLAGS_WARNINGS += -Wframe-larger-than=1024
|
||||
endif
|
||||
|
||||
endif
|
||||
|
||||
# Add common flags to specific flags
|
||||
GCC_FLAGS_WARNINGS += $(COMMON_FLAGS_WARNINGS)
|
||||
GXX_FLAGS_WARNINGS += $(COMMON_FLAGS_WARNINGS)
|
||||
|
||||
80
doc/010_basic_concept.md
Normal file
80
doc/010_basic_concept.md
Normal file
@ -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
|
||||
|
||||
229
doc/020_Compile_a_module.md
Normal file
229
doc/020_Compile_a_module.md
Normal file
@ -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
|
||||
|
||||
504
doc/030_Create_a_new_module.md
Normal file
504
doc/030_Create_a_new_module.md
Normal file
@ -0,0 +1,504 @@
|
||||
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"
|
||||
# "MPL-1" / "MPL-1.1" / "MPL-2"
|
||||
# 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"
|
||||
# "MPL-1" / "MPL-1.1" / "MPL-2"
|
||||
# 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
|
||||
|
||||
112
doc/100_Use_on_Ios.md
Normal file
112
doc/100_Use_on_Ios.md
Normal file
@ -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
|
||||
```
|
||||
|
||||
Application 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
|
||||
```
|
||||
15
doc/101_Use_on_Android.md
Normal file
15
doc/101_Use_on_Android.md
Normal file
@ -0,0 +1,15 @@
|
||||
Connect device
|
||||
To connect to a real device or phone via ADB under Arch, you must:
|
||||
|
||||
install android-udev
|
||||
|
||||
plug in your android device via USB.
|
||||
|
||||
Enable USB Debugging on your phone or device:
|
||||
|
||||
Jelly Bean (4.2) and newer: Go to Settings --> About Phone tap “Build Number” 7 times until you get a popup that you have become a developer. Then go to Settings --> Developer --> USB debugging and enable it. The device will ask to allow the computer with its fingerprint to connect. allowing it permanent will copy $HOME/.android/adbkey.pub onto the devices /data/misc/adb/adb_keys folder.
|
||||
|
||||
If android-udev has been installed, add yourself to the adbusers group:
|
||||
|
||||
# gpasswd -a username adbusers
|
||||
|
||||
144
doc/mainpage.md
Normal file
144
doc/mainpage.md
Normal file
@ -0,0 +1,144 @@
|
||||
Lutin Build system {#mainpage}
|
||||
==================
|
||||
|
||||
@tableofcontents
|
||||
|
||||
`lutin` is a generic builder and package maker is a FREE software tool.
|
||||
|
||||
|
||||
 https://pypi.python.org/pypi/lutin
|
||||
|
||||
|
||||
Release (master) {#lutin_mainpage_build_master}
|
||||
================
|
||||
|
||||
 https://travis-ci.org/HeeroYui/lutin
|
||||
|
||||
|
||||
Developement (dev) {#lutin_mainpage_build_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 (MPL v2.0) {#lutin_mainpage_licence}
|
||||
=====================
|
||||
|
||||
Copyright lutin Edouard DUPIN
|
||||
|
||||
Licensed under the Mozilla Public 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
|
||||
|
||||
https://www.mozilla.org/MPL/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)
|
||||
35
doxy_lutin.py
Normal file
35
doxy_lutin.py
Normal file
@ -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
|
||||
157
lutin/__init__.py
Executable file
157
lutin/__init__.py
Executable file
@ -0,0 +1,157 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
import os
|
||||
import sys
|
||||
import fnmatch
|
||||
# Local import
|
||||
from . import macro
|
||||
from . import target
|
||||
from . import builder
|
||||
from . import system
|
||||
from . import host
|
||||
from . import tools
|
||||
from realog import debug
|
||||
from . import module
|
||||
from . import env
|
||||
is_init = False
|
||||
|
||||
|
||||
def filter_name_and_file(root, list_files, filter):
|
||||
# filter elements:
|
||||
tmp_list = fnmatch.filter(list_files, filter)
|
||||
out = []
|
||||
for elem in tmp_list:
|
||||
if os.path.isfile(os.path.join(root, elem)) == True:
|
||||
out.append(elem);
|
||||
return out;
|
||||
|
||||
def filter_path(root, list_files):
|
||||
out = []
|
||||
for elem in list_files:
|
||||
if len(elem) == 0 \
|
||||
or elem[0] == '.':
|
||||
continue
|
||||
if os.path.isdir(os.path.join(root, elem)) == True:
|
||||
out.append(elem);
|
||||
return out;
|
||||
|
||||
def import_path_local(path, limit_sub_folder, exclude_path = [], base_name = ""):
|
||||
out = []
|
||||
debug.verbose("lutin files: " + str(path) + " [START]")
|
||||
if limit_sub_folder == 0:
|
||||
debug.debug("Subparsing limitation append ...")
|
||||
return []
|
||||
try:
|
||||
list_files = os.listdir(path)
|
||||
except:
|
||||
# an error occure, maybe read error ...
|
||||
debug.warning("error when getting subdirectory of '" + str(path) + "'")
|
||||
return []
|
||||
if path in exclude_path:
|
||||
debug.debug("find '" + str(path) + "' in exclude_path=" + str(exclude_path))
|
||||
return []
|
||||
# filter elements:
|
||||
tmp_list_lutin_file = filter_name_and_file(path, list_files, base_name + "*.py")
|
||||
debug.verbose("lutin files: " + str(path) + " : " + str(tmp_list_lutin_file))
|
||||
# Import the module:
|
||||
for filename in tmp_list_lutin_file:
|
||||
out.append(os.path.join(path, filename))
|
||||
debug.extreme_verbose(" Find a file : '" + str(out[-1]) + "'")
|
||||
need_parse_sub_folder = True
|
||||
rm_value = -1
|
||||
# check if we need to parse sub_folder
|
||||
if len(tmp_list_lutin_file) != 0:
|
||||
need_parse_sub_folder = False
|
||||
# check if the file "lutin_parse_sub.py" is present ==> parse SubFolder (force and add +1 in the resursing
|
||||
if base_name + "ParseSubFolders.txt" in list_files:
|
||||
debug.debug("find SubParser ... " + str(base_name + "ParseSubFolders.txt") + " " + path)
|
||||
data_file_sub = tools.file_read_data(os.path.join(path, base_name + "ParseSubFolders.txt"))
|
||||
if data_file_sub == "":
|
||||
debug.debug(" Empty file Load all subfolder in the worktree in '" + str(path) + "'")
|
||||
need_parse_sub_folder = True
|
||||
rm_value = 0
|
||||
else:
|
||||
list_sub = data_file_sub.split("\n")
|
||||
debug.debug(" Parse selected folders " + str(list_sub) + " no parse local folder directory")
|
||||
need_parse_sub_folder = False
|
||||
for folder in list_sub:
|
||||
if folder == "" \
|
||||
or folder == "/":
|
||||
continue;
|
||||
tmp_out = import_path_local(os.path.join(path, folder),
|
||||
1,
|
||||
exclude_path,
|
||||
base_name)
|
||||
# add all the elements:
|
||||
for elem in tmp_out:
|
||||
out.append(elem)
|
||||
if need_parse_sub_folder == True:
|
||||
list_folders = filter_path(path, list_files)
|
||||
for folder in list_folders:
|
||||
tmp_out = import_path_local(os.path.join(path, folder),
|
||||
limit_sub_folder - rm_value,
|
||||
exclude_path,
|
||||
base_name)
|
||||
# add all the elements:
|
||||
for elem in tmp_out:
|
||||
out.append(elem)
|
||||
return out
|
||||
|
||||
|
||||
def init():
|
||||
global is_init;
|
||||
if is_init == True:
|
||||
return
|
||||
debug.verbose("Use Make as a make stadard")
|
||||
sys.path.append(tools.get_run_path())
|
||||
# create the list of basic folder:
|
||||
basic_folder_list = []
|
||||
basic_folder_list.append([tools.get_current_path(__file__), True])
|
||||
# Import all sub path without out and archive
|
||||
for elem_path in os.listdir("."):
|
||||
if os.path.isdir(elem_path) == False:
|
||||
continue
|
||||
if elem_path.lower() == "android" \
|
||||
or elem_path == "out" :
|
||||
continue
|
||||
debug.debug("Automatic load path: '" + elem_path + "'")
|
||||
basic_folder_list.append([elem_path, False])
|
||||
|
||||
# create in a single path the basic list of lutin files (all start with lutin and end with .py)
|
||||
exclude_path = env.get_exclude_search_path()
|
||||
limit_sub_folder = env.get_parse_depth()
|
||||
list_of_lutin_files = []
|
||||
for elem_path, is_system in basic_folder_list:
|
||||
if is_system == True:
|
||||
limit_sub_folder_tmp = 999999
|
||||
else:
|
||||
limit_sub_folder_tmp = limit_sub_folder
|
||||
tmp_out = import_path_local(elem_path,
|
||||
limit_sub_folder_tmp,
|
||||
exclude_path,
|
||||
env.get_build_system_base_name())
|
||||
# add all the elements:
|
||||
for elem in tmp_out:
|
||||
list_of_lutin_files.append(elem)
|
||||
|
||||
debug.debug("Files specific lutin: ")
|
||||
for elem_path in list_of_lutin_files:
|
||||
debug.debug(" " + elem_path)
|
||||
# simply import element from the basic list of files (single parse ...)
|
||||
builder.import_path(list_of_lutin_files)
|
||||
module.import_path(list_of_lutin_files)
|
||||
system.import_path(list_of_lutin_files)
|
||||
target.import_path(list_of_lutin_files)
|
||||
macro.import_path(list_of_lutin_files)
|
||||
|
||||
builder.init()
|
||||
is_init = True
|
||||
|
||||
|
||||
100
lutin/builder.py
Normal file
100
lutin/builder.py
Normal file
@ -0,0 +1,100 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
import sys
|
||||
import os
|
||||
import inspect
|
||||
import fnmatch
|
||||
import datetime
|
||||
# Local import
|
||||
from realog import debug
|
||||
from . import heritage
|
||||
from . import env
|
||||
|
||||
##
|
||||
## constitution of dictionnary:
|
||||
## - "type": "compiler", "linker"
|
||||
## - "in": input type file
|
||||
## - "out": extention of the files
|
||||
## - "builder": pointer on the element
|
||||
##
|
||||
builder_list=[]
|
||||
__start_builder_name="Builder_"
|
||||
|
||||
##
|
||||
## @brief Import all File that start with env.get_build_system_base_name() + __start_builder_name + XXX and register in the list of Builder
|
||||
## @param[in] path_list ([string,...]) List of file that start with env.get_build_system_base_name() in the running worktree (Parse one time ==> faster)
|
||||
##
|
||||
def import_path(path_list):
|
||||
global builder_list
|
||||
global_base = env.get_build_system_base_name()
|
||||
debug.debug("BUILDER: Init with Files list:")
|
||||
for elem in path_list:
|
||||
sys.path.append(os.path.dirname(elem))
|
||||
# Get file name:
|
||||
filename = os.path.basename(elem)
|
||||
# Remove .py at the end:
|
||||
filename = filename[:-3]
|
||||
base_file_name = filename
|
||||
# Remove global base name:
|
||||
filename = filename[len(global_base):]
|
||||
# Check if it start with the local patern:
|
||||
if filename[:len(__start_builder_name)] != __start_builder_name:
|
||||
debug.extreme_verbose("BUILDER: Integrate: '" + filename + "' from '" + elem + "' ==> rejected")
|
||||
continue
|
||||
# Remove local patern
|
||||
builder_name = filename[len(__start_builder_name):]
|
||||
debug.verbose("BUILDER: Integrate: '" + builder_name + "' from '" + elem + "'")
|
||||
the_builder = __import__(base_file_name)
|
||||
builder_list.append({"name":builder_name,
|
||||
"element":the_builder
|
||||
})
|
||||
debug.debug('BUILDER: type=' + the_builder.get_type() + " in=" + str(the_builder.get_input_type()) + " out=" + str(the_builder.get_output_type()))
|
||||
debug.verbose("List of BUILDER: ")
|
||||
for elem in builder_list:
|
||||
debug.verbose(" " + str(elem["name"]))
|
||||
|
||||
|
||||
##
|
||||
## @brief All builder are common (no target or comilator dependency). We need to load all of them when start lutin
|
||||
##
|
||||
def init():
|
||||
global builder_list
|
||||
debug.debug('BUILDER: Initialize all ...')
|
||||
for element in builder_list:
|
||||
if element["element"] != None:
|
||||
element["element"].init()
|
||||
|
||||
##
|
||||
## @brief Get a builder tool with specifiying the input type (like cpp, S ...)
|
||||
## @param[in] input_type (string) extention file that can be compile
|
||||
##
|
||||
def get_builder(input_type):
|
||||
global builder_list
|
||||
for element in builder_list:
|
||||
if element["element"] != None:
|
||||
if input_type in element["element"].get_input_type():
|
||||
return element["element"]
|
||||
# we can not find the builder ...
|
||||
debug.error("Can not find builder for type : '" + str(input_type) + "'")
|
||||
raise ValueError('type error :' + str(input_type))
|
||||
|
||||
##
|
||||
## @brief Get a builder tool with specifiying the output type (like .exe, .jar ...)
|
||||
## @param[in] input_type (string) extention file that can be generated
|
||||
##
|
||||
def get_builder_with_output(output_type):
|
||||
global builder_list
|
||||
for element in builder_list:
|
||||
if element["element"] != None:
|
||||
if output_type in element["element"].get_output_type():
|
||||
return element["element"]
|
||||
# we can not find the builder ...
|
||||
debug.error("Can not find builder for type : '" + str(output_type) + "'")
|
||||
raise ValueError('type error :' + str(output_type))
|
||||
245
lutin/depend.py
Normal file
245
lutin/depend.py
Normal file
@ -0,0 +1,245 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
import os
|
||||
# Local import
|
||||
from realog import debug
|
||||
from . import env
|
||||
|
||||
def _create_directory_of_file(file):
|
||||
path = os.path.dirname(file)
|
||||
try:
|
||||
os.stat(path)
|
||||
except:
|
||||
os.makedirs(path)
|
||||
|
||||
def _file_write_data(path, data):
|
||||
file = open(path, "w")
|
||||
file.write(data)
|
||||
file.close()
|
||||
|
||||
def _file_size(path):
|
||||
if not os.path.isfile(path):
|
||||
return 0
|
||||
statinfo = os.stat(path)
|
||||
return statinfo.st_size
|
||||
|
||||
def _file_read_data(path, binary=False):
|
||||
if not os.path.isfile(path):
|
||||
return ""
|
||||
if binary == True:
|
||||
file = open(path, "rb")
|
||||
else:
|
||||
file = open(path, "r")
|
||||
data_file = file.read()
|
||||
file.close()
|
||||
return data_file
|
||||
|
||||
##
|
||||
## @brief Creata a dependency file with a list of files
|
||||
## @param[in] depend_file (string) filename to store a dependency data
|
||||
## @param[in] list_files ([string,...]) List of file that depend the current element
|
||||
##
|
||||
def create_dependency_file(depend_file, list_files):
|
||||
data = ""
|
||||
for elem in list_files:
|
||||
data += elem + "\n"
|
||||
_create_directory_of_file(depend_file)
|
||||
_file_write_data(depend_file, data)
|
||||
|
||||
##
|
||||
## @brief Check if all dependency of a file and dependency file is correct or not
|
||||
## @param[in] dst (string) File that will be generated
|
||||
## @param[in] src (string) Source File needed to generate the 'dst'
|
||||
## @param[in] depend_file (string) Dependency file that contain all file that the src depending
|
||||
## @param[in] file_cmd (string) Filename of where is store the cmdline to generate the 'dst'
|
||||
## @param[in] cmd_line (string) Command line that will be use to generate the 'dst'
|
||||
## @param[in] force_identical (string) for copy file this check if the src and dst are identical
|
||||
## @return (bool) True: something change ==> need to rebuild, False otherwise
|
||||
##
|
||||
def need_re_build(dst, src, depend_file=None, file_cmd="", cmd_line="", force_identical=False):
|
||||
debug.extreme_verbose("Request check of dependency of :")
|
||||
debug.extreme_verbose(" dst='" + str(dst) + "'")
|
||||
debug.extreme_verbose(" src='" + str(src) + "'")
|
||||
debug.extreme_verbose(" dept='" + str(depend_file) + "'")
|
||||
debug.extreme_verbose(" cmd='" + str(file_cmd) + "'")
|
||||
debug.extreme_verbose(" force_identical='" + str(force_identical) + "'")
|
||||
# if force mode selected ==> just force rebuild ...
|
||||
if env.get_force_mode():
|
||||
debug.extreme_verbose(" ==> must rebuild (force mode)")
|
||||
return True
|
||||
|
||||
# check if the destination existed:
|
||||
if dst != "" \
|
||||
and dst != None \
|
||||
and os.path.exists(dst) == False:
|
||||
debug.extreme_verbose(" ==> must rebuild (dst does not exist)")
|
||||
return True
|
||||
if src != "" \
|
||||
and src != None \
|
||||
and os.path.exists(src) == False:
|
||||
debug.warning(" ==> unexistant file :'" + src + "'")
|
||||
return True
|
||||
# Check the basic date if the 2 files
|
||||
if dst != "" \
|
||||
and dst != None \
|
||||
and src != "" \
|
||||
and src != None \
|
||||
and os.path.getmtime(src) > os.path.getmtime(dst):
|
||||
debug.extreme_verbose(" ==> must rebuild (source time greater)")
|
||||
return True
|
||||
|
||||
if depend_file != "" \
|
||||
and depend_file != None \
|
||||
and os.path.exists(depend_file) == False:
|
||||
debug.extreme_verbose(" ==> must rebuild (no depending file)")
|
||||
return True
|
||||
|
||||
if file_cmd != "" \
|
||||
and file_cmd != None:
|
||||
if os.path.exists(file_cmd) == False:
|
||||
debug.extreme_verbose(" ==> must rebuild (no commandLine file)")
|
||||
return True
|
||||
# check if the 2 cmd_line are similar :
|
||||
file2 = open(file_cmd, "r")
|
||||
first_and_unique_line = file2.read()
|
||||
if first_and_unique_line != cmd_line:
|
||||
debug.extreme_verbose(" ==> must rebuild (cmd_lines are not identical)")
|
||||
debug.extreme_verbose(" ==> '" + cmd_line + "'")
|
||||
debug.extreme_verbose(" ==> '" + first_and_unique_line + "'")
|
||||
file2.close()
|
||||
return True
|
||||
# the cmdfile is correct ...
|
||||
file2.close()
|
||||
|
||||
if depend_file != "" \
|
||||
and depend_file != None:
|
||||
debug.extreme_verbose(" start parsing dependency file : '" + depend_file + "'")
|
||||
file = open(depend_file, "r")
|
||||
for cur_line in file.readlines():
|
||||
# normal file : end with : ": \\n"
|
||||
cur_line = cur_line[:len(cur_line)-1]
|
||||
# removing last \ ...
|
||||
if cur_line[len(cur_line)-1:] == '\\' :
|
||||
cur_line = cur_line[:len(cur_line)-1]
|
||||
# remove white space :
|
||||
#debug.verbose(" Line (read) : '" + cur_line + "'");
|
||||
cur_line = cur_line.strip()
|
||||
#debug.verbose(" Line (strip) : '" + cur_line + "'");
|
||||
|
||||
test_file=""
|
||||
if cur_line[len(cur_line)-1:] == ':':
|
||||
debug.extreme_verbose(" Line (no check (already done) : '" + cur_line + "'");
|
||||
elif len(cur_line) == 0 \
|
||||
or cur_line == '\\':
|
||||
debug.extreme_verbose(" Line (Not parsed) : '" + cur_line + "'");
|
||||
else:
|
||||
test_file = cur_line
|
||||
debug.extreme_verbose(" Line (might check) : '" + test_file + "'");
|
||||
# really check files:
|
||||
if test_file != "":
|
||||
debug.extreme_verbose(" ==> test");
|
||||
if False==os.path.exists(test_file):
|
||||
debug.extreme_verbose(" ==> must rebuild (a dependency file does not exist)")
|
||||
file.close()
|
||||
return True
|
||||
if os.path.getmtime(test_file) > os.path.getmtime(dst):
|
||||
debug.extreme_verbose(" ==> must rebuild (a dependency file time is newer)")
|
||||
file.close()
|
||||
return True
|
||||
# close the current file :
|
||||
file.close()
|
||||
# check the 2 files are identical:
|
||||
if force_identical == True:
|
||||
# check if the 2 cmd_line are similar:
|
||||
size_src = _file_size(src)
|
||||
size_dst = _file_size(dst)
|
||||
if size_src != size_dst:
|
||||
debug.extreme_verbose(" Force Rewrite not the same size size_src=" + str(size_src) + " != size_dest=" + str(size_dst))
|
||||
return True
|
||||
data_src = _file_read_data(src, binary=True)
|
||||
data_dst = _file_read_data(dst, binary=True)
|
||||
if data_src != data_dst:
|
||||
debug.extreme_verbose(" Force Rewrite not the same data")
|
||||
return True
|
||||
|
||||
debug.extreme_verbose(" ==> Not rebuild (all dependency is OK)")
|
||||
return False
|
||||
|
||||
##
|
||||
## @brief
|
||||
## @param[in] dst (string) File that will be generated
|
||||
## @param[in] src_list ([string,...]) Source file list needed to generate the 'dst'
|
||||
## @param[in] must_have_src (bool) All sources must be present
|
||||
## @param[in] file_cmd (string) Filename of where is store the cmdline to generate the 'dst'
|
||||
## @param[in] cmd_line (string) Command line that will be use to generate the 'dst'
|
||||
## @return (bool) True: Need to regenerate the package, False otherwise
|
||||
##
|
||||
def need_re_package(dst, src_list, must_have_src, file_cmd="", cmd_line=""):
|
||||
debug.extreme_verbose("Request check of dependency of :")
|
||||
debug.extreme_verbose(" dst='" + str(dst) + "'")
|
||||
compleate_list = []
|
||||
debug.extreme_verbose(" src:")
|
||||
if type(src_list) == str:
|
||||
compleate_list.append(src_list)
|
||||
debug.extreme_verbose(" '" + src_list + "'")
|
||||
elif type(src_list) == list:
|
||||
for src in src_list:
|
||||
compleate_list.append(src)
|
||||
debug.extreme_verbose(" '" + str(src) + "'")
|
||||
elif type(src_list) == dict:
|
||||
for key in src_list:
|
||||
debug.extreme_verbose(" '" + str(key) + "'")
|
||||
for src in src_list[key]:
|
||||
compleate_list.append(src)
|
||||
debug.extreme_verbose(" '" + str(src) + "'")
|
||||
|
||||
if must_have_src == False \
|
||||
and len(compleate_list) == 0:
|
||||
return False
|
||||
|
||||
# if force mode selected ==> just force rebuild ...
|
||||
if env.get_force_mode():
|
||||
debug.extreme_verbose(" ==> must re-package (force mode)")
|
||||
return True
|
||||
|
||||
# check if the destination existed:
|
||||
if os.path.exists(dst) == False:
|
||||
debug.extreme_verbose(" ==> must re-package (dst does not exist)")
|
||||
return True
|
||||
# chek the basic date if the 2 files
|
||||
if len(compleate_list) == 0:
|
||||
debug.extreme_verbose(" ==> must re-package (no source ???)")
|
||||
return True
|
||||
for src in compleate_list:
|
||||
if os.path.getmtime(src) > os.path.getmtime(dst):
|
||||
debug.extreme_verbose(" ==> must re-package (source time greater) : '" + src + "'")
|
||||
return True
|
||||
|
||||
if ""!=file_cmd:
|
||||
if False==os.path.exists(file_cmd):
|
||||
debug.extreme_verbose(" ==> must rebuild (no commandLine file)")
|
||||
return True
|
||||
# check if the 2 cmd_line are similar :
|
||||
file2 = open(file_cmd, "r")
|
||||
first_and_unique_line = file2.read()
|
||||
if first_and_unique_line != cmd_line:
|
||||
debug.extreme_verbose(" ==> must rebuild (cmd_lines are not identical)")
|
||||
debug.extreme_verbose(" ==> '" + cmd_line + "'")
|
||||
debug.extreme_verbose(" ==> '" + first_and_unique_line + "'")
|
||||
file2.close()
|
||||
return True
|
||||
# the cmdfile is correct ...
|
||||
file2.close()
|
||||
|
||||
debug.extreme_verbose(" ==> Not re-package (all dependency is OK)")
|
||||
return False
|
||||
|
||||
|
||||
|
||||
222
lutin/env.py
Normal file
222
lutin/env.py
Normal file
@ -0,0 +1,222 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
# Local import
|
||||
from realog import debug
|
||||
|
||||
|
||||
|
||||
force_mode=False
|
||||
|
||||
def set_force_mode(val):
|
||||
global force_mode
|
||||
if val==1:
|
||||
force_mode = 1
|
||||
else:
|
||||
force_mode = 0
|
||||
|
||||
def get_force_mode():
|
||||
global force_mode
|
||||
return force_mode
|
||||
|
||||
force_optimisation=False
|
||||
|
||||
def set_force_optimisation(val):
|
||||
global force_optimisation
|
||||
if val==1:
|
||||
force_optimisation = 1
|
||||
else:
|
||||
force_optimisation = 0
|
||||
|
||||
def get_force_optimisation():
|
||||
global force_optimisation
|
||||
return force_optimisation
|
||||
|
||||
isolate_system=False
|
||||
|
||||
def set_isolate_system(val):
|
||||
global isolate_system
|
||||
if val==1:
|
||||
isolate_system = 1
|
||||
else:
|
||||
isolate_system = 0
|
||||
|
||||
def get_isolate_system():
|
||||
global isolate_system
|
||||
return isolate_system
|
||||
|
||||
parse_depth = 9999999
|
||||
|
||||
def set_parse_depth(val):
|
||||
global parse_depth
|
||||
parse_depth = val
|
||||
debug.debug("Set depth search element: " + str(parse_depth))
|
||||
|
||||
def get_parse_depth():
|
||||
global parse_depth
|
||||
return parse_depth
|
||||
|
||||
exclude_search_path = []
|
||||
|
||||
def set_exclude_search_path(val):
|
||||
global exclude_search_path
|
||||
exclude_search_path = val
|
||||
debug.debug("Set depth search element: " + str(exclude_search_path))
|
||||
|
||||
def get_exclude_search_path():
|
||||
global exclude_search_path
|
||||
return exclude_search_path
|
||||
|
||||
|
||||
build_system_base_name = "lutin"
|
||||
|
||||
def set_build_system_base_name(val):
|
||||
global build_system_base_name
|
||||
build_system_base_name = val
|
||||
debug.debug("Set basename: '" + str(build_system_base_name) + "'")
|
||||
|
||||
def get_build_system_base_name():
|
||||
global build_system_base_name
|
||||
return build_system_base_name
|
||||
|
||||
|
||||
print_pretty_mode=False
|
||||
|
||||
def set_print_pretty_mode(val):
|
||||
global print_pretty_mode
|
||||
if val == True:
|
||||
print_pretty_mode = True
|
||||
else:
|
||||
print_pretty_mode = False
|
||||
|
||||
def get_print_pretty_mode():
|
||||
global print_pretty_mode
|
||||
return print_pretty_mode
|
||||
|
||||
store_warning=False
|
||||
def set_warning_mode(val):
|
||||
global store_warning
|
||||
if val == True:
|
||||
store_warning = True
|
||||
else:
|
||||
store_warning = False
|
||||
|
||||
def get_warning_mode():
|
||||
global store_warning
|
||||
return store_warning
|
||||
|
||||
ccache=False
|
||||
def set_ccache(val):
|
||||
global ccache
|
||||
if val == True:
|
||||
ccache = True
|
||||
else:
|
||||
ccache = False
|
||||
|
||||
def get_ccache():
|
||||
global ccache
|
||||
return ccache
|
||||
|
||||
def end_with(name, list):
|
||||
for appl in list:
|
||||
#debug.info("pppppppp : " + str([name[-len(appl):], appl]))
|
||||
if name[-len(appl):] == appl:
|
||||
return True
|
||||
return False
|
||||
|
||||
|
||||
def print_pretty(my_string, force=False):
|
||||
global print_pretty_mode
|
||||
if print_pretty_mode == True \
|
||||
or force == True:
|
||||
if my_string[len(my_string)-1] == ' ':
|
||||
tmpcmdLine = my_string[:len(my_string)-1]
|
||||
else:
|
||||
tmpcmdLine = my_string
|
||||
cmdApplication = tmpcmdLine.split(' ')[0]
|
||||
tmpcmdLine = tmpcmdLine.replace(' ', '\n\t')
|
||||
tmpcmdLine = tmpcmdLine.replace('\n\t\n\t', '\n\t')
|
||||
tmpcmdLine = tmpcmdLine.replace('\n\t\n\t', '\n\t')
|
||||
tmpcmdLine = tmpcmdLine.replace('\n\t\n\t', '\n\t')
|
||||
baseElementList = []
|
||||
if end_with(cmdApplication, ["javac"]) == True:
|
||||
baseElementList = [
|
||||
"-d",
|
||||
"-D",
|
||||
"-classpath",
|
||||
"-sourcepath"
|
||||
]
|
||||
elif end_with(cmdApplication, ["java"]) == True:
|
||||
baseElementList = [
|
||||
"-z",
|
||||
"-f",
|
||||
"-rf"
|
||||
]
|
||||
elif end_with(cmdApplication, ["jarsigner"]) == True:
|
||||
baseElementList = [
|
||||
"-sigalg",
|
||||
"-digestalg",
|
||||
"-storepass",
|
||||
"-keypass"
|
||||
]
|
||||
elif end_with(cmdApplication, ["jar"]) == True:
|
||||
baseElementList = [
|
||||
"cf",
|
||||
"-C"
|
||||
]
|
||||
elif end_with(cmdApplication, ["aapt"]) == True:
|
||||
baseElementList = [
|
||||
"-M",
|
||||
"-F",
|
||||
"-I",
|
||||
"-S",
|
||||
"-J"
|
||||
]
|
||||
elif end_with(cmdApplication, ["g++", "gcc", "clang", "clang++", "ar", "ld", "ranlib"]) == True:
|
||||
baseElementList = [
|
||||
"-o",
|
||||
"-D",
|
||||
"-I",
|
||||
"-L",
|
||||
"-framework",
|
||||
"-isysroot",
|
||||
"-arch",
|
||||
"-keystore",
|
||||
"-sigalg",
|
||||
"-digestalg",
|
||||
"-target",
|
||||
"-gcc-toolchain",
|
||||
"-current_version",
|
||||
"-compatibility_version"
|
||||
]
|
||||
|
||||
for element in baseElementList:
|
||||
tmpcmdLine = tmpcmdLine.replace(element+'\n\t', element+' ')
|
||||
for element in ["<", "<<", ">", ">>"]:
|
||||
tmpcmdLine = tmpcmdLine.replace(element+'\n\t', element+' ')
|
||||
tmpcmdLine = tmpcmdLine.replace('\n\t', ' \\\n\t')
|
||||
|
||||
return tmpcmdLine
|
||||
else:
|
||||
return my_string
|
||||
|
||||
force_strip_mode=False
|
||||
|
||||
def set_force_strip_mode(val):
|
||||
global force_strip_mode
|
||||
if val == True:
|
||||
force_strip_mode = True
|
||||
else:
|
||||
force_strip_mode = False
|
||||
|
||||
def get_force_strip_mode():
|
||||
global force_strip_mode
|
||||
return force_strip_mode
|
||||
|
||||
266
lutin/heritage.py
Normal file
266
lutin/heritage.py
Normal file
@ -0,0 +1,266 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
import sys
|
||||
import copy
|
||||
# Local import
|
||||
from realog import debug
|
||||
|
||||
|
||||
def append_to_list(list_out, elem):
|
||||
if type(elem) == str:
|
||||
if elem not in list_out:
|
||||
list_out.append(copy.deepcopy(elem))
|
||||
else:
|
||||
# mulyiple imput in the list ...
|
||||
for element in elem:
|
||||
if element not in list_out:
|
||||
list_out.append(copy.deepcopy(element))
|
||||
|
||||
|
||||
|
||||
class HeritageList:
|
||||
def __init__(self, heritage = None):
|
||||
self.flags = {}
|
||||
# sources list:
|
||||
self.src = { 'src':[],
|
||||
'dynamic':[],
|
||||
'static':[]
|
||||
}
|
||||
self.path = {}
|
||||
self.list_heritage = []
|
||||
if heritage != None:
|
||||
self.add_heritage(heritage)
|
||||
|
||||
def add_heritage(self, heritage):
|
||||
if type(heritage) == type(None) \
|
||||
or heritage.name == "":
|
||||
return
|
||||
for element in self.list_heritage:
|
||||
if element.name == heritage.name:
|
||||
return
|
||||
self.list_heritage.append(heritage)
|
||||
self.regenerate_tree()
|
||||
|
||||
def add_heritage_list(self, heritage_list):
|
||||
if type(heritage_list) == type(None):
|
||||
return
|
||||
for herit in heritage_list.list_heritage:
|
||||
find = False
|
||||
for element in self.list_heritage:
|
||||
if element.name == herit.name:
|
||||
find = True
|
||||
if find == False:
|
||||
self.list_heritage.append(herit)
|
||||
self.regenerate_tree()
|
||||
|
||||
def regenerate_tree(self):
|
||||
debug.verbose("Regenerate heritage list:")
|
||||
self.flags = {}
|
||||
# sources list:
|
||||
self.src = { 'src':[],
|
||||
'dynamic':[],
|
||||
'static':[]
|
||||
}
|
||||
self.path = {}
|
||||
# reorder heritage list :
|
||||
listHeritage = self.list_heritage
|
||||
self.list_heritage = []
|
||||
# first step : add all lib with no dependency:
|
||||
debug.extreme_verbose(" add element with no dependency:")
|
||||
for herit in listHeritage:
|
||||
if len(herit.depends) == 0:
|
||||
debug.extreme_verbose(" add: " + str(herit.name))
|
||||
self.list_heritage.append(copy.deepcopy(herit))
|
||||
listHeritage.remove(herit)
|
||||
debug.extreme_verbose(" add element with dependency:")
|
||||
while len(listHeritage) > 0:
|
||||
currentHeritageSize = len(listHeritage)
|
||||
debug.verbose(" list heritage = " + str([[x.name, x.depends] for x in listHeritage]))
|
||||
debug.extreme_verbose(" list heritage (rest):")
|
||||
for tmppp_herit in listHeritage:
|
||||
debug.extreme_verbose(" elem= " + str(tmppp_herit.name) + " : " + str(tmppp_herit.depends))
|
||||
# Add element only when all dependence are resolved
|
||||
for herit in listHeritage:
|
||||
listDependsName = [y.name for y in self.list_heritage]
|
||||
if all(x in listDependsName for x in herit.depends) == True:
|
||||
debug.extreme_verbose(" add: " + str(herit.name))
|
||||
listHeritage.remove(herit)
|
||||
self.list_heritage.append(copy.deepcopy(herit))
|
||||
if currentHeritageSize == len(listHeritage):
|
||||
debug.warning("Not resolve dependency between the library ==> can be a cyclic dependency !!!")
|
||||
for herit in listHeritage:
|
||||
self.list_heritage.append(copy.deepcopy(herit))
|
||||
listHeritage = []
|
||||
debug.warning("new heritage list:")
|
||||
for element in self.list_heritage:
|
||||
debug.warning(" " + element.name + " " + str(element.depends))
|
||||
debug.extreme_verbose("new heritage list:")
|
||||
for element in self.list_heritage:
|
||||
debug.extreme_verbose(" " + element.name + " " + str(element.depends))
|
||||
for element in reversed(self.list_heritage):
|
||||
for flags in element.flags:
|
||||
# get value
|
||||
value = element.flags[flags]
|
||||
# if it is a list, simply add element on the previous one
|
||||
if type(value) == list:
|
||||
if flags not in self.flags:
|
||||
self.flags[flags] = value
|
||||
else:
|
||||
append_to_list(self.flags[flags], value)
|
||||
elif type(value) == bool:
|
||||
if flags not in self.flags:
|
||||
self.flags[flags] = value
|
||||
else:
|
||||
# keep only true, if false ==> bad case ...
|
||||
if self.flags[flags] == True \
|
||||
or value == True:
|
||||
self.flags[flags] = True
|
||||
elif type(value) == int:
|
||||
# case of "c-version", "c++-version"
|
||||
if flags not in self.flags:
|
||||
self.flags[flags] = value
|
||||
else:
|
||||
# keep only true, if false ==> bad case ...
|
||||
if self.flags[flags] < value:
|
||||
self.flags[flags] = value
|
||||
append_to_list(self.src['src'], element.src['src'])
|
||||
append_to_list(self.src['dynamic'], element.src['dynamic'])
|
||||
append_to_list(self.src['static'], element.src['static'])
|
||||
for element in self.list_heritage:
|
||||
debug.extreme_verbose(" elem: " + str(element.name))
|
||||
debug.extreme_verbose(" Path (base): " + str(self.path))
|
||||
debug.extreme_verbose(" inside: " + str(element.path))
|
||||
for ppp in element.path:
|
||||
value = copy.deepcopy(element.path[ppp])
|
||||
if ppp not in self.path:
|
||||
self.path[ppp] = value
|
||||
else:
|
||||
append_to_list(self.path[ppp], value)
|
||||
debug.extreme_verbose("Path : " + str(self.path))
|
||||
for ppp in self.path:
|
||||
tmp = self.path[ppp]
|
||||
self.path[ppp] = []
|
||||
for iii in reversed(tmp):
|
||||
self.path[ppp].append(iii)
|
||||
debug.extreme_verbose("Path : " + str(self.path))
|
||||
|
||||
##
|
||||
## @brief Generate a string representing the class (for str(xxx))
|
||||
## @param[in] self (handle) Class handle
|
||||
## @return (string) string of str() convertion
|
||||
##
|
||||
def __repr__(self):
|
||||
dep = []
|
||||
for elem in reversed(self.list_heritage):
|
||||
dep.append(str(elem.name))
|
||||
return "{HeritageList: " + str(dep) + "}"
|
||||
|
||||
class heritage:
|
||||
def __init__(self, module, target):
|
||||
self.name = ""
|
||||
self.depends = []
|
||||
## Remove all variable to prevent error of multiple definition
|
||||
# all the parameter that the upper classe need when build
|
||||
self.flags = {}
|
||||
# sources list:
|
||||
self.src = { 'src':[],
|
||||
'dynamic':[],
|
||||
'static':[]
|
||||
}
|
||||
self.path = {}
|
||||
self.include = ""
|
||||
# update is set at true when data are newly created ==> force upper element to update
|
||||
self.has_been_updated=False
|
||||
|
||||
if type(module) != type(None):
|
||||
# all the parameter that the upper classe need when build
|
||||
self.name = module.get_name()
|
||||
self.depends = copy.deepcopy(module.get_depends())
|
||||
# keep reference because the flags can change in time
|
||||
self.flags = module._flags["export"] # have no deep copy here is a feature ...
|
||||
self.path = copy.deepcopy(module._path["export"])
|
||||
# if the user install some header ==> they will ba autoamaticaly exported ...
|
||||
if target != None:
|
||||
if len(module._header) > 0:
|
||||
self.include = target.get_build_path_include(module.get_name())
|
||||
|
||||
def add_depends(self, elements):
|
||||
self.depends.append(elements)
|
||||
|
||||
def add_import_path(self, list):
|
||||
append_to_list(self.path, list)
|
||||
|
||||
def add_sources(self, elements):
|
||||
if type(elements) == type(None):
|
||||
debug.error("try add element none in a list ...")
|
||||
append_to_list(self.src['src'], elements)
|
||||
|
||||
def add_lib_static(self, elements):
|
||||
if type(elements) == type(None):
|
||||
debug.error("try add element none in a list ...")
|
||||
append_to_list(self.src['static'], elements)
|
||||
|
||||
def add_lib_dynamic(self, elements):
|
||||
if type(elements) == type(None):
|
||||
debug.error("try add element none in a list ...")
|
||||
append_to_list(self.src['dynamic'], elements)
|
||||
|
||||
def add_lib_interpreted(self, type_interpretation, elements):
|
||||
# TODO : Think at a better methodologie ...
|
||||
if type(elements) == type(None):
|
||||
debug.error("try add element none in a list ...")
|
||||
append_to_list(self.src['src'], elements)
|
||||
|
||||
def auto_add_build_header(self):
|
||||
if self.include != "":
|
||||
# TODO :Set it better :
|
||||
if 'c' not in self.path:
|
||||
self.path['c'] = []
|
||||
self.path['c'].append(self.include)
|
||||
|
||||
def need_update(self, list):
|
||||
self.has_been_updated=True
|
||||
|
||||
def add_sub(self, other):
|
||||
if type(other) == type(None):
|
||||
debug.verbose("input of the heriatege class is None !!!")
|
||||
return
|
||||
if other.has_been_updated == True:
|
||||
self.has_been_updated = True
|
||||
for flags in other.flags:
|
||||
value = other.flags[flags]
|
||||
if flags not in self.flags:
|
||||
self.flags[flags] = copy.deepcopy(value)
|
||||
else:
|
||||
append_to_list(self.flags[flags], value)
|
||||
self.add_import_path(other.path)
|
||||
self.add_sources(other.src)
|
||||
if "c-version" in module.flags["export"]:
|
||||
ver = module.flags["export"]["c-version"]
|
||||
if "c-version" in self.flags:
|
||||
if self.flags["c-version"] > ver:
|
||||
ver = self.flags["c-version"]
|
||||
self.flags["c-version"] = ver
|
||||
if "c++-version" in module.flags["export"]:
|
||||
ver = module.flags["export"]["c++-version"]
|
||||
if "c++-version" in self.flags:
|
||||
if self.flags["c++-version"] > ver:
|
||||
ver = self.flags["c++-version"]
|
||||
self.flags["c++-version"] = ver
|
||||
|
||||
##
|
||||
## @brief Generate a string representing the class (for str(xxx))
|
||||
## @param[in] self (handle) Class handle
|
||||
## @return (string) string of str() convertion
|
||||
##
|
||||
def __repr__(self):
|
||||
return "{Heritage:" + str(self.name) + " depend on: " + str(reversed(self.depends)) + " ... }"
|
||||
|
||||
|
||||
37
lutin/host.py
Normal file
37
lutin/host.py
Normal file
@ -0,0 +1,37 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
import platform
|
||||
import sys
|
||||
# Local import
|
||||
from realog 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() + "'")
|
||||
|
||||
debug.debug("host.OS = " + OS)
|
||||
|
||||
|
||||
if sys.maxsize > 2**32:
|
||||
BUS_SIZE = 64
|
||||
else:
|
||||
BUS_SIZE = 32
|
||||
|
||||
debug.debug("host.BUS_SIZE = " + str(BUS_SIZE))
|
||||
|
||||
110
lutin/image.py
Normal file
110
lutin/image.py
Normal file
@ -0,0 +1,110 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
import platform
|
||||
import os
|
||||
# Local import
|
||||
from realog import debug
|
||||
from . import tools
|
||||
from . import multiprocess
|
||||
from . import depend
|
||||
|
||||
enable_resize_image = True
|
||||
try:
|
||||
if platform.system() == "Darwin":
|
||||
import CoreGraphics
|
||||
else:
|
||||
from PIL import Image
|
||||
except:
|
||||
enable_resize_image = False
|
||||
debug.warning("Missing python tools : CoreGraphics (MacOs) or PIL")
|
||||
|
||||
##
|
||||
## @brief Generate the upper pow 2 of the size in parameter
|
||||
## @param[in] size (int) Size that might heve the upper pow(2)
|
||||
## @return the new size in pow(2)
|
||||
##
|
||||
def get_pow_2_multiple(size):
|
||||
base = 2
|
||||
while size>base:
|
||||
base = base * 2
|
||||
return base
|
||||
|
||||
##
|
||||
## @brief Resize an image
|
||||
## @param[in] src_file (string) Path of the source image file
|
||||
## @param[in] dest_file (string) Path out the destination image file
|
||||
## @param[in] x (int) Width of the image
|
||||
## @param[in] y (int) Height of the image
|
||||
## @param[in] cmd_file (string) Filename of where is store the cmdline to generate the 'dst'
|
||||
##
|
||||
# TODO : 3 things to do :
|
||||
# check if force requested
|
||||
# check if time change
|
||||
# check if command line change
|
||||
def resize(src_file, dest_file, x, y, cmd_file=None):
|
||||
if os.path.exists(src_file) == False:
|
||||
debug.error("Request a resize an image that does not existed : '" + src_file + "'")
|
||||
return
|
||||
if enable_resize_image == False:
|
||||
debug.warning("Can not resize image missing pillow or CoreGraphics : '" + src_file + "' (just copy)")
|
||||
tools.copy_file(src_file, dest_file)
|
||||
return
|
||||
cmd_line = "resize Image : " + src_file + " ==> " + dest_file + " newSize=(" + str(x) + "x" + str(y) + ")"
|
||||
if depend.need_re_build(dest_file, src_file, file_cmd=cmd_file , cmd_line=cmd_line) == False:
|
||||
return
|
||||
# add cmdLine ...
|
||||
x = get_pow_2_multiple(x)
|
||||
extension = dest_file[dest_file.rfind('.'):]
|
||||
if platform.system() == "Darwin":
|
||||
source_image = CoreGraphics.CGImageImport(CoreGraphics.CGDataProviderCreateWithFilename(src_file))
|
||||
source_width = source_image.getWidth()
|
||||
source_height = source_image.getHeight()
|
||||
if source_width <= x:
|
||||
# for small image just copy:
|
||||
tools.copy_file(src_file, dest_file)
|
||||
else:
|
||||
if y <= 0:
|
||||
# keep ratio :
|
||||
y = int(float(x) * float(source_height) / float(source_width))
|
||||
y = get_pow_2_multiple(y)
|
||||
debug.print_element("resize Image (" + str(x) + "x" + str(y) + ")", src_file, "==>", dest_file)
|
||||
debug.debug("Resize image: " + src_file + " size=(" + str(source_width) + "x" + str(source_height) + ") -> (" + str(x) + "x" + str(y) + ")")
|
||||
source_image_rect = CoreGraphics.CGRectMake(0, 0, source_width, source_height)
|
||||
new_image = source_image.createWithImageInRect(source_image_rect)
|
||||
colors_space = CoreGraphics.CGColorSpaceCreateDeviceRGB()
|
||||
colors = CoreGraphics.CGFloatArray(5)
|
||||
context = CoreGraphics.CGBitmapContextCreateWithColor(x, y, colors_space, colors)
|
||||
context.setInterpolationQuality(CoreGraphics.kCGInterpolationHigh)
|
||||
new_image_rect = CoreGraphics.CGRectMake(0, 0, x, y)
|
||||
context.drawImage(new_image_rect, new_image)
|
||||
tools.create_directory_of_file(dest_file)
|
||||
if extension == ".jpeg":
|
||||
context.writeToFile(dest_file, CoreGraphics.kCGImageFormatJPEG)
|
||||
elif extension == ".png":
|
||||
context.writeToFile(dest_file, CoreGraphics.kCGImageFormatPNG)
|
||||
else:
|
||||
debug.error(" can not manage extention ... : " + dest_file)
|
||||
else:
|
||||
# open an image file (.bmp,.jpg,.png,.gif) you have in the working path
|
||||
im1 = Image.open(src_file)
|
||||
if im1.size[0] <= x:
|
||||
# for small image just copy:
|
||||
tools.copy_file(src_file, dest_file)
|
||||
else:
|
||||
if y <= 0:
|
||||
# keep ratio :
|
||||
y = int(float(x) * float(im1.size[1]) / float(im1.size[0]))
|
||||
y = get_pow_2_multiple(y)
|
||||
debug.print_element("resize Image (" + str(x) + "x" + str(y) + ")", src_file, "==>", dest_file)
|
||||
# use one of these filter options to resize the image
|
||||
tmpImage = im1.resize((x, y), Image.ANTIALIAS)
|
||||
tools.create_directory_of_file(dest_file)
|
||||
tmpImage.save(dest_file)
|
||||
tools.store_command(cmd_line, cmd_file)
|
||||
125
lutin/license.py
Normal file
125
lutin/license.py
Normal file
@ -0,0 +1,125 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
license_base = {
|
||||
"APACHE-2": {
|
||||
"generic":True,
|
||||
"contaminate-static":False,
|
||||
"contaminate-dynamic":False,
|
||||
"redistribute-source":False,
|
||||
"title":"MPL v2.0 license",
|
||||
"licence-file":"licence/apache-2.txt"
|
||||
},
|
||||
"GPL-2": {
|
||||
"generic":True,
|
||||
"contaminate-static":True,
|
||||
"contaminate-dynamic":True,
|
||||
"redistribute-source":True,
|
||||
"title":"GPL: Gnu Public Licence v2.0",
|
||||
"licence-file":"licence/GPL-2.txt"
|
||||
},
|
||||
"GPL-3": {
|
||||
"generic":True,
|
||||
"contaminate-static":True,
|
||||
"contaminate-dynamic":True,
|
||||
"redistribute-source":True,
|
||||
"title":"GPL: GNU General Public License v3.0",
|
||||
"licence-file":"licence/GPL-3.txt"
|
||||
},
|
||||
"LGPL-2": {
|
||||
"generic":True,
|
||||
"contaminate-static":False,
|
||||
"contaminate-dynamic":False,
|
||||
"redistribute-source":True,
|
||||
"title":"LGPL: GNU Lesser General Public License v2.0",
|
||||
"licence-file":"licence/LGPL-2.txt"
|
||||
},
|
||||
"LGPL-3": {
|
||||
"generic":True,
|
||||
"contaminate-static":True,
|
||||
"contaminate-dynamic":False,
|
||||
"redistribute-source":True,
|
||||
"title":"LGPL: GNU Lesser General Public License v3.0",
|
||||
"licence-file":"licence/LGPL-3.txt"
|
||||
},
|
||||
"MIT": {
|
||||
"generic":True,
|
||||
"contaminate-static":False,
|
||||
"contaminate-dynamic":False,
|
||||
"redistribute-source":False,
|
||||
"title":"MIT: Massachusetts Institute of Technology License",
|
||||
"licence-file":"licence/MIT.txt"
|
||||
},
|
||||
"BSD-2": {
|
||||
"generic":True,
|
||||
"contaminate-static":False,
|
||||
"contaminate-dynamic":False,
|
||||
"redistribute-source":False,
|
||||
"title":"BSD 2-clauses: Berkeley Software Distribution License",
|
||||
"licence-file":"licence/BSD-2.txt"
|
||||
},
|
||||
"BSD-3": {
|
||||
"generic":True,
|
||||
"contaminate-static":False,
|
||||
"contaminate-dynamic":False,
|
||||
"redistribute-source":False,
|
||||
"title":"BSD 3-clauses: Berkeley Software Distribution License",
|
||||
"licence-file":"licence/BSD-3.txt"
|
||||
},
|
||||
"BSD-4": {
|
||||
"generic":True,
|
||||
"contaminate-static":False,
|
||||
"contaminate-dynamic":False,
|
||||
"redistribute-source":False,
|
||||
"title":"BSD 4-clauses: Berkeley Software Distribution License",
|
||||
"licence-file":"licence/BSD-4.txt"
|
||||
},
|
||||
"PNG": {
|
||||
"generic":True,
|
||||
"contaminate-static":False,
|
||||
"contaminate-dynamic":False,
|
||||
"redistribute-source":False,
|
||||
"title":"PNG License",
|
||||
"licence-file":"licence/png.txt"
|
||||
},
|
||||
"MPL-1": {
|
||||
"generic":True,
|
||||
"contaminate-static":False,
|
||||
"contaminate-dynamic":False,
|
||||
"redistribute-source":True,
|
||||
"title":"MPL: Mozilla Public Licence v1.0",
|
||||
"licence-file":"licence/MPL-1.txt"
|
||||
},
|
||||
"MPL-1.1": {
|
||||
"generic":True,
|
||||
"contaminate-static":False,
|
||||
"contaminate-dynamic":False,
|
||||
"redistribute-source":True,
|
||||
"title":"MPL: Mozilla Public Licence v1.1",
|
||||
"licence-file":"licence/MPL-1.1.txt"
|
||||
},
|
||||
"MPL-2": {
|
||||
"generic":True,
|
||||
"contaminate-static":False,
|
||||
"contaminate-dynamic":False,
|
||||
"redistribute-source":True,
|
||||
"title":"MPL: Mozilla Public Licence v2.0",
|
||||
"licence-file":"licence/MPL-2.txt"
|
||||
},
|
||||
}
|
||||
|
||||
def get_basic_list():
|
||||
global license_base
|
||||
out = []
|
||||
for name in license_base:
|
||||
out.append(name)
|
||||
return out
|
||||
|
||||
|
||||
76
lutin/macro.py
Normal file
76
lutin/macro.py
Normal file
@ -0,0 +1,76 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
import sys
|
||||
import os
|
||||
import inspect
|
||||
import fnmatch
|
||||
import datetime
|
||||
# Local import
|
||||
from realog import debug
|
||||
from . import tools
|
||||
from . import env
|
||||
|
||||
|
||||
__macro_list=[]
|
||||
__start_macro_name="Macro_"
|
||||
|
||||
##
|
||||
## @brief Import all File that start with env.get_build_system_base_name() + __start_macro_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 __macro_list
|
||||
global_base = env.get_build_system_base_name()
|
||||
debug.debug("TARGET: Init with Files list:")
|
||||
for elem in path_list:
|
||||
sys.path.append(os.path.dirname(elem))
|
||||
# Get file name:
|
||||
filename = os.path.basename(elem)
|
||||
# Remove .py at the end:
|
||||
filename = filename[:-3]
|
||||
# Remove global base name:
|
||||
filename = filename[len(global_base):]
|
||||
# Check if it start with the local patern:
|
||||
if filename[:len(__start_macro_name)] != __start_macro_name:
|
||||
debug.extreme_verbose("MACRO: NOT-Integrate: '" + filename + "' from '" + elem + "' ==> rejected")
|
||||
continue
|
||||
# Remove local patern
|
||||
target_name = filename[len(__start_macro_name):]
|
||||
debug.verbose("MACRO: Integrate: '" + target_name + "' from '" + elem + "'")
|
||||
__macro_list.append([target_name, elem])
|
||||
debug.verbose("New list MACRO: ")
|
||||
for elem in __macro_list:
|
||||
debug.verbose(" " + str(elem[0]))
|
||||
|
||||
##
|
||||
## @brief Load a specific target
|
||||
##
|
||||
def load_macro(name):
|
||||
global __macro_list
|
||||
debug.debug("load macro: " + name)
|
||||
if len(__macro_list) == 0:
|
||||
debug.error("No macro to compile !!!")
|
||||
debug.debug("list macro: " + str(__macro_list))
|
||||
for mod in __macro_list:
|
||||
if mod[0] == name:
|
||||
debug.verbose("add to path: '" + os.path.dirname(mod[1]) + "'")
|
||||
sys.path.append(os.path.dirname(mod[1]))
|
||||
debug.verbose("import macro : '" + env.get_build_system_base_name() + __start_macro_name + name + "'")
|
||||
the_macro = __import__(env.get_build_system_base_name() + __start_macro_name + name)
|
||||
return the_macro
|
||||
raise KeyError("No entry for : " + name)
|
||||
|
||||
def list_all_macro():
|
||||
global __macro_list
|
||||
tmp_list_name = []
|
||||
for mod in __macro_list:
|
||||
tmp_list_name.append(mod[0])
|
||||
return tmp_list_name
|
||||
1889
lutin/module.py
Normal file
1889
lutin/module.py
Normal file
File diff suppressed because it is too large
Load Diff
308
lutin/multiprocess.py
Normal file
308
lutin/multiprocess.py
Normal file
@ -0,0 +1,308 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
import sys
|
||||
import threading
|
||||
import time
|
||||
import sys
|
||||
if sys.version_info >= (3, 0):
|
||||
import queue
|
||||
else:
|
||||
import Queue as queue
|
||||
import os
|
||||
import subprocess
|
||||
import shlex
|
||||
# Local import
|
||||
from realog import debug
|
||||
from . import tools
|
||||
from . import env
|
||||
from . import depend
|
||||
|
||||
queue_lock = threading.Lock()
|
||||
work_queue = queue.Queue()
|
||||
current_thread_working = 0
|
||||
threads = []
|
||||
# To know the first error arrive in the pool ==> to display all the time the same error file when multiple compilation
|
||||
current_id_execution = 0
|
||||
error_execution = {
|
||||
"id":-1,
|
||||
"cmd":"",
|
||||
"return":0,
|
||||
"err":"",
|
||||
"out":"",
|
||||
}
|
||||
|
||||
exit_flag = False # resuest stop of the thread
|
||||
is_init = False # the thread are initialized
|
||||
error_occured = False # a thread have an error
|
||||
processor_availlable = 1 # number of CPU core availlable
|
||||
##
|
||||
## @brief Execute the command with no get of output
|
||||
##
|
||||
def run_command_no_lock_out(cmd_line):
|
||||
# prepare command line:
|
||||
args = shlex.split(cmd_line)
|
||||
debug.info("cmd = " + str(args))
|
||||
try:
|
||||
# create the subprocess
|
||||
p = subprocess.Popen(args)
|
||||
except subprocess.CalledProcessError as e:
|
||||
debug.error("subprocess.CalledProcessError : " + str(args))
|
||||
return
|
||||
#except:
|
||||
# debug.error("Exception on : " + str(args))
|
||||
# launch the subprocess:
|
||||
p.communicate()
|
||||
|
||||
##
|
||||
## @brief Execute the command and ruturn generate data
|
||||
##
|
||||
def run_command_direct(cmd_line):
|
||||
# prepare command line:
|
||||
args = shlex.split(cmd_line)
|
||||
debug.verbose("cmd = " + str(args))
|
||||
try:
|
||||
# create the subprocess
|
||||
p = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
||||
except subprocess.CalledProcessError as e:
|
||||
debug.error("subprocess.CalledProcessError : " + str(args))
|
||||
except:
|
||||
debug.error("Exception on : " + str(args))
|
||||
# launch the subprocess:
|
||||
output, err = p.communicate()
|
||||
if sys.version_info >= (3, 0):
|
||||
output = output.decode("utf-8")
|
||||
err = err.decode("utf-8")
|
||||
# Check error :
|
||||
if p.returncode == 0:
|
||||
if output == None:
|
||||
return err[:-1];
|
||||
return output[:-1];
|
||||
else:
|
||||
debug.warning("get an error cmd " + str(err))
|
||||
return False
|
||||
|
||||
|
||||
def run_command(cmd_line, store_cmd_line="", build_id=-1, file="", store_output_file="", depend_data=None):
|
||||
global error_occured
|
||||
global exit_flag
|
||||
global current_id_execution
|
||||
global error_execution
|
||||
# prepare command line:
|
||||
args = shlex.split(cmd_line)
|
||||
debug.verbose("cmd = " + str(args))
|
||||
try:
|
||||
# create the subprocess
|
||||
p = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
||||
except subprocess.CalledProcessError as e:
|
||||
debug.error("subprocess.CalledProcessError : TODO ...")
|
||||
except:
|
||||
debug.error("Exception on : " + str(args))
|
||||
# launch the subprocess:
|
||||
output, err = p.communicate()
|
||||
if sys.version_info >= (3, 0):
|
||||
output = output.decode("utf-8")
|
||||
err = err.decode("utf-8")
|
||||
# store error if needed:
|
||||
tools.store_warning(store_output_file, output, err)
|
||||
# Check error :
|
||||
if p.returncode == 0:
|
||||
debug.debug(env.print_pretty(cmd_line))
|
||||
queue_lock.acquire()
|
||||
if depend_data != None:
|
||||
depend.create_dependency_file(depend_data['file'], depend_data['data'])
|
||||
# TODO : Print the output all the time .... ==> to show warnings ...
|
||||
if build_id >= 0 and (output != "" or err != ""):
|
||||
debug.warning("output in subprocess compiling: '" + file + "'")
|
||||
if output != "":
|
||||
debug.print_compilator(output)
|
||||
if err != "":
|
||||
debug.print_compilator(err)
|
||||
queue_lock.release()
|
||||
else:
|
||||
error_occured = True
|
||||
exit_flag = True
|
||||
# if No ID : Not in a multiprocess mode ==> just stop here
|
||||
if build_id < 0:
|
||||
debug.debug(env.print_pretty(cmd_line), force=True)
|
||||
debug.print_compilator(output)
|
||||
debug.print_compilator(err)
|
||||
if p.returncode == 2:
|
||||
debug.error("can not compile file ... [keyboard interrrupt]")
|
||||
else:
|
||||
debug.error("can not compile file ... ret : " + str(p.returncode))
|
||||
else:
|
||||
# in multiprocess interface
|
||||
queue_lock.acquire()
|
||||
# if an other write an error before, check if the current process is started before ==> then is the first error
|
||||
if error_execution["id"] >= build_id:
|
||||
# nothing to do ...
|
||||
queue_lock.release()
|
||||
return;
|
||||
error_execution["id"] = build_id
|
||||
error_execution["cmd"] = cmd_line
|
||||
error_execution["return"] = p.returncode
|
||||
error_execution["err"] = err,
|
||||
error_execution["out"] = output,
|
||||
queue_lock.release()
|
||||
# not write the command file...
|
||||
return
|
||||
debug.verbose("done 3")
|
||||
# write cmd line only after to prevent errors ...
|
||||
tools.store_command(cmd_line, store_cmd_line)
|
||||
|
||||
|
||||
|
||||
class myThread(threading.Thread):
|
||||
def __init__(self, thread_id, lock, queue):
|
||||
threading.Thread.__init__(self)
|
||||
self.thread_id = thread_id
|
||||
self.name = "Thread " + str(thread_id)
|
||||
self.queue = queue
|
||||
self.lock = lock
|
||||
def run(self):
|
||||
debug.verbose("Starting " + self.name)
|
||||
global exit_flag
|
||||
global current_thread_working
|
||||
working_set = False
|
||||
while exit_flag == False:
|
||||
self.lock.acquire()
|
||||
if not self.queue.empty():
|
||||
if working_set == False:
|
||||
current_thread_working += 1
|
||||
working_set = True
|
||||
data = self.queue.get()
|
||||
self.lock.release()
|
||||
debug.verbose(self.name + " processing '" + data[0] + "'")
|
||||
if data[0]=="cmd_line":
|
||||
comment = data[2]
|
||||
cmd_line = data[1]
|
||||
cmd_store_file = data[3]
|
||||
debug.print_element("[" + str(data[4]) + "][" + str(self.thread_id) + "] " + comment[0],
|
||||
comment[1],
|
||||
comment[2],
|
||||
comment[3])
|
||||
run_command(cmd_line,
|
||||
cmd_store_file,
|
||||
build_id=data[4],
|
||||
file=comment[3],
|
||||
store_output_file=data[5],
|
||||
depend_data=data[6])
|
||||
else:
|
||||
debug.warning("unknow request command : " + data[0])
|
||||
else:
|
||||
if working_set==True:
|
||||
current_thread_working -= 1
|
||||
working_set=False
|
||||
# no element to parse, just wait ...
|
||||
self.lock.release()
|
||||
time.sleep(0.2)
|
||||
# kill requested ...
|
||||
debug.verbose("Exiting " + self.name)
|
||||
|
||||
|
||||
def set_error_occured():
|
||||
global exit_flag
|
||||
exit_flag = True
|
||||
|
||||
# set the debug system call us to stop threading
|
||||
debug.set_callback_error(set_error_occured)
|
||||
|
||||
|
||||
def set_core_number(number_of_core):
|
||||
global processor_availlable
|
||||
processor_availlable = number_of_core
|
||||
debug.debug(" set number of core for multi process compilation : " + str(processor_availlable))
|
||||
# nothing else to do
|
||||
|
||||
def init():
|
||||
global error_occured
|
||||
global exit_flag
|
||||
global is_init
|
||||
if is_init == False:
|
||||
is_init = True
|
||||
error_occured = False
|
||||
global threads
|
||||
global queue_lock
|
||||
global work_queue
|
||||
# Create all the new threads
|
||||
thread_id = 0
|
||||
while thread_id < processor_availlable:
|
||||
thread = myThread(thread_id, queue_lock, work_queue)
|
||||
thread.start()
|
||||
threads.append(thread)
|
||||
thread_id += 1
|
||||
|
||||
|
||||
|
||||
def un_init():
|
||||
global exit_flag
|
||||
# Notify threads it's time to exit
|
||||
exit_flag = True
|
||||
if processor_availlable > 1:
|
||||
# Wait for all threads to complete
|
||||
for tmp in threads:
|
||||
debug.verbose("join thread ...")
|
||||
tmp.join()
|
||||
debug.verbose("Exiting ALL Threads")
|
||||
|
||||
|
||||
|
||||
def run_in_pool(cmd_line, comment, store_cmd_line="", store_output_file="", depend_data=None):
|
||||
global current_id_execution
|
||||
if processor_availlable <= 1:
|
||||
debug.print_element(comment[0], comment[1], comment[2], comment[3])
|
||||
run_command(cmd_line, store_cmd_line, file=comment[3], store_output_file=store_output_file, depend_data=depend_data)
|
||||
return
|
||||
# multithreaded mode
|
||||
init()
|
||||
# Fill the queue
|
||||
queue_lock.acquire()
|
||||
debug.verbose("add : in pool cmd_line")
|
||||
work_queue.put(["cmd_line", cmd_line, comment, store_cmd_line, current_id_execution, store_output_file, depend_data])
|
||||
current_id_execution +=1;
|
||||
queue_lock.release()
|
||||
|
||||
|
||||
def pool_synchrosize():
|
||||
global error_occured
|
||||
global error_execution
|
||||
if processor_availlable <= 1:
|
||||
#in this case : nothing to synchronise
|
||||
return
|
||||
|
||||
debug.verbose("wait queue process ended\n")
|
||||
# Wait for queue to empty
|
||||
while not work_queue.empty() \
|
||||
and error_occured == False:
|
||||
time.sleep(0.2)
|
||||
pass
|
||||
# Wait all thread have ended their current process
|
||||
while current_thread_working != 0 \
|
||||
and error_occured == False:
|
||||
time.sleep(0.2)
|
||||
pass
|
||||
if error_occured == False:
|
||||
debug.verbose("queue is empty")
|
||||
else:
|
||||
un_init()
|
||||
debug.debug("Thread return with error ... ==> stop all the pool")
|
||||
if error_execution["id"] == -1:
|
||||
debug.error("Pool error occured ... (No return information on Pool)")
|
||||
return
|
||||
debug.error("Error in an pool element : [" + str(error_execution["id"]) + "]", crash=False)
|
||||
debug.debug(env.print_pretty(error_execution["cmd"]), force=True)
|
||||
debug.print_compilator(str(error_execution["out"][0]))
|
||||
debug.print_compilator(str(error_execution["err"][0]))
|
||||
if error_execution["return"] == 2:
|
||||
debug.error("can not compile file ... [keyboard interrrupt]")
|
||||
else:
|
||||
debug.error("can not compile file ... return value : " + str(error_execution["return"]))
|
||||
|
||||
324
lutin/system.py
Normal file
324
lutin/system.py
Normal file
@ -0,0 +1,324 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
import sys
|
||||
import os
|
||||
import inspect
|
||||
import fnmatch
|
||||
import datetime
|
||||
# Local import
|
||||
from realog import debug
|
||||
from . import module
|
||||
from . import tools
|
||||
from . import env
|
||||
##
|
||||
## @brief System class represent the pre-build Module that are already install and accessible in the system environment
|
||||
##
|
||||
class System:
|
||||
##
|
||||
## @brief Constructor
|
||||
## @param[in] self (handle) Class handle
|
||||
## @return None
|
||||
##
|
||||
def __init__(self):
|
||||
self._valid=False;
|
||||
self._help="";
|
||||
self._export_depends=[]
|
||||
self._export_flags={}
|
||||
self._export_src=[]
|
||||
self._export_path=[]
|
||||
self._action_on_state={}
|
||||
self._headers=[]
|
||||
self._version=None
|
||||
|
||||
##
|
||||
## @brief Set the help of this system Module
|
||||
## @param[in] self (handle) Class handle
|
||||
## @param[in] help (string) Help for the user
|
||||
## @return None
|
||||
##
|
||||
def set_help(self, help):
|
||||
self._help = help;
|
||||
|
||||
##
|
||||
## @brief Get the help of this system Module
|
||||
## @param[in] self (handle) Class handle
|
||||
## @return (string) Help for the user
|
||||
##
|
||||
def get_help(self):
|
||||
return self._help;
|
||||
|
||||
##
|
||||
## @brief Set validity state of the system Module
|
||||
## @param[in] self (handle) Class handle
|
||||
## @param[in] state (bool) New valididty state of the system module
|
||||
## @return None
|
||||
##
|
||||
def set_valid(self, state):
|
||||
self._valid = state
|
||||
|
||||
##
|
||||
## @brief Get validity state of the system Module
|
||||
## @param[in] self (handle) Class handle
|
||||
## @return (bool) New valididty state of the system module
|
||||
##
|
||||
def get_valid(self):
|
||||
return self._valid
|
||||
|
||||
##
|
||||
## @brief Add source element
|
||||
## @param[in] self (handle) Class handle
|
||||
## @param[in] list ([string,...]) List of all Files to add. ex: *.a, *.so ...
|
||||
## @return None
|
||||
##
|
||||
def add_sources(self, list):
|
||||
tools.list_append_to(self._export_src, list)
|
||||
|
||||
##
|
||||
## @brief Add include path of the sources
|
||||
## @param[in] self (handle) Class handle
|
||||
## @param[in] list ([string,...]) List of all path to add in the -I include element
|
||||
## @return None
|
||||
##
|
||||
# todo : add other than C ...
|
||||
def add_path(self, list):
|
||||
tools.list_append_to(self._export_path, list)
|
||||
|
||||
##
|
||||
## @brief Add a dependency on this module
|
||||
## @param[in] self (handle) Class handle
|
||||
## @param[in] list ([string,...] or string) Name(s) of the modules dependency
|
||||
## @return None
|
||||
##
|
||||
def add_depend(self, list):
|
||||
tools.list_append_to(self._export_depends, list, True)
|
||||
|
||||
##
|
||||
## @brief Add compilation flags
|
||||
## @param[in] self (handle) Class handle
|
||||
## @param[in] type (string) inclusion group name 'c', 'c++', 'java' ...
|
||||
## @param[in] list ([string,...] or string) List of path to include
|
||||
## @return None
|
||||
##
|
||||
def add_flag(self, type, list):
|
||||
tools.list_append_to_2(self._export_flags, type, list)
|
||||
|
||||
##
|
||||
## @brief Set version of the module
|
||||
## @param[in] self (handle) Class handle
|
||||
## @param[in] version_list ([int,...]) Ids of the version. ex: [1,2,5] or [0,8,"dev"]
|
||||
## @return None
|
||||
##
|
||||
def set_version(self, version_list):
|
||||
self._version = version_list
|
||||
|
||||
## @copydoc lutin.module.Target.add_action
|
||||
def add_action(self, name_of_state="PACKAGE", level=5, name="no-name", action=None):
|
||||
if name_of_state not in self._action_on_state:
|
||||
self._action_on_state[name_of_state] = [[level, name, action]]
|
||||
else:
|
||||
self._action_on_state[name_of_state].append([level, name, action])
|
||||
|
||||
## @copydoc lutin.module.Module.add_header_file
|
||||
def add_header_file(self, list, destination_path=None, clip_path=None, recursive=False):
|
||||
self._headers.append({
|
||||
"list":list,
|
||||
"dst":destination_path,
|
||||
"clip":clip_path,
|
||||
"recursive":recursive
|
||||
})
|
||||
##
|
||||
## @brief Generate a string representing the class (for str(xxx))
|
||||
## @param[in] self (handle) Class handle
|
||||
## @return (string) string of str() convertion
|
||||
##
|
||||
def __repr__(self):
|
||||
return "{lutin.System}"
|
||||
|
||||
##
|
||||
## @brief Configure a module with internal datas
|
||||
## @param[in] self (handle) Class handle
|
||||
## @param[in] target (handle) @ref lutin.module.Target handle
|
||||
## @param[in] module (handle) @ref lutin.module.Module handle
|
||||
## @return None
|
||||
##
|
||||
def configure_module(self, target, module):
|
||||
# add element flags to export
|
||||
for elem in self._export_flags:
|
||||
debug.verbose("add element :" + str(elem) + " elems=" + str(self._export_flags[elem]))
|
||||
module.add_flag(elem, self._export_flags[elem], export=True)
|
||||
# add module dependency
|
||||
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={}
|
||||
__start_system_name="System_"
|
||||
|
||||
##
|
||||
## @brief Import all File that start with env.get_build_system_base_name() + __start_system_name + XXX and register in the list of System
|
||||
## @param[in] path_list ([string,...]) List of file that start with env.get_build_system_base_name() in the running worktree (Parse one time ==> faster)
|
||||
##
|
||||
def import_path(path_list):
|
||||
global __system_list
|
||||
global_base = env.get_build_system_base_name()
|
||||
debug.debug("SYSTEM: Init with Files list:")
|
||||
for elem in path_list:
|
||||
sys.path.append(os.path.dirname(elem))
|
||||
# Get file name:
|
||||
filename = os.path.basename(elem)
|
||||
# Remove .py at the end:
|
||||
filename = filename[:-3]
|
||||
# Remove global base name:
|
||||
filename = filename[len(global_base):]
|
||||
# Check if it start with the local patern:
|
||||
if filename[:len(__start_system_name)] != __start_system_name:
|
||||
debug.extreme_verbose("SYSTEM: NOT-Integrate: '" + filename + "' from '" + elem + "' ==> rejected")
|
||||
continue
|
||||
# Remove local patern
|
||||
system_name = filename[len(__start_system_name):]
|
||||
system_type, system_name = system_name.split('_')
|
||||
debug.verbose("SYSTEM: Integrate: '" + system_type + "':'" + system_name + "' from '" + elem + "'")
|
||||
if system_type in __system_list:
|
||||
__system_list[system_type].append({"name":system_name,
|
||||
"path":elem,
|
||||
"system":None,
|
||||
"loaded":False,
|
||||
"exist":False,
|
||||
"module":None})
|
||||
else:
|
||||
__system_list[system_type] = [{"name":system_name,
|
||||
"path":elem,
|
||||
"system":None,
|
||||
"loaded":False,
|
||||
"exist":False,
|
||||
"module":None}]
|
||||
debug.verbose("New list system: ")
|
||||
for elem in __system_list:
|
||||
debug.verbose(" " + str(elem))
|
||||
for val in __system_list[elem]:
|
||||
debug.verbose(" " + str(val["name"]))
|
||||
|
||||
##
|
||||
## @brief Display all the system binary that can be used
|
||||
##
|
||||
def display():
|
||||
global __system_list
|
||||
for elementName in __system_list:
|
||||
debug.info("SYSTEM: Integrate system: '" + elementName +"'")
|
||||
for data in __system_list[elementName]:
|
||||
debug.info("SYSTEM: '" + data["name"] +"' in " + data["path"])
|
||||
|
||||
##
|
||||
## @brief Check if a system Module is availlable for a specific target
|
||||
## @param[in] lib_name (string) Name of the Library
|
||||
## @param[in] 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 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()
|
||||
"""
|
||||
if data["exist"] == False:
|
||||
debug.warning("Can not Import: '" + data["name"] + "' ==> disabled")
|
||||
"""
|
||||
else:
|
||||
debug.warning("Not find: '" + data["name"] + "' ==> get exception")
|
||||
return data["exist"]
|
||||
return False
|
||||
|
||||
##
|
||||
## @brief Load a system Module for a specific target
|
||||
## @param[in] target (handle) Handle on the @ref Target build engine
|
||||
## @param[in] lib_name (string) Name of the Library
|
||||
## @param[in] 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!")
|
||||
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
|
||||
|
||||
1222
lutin/target.py
Normal file
1222
lutin/target.py
Normal file
File diff suppressed because it is too large
Load Diff
496
lutin/tools.py
Normal file
496
lutin/tools.py
Normal file
@ -0,0 +1,496 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
import os
|
||||
import shutil
|
||||
import errno
|
||||
import fnmatch
|
||||
import stat
|
||||
# Local import
|
||||
from realog import debug
|
||||
from . import depend
|
||||
from . import env
|
||||
|
||||
"""
|
||||
|
||||
"""
|
||||
def get_run_path():
|
||||
return os.getcwd()
|
||||
|
||||
"""
|
||||
|
||||
"""
|
||||
def get_current_path(file):
|
||||
return os.path.dirname(os.path.realpath(file))
|
||||
|
||||
def create_directory_of_file(file):
|
||||
path = os.path.dirname(file)
|
||||
try:
|
||||
os.stat(path)
|
||||
except:
|
||||
os.makedirs(path)
|
||||
|
||||
def get_list_sub_path(path):
|
||||
# TODO : os.listdir(path)
|
||||
for dirname, dirnames, filenames in os.walk(path):
|
||||
return dirnames
|
||||
return []
|
||||
|
||||
def remove_path_and_sub_path(path):
|
||||
if os.path.isdir(path):
|
||||
debug.verbose("remove path : '" + path + "'")
|
||||
shutil.rmtree(path)
|
||||
|
||||
def remove_file(path):
|
||||
if os.path.isfile(path):
|
||||
os.remove(path)
|
||||
elif os.path.islink(path):
|
||||
os.remove(path)
|
||||
|
||||
def file_size(path):
|
||||
if not os.path.isfile(path):
|
||||
return 0
|
||||
statinfo = os.stat(path)
|
||||
return statinfo.st_size
|
||||
|
||||
def file_read_data(path, binary=False):
|
||||
debug.verbose("path= " + path)
|
||||
if not os.path.isfile(path):
|
||||
return ""
|
||||
if binary == True:
|
||||
file = open(path, "rb")
|
||||
else:
|
||||
file = open(path, "r")
|
||||
data_file = file.read()
|
||||
file.close()
|
||||
return data_file
|
||||
|
||||
def version_to_string(version):
|
||||
version_ID = ""
|
||||
for id in version:
|
||||
if len(version_ID) != 0:
|
||||
if type(id) == str:
|
||||
version_ID += "-"
|
||||
else:
|
||||
version_ID += "."
|
||||
version_ID += str(id)
|
||||
return version_ID
|
||||
|
||||
##
|
||||
## @brief Write data in a specific path.
|
||||
## @param[in] path Path of the data might be written.
|
||||
## @param[in] data Data To write in the file.
|
||||
## @param[in] only_if_new (default: False) Write data only if data is different.
|
||||
## @return True Something has been copied
|
||||
## @return False Nothing has been copied
|
||||
##
|
||||
def file_write_data(path, data, only_if_new=False):
|
||||
if only_if_new == True:
|
||||
if os.path.exists(path) == True:
|
||||
old_data = file_read_data(path)
|
||||
if old_data == data:
|
||||
return False
|
||||
#real write of data:
|
||||
create_directory_of_file(path)
|
||||
file = open(path, "w")
|
||||
file.write(data)
|
||||
file.close()
|
||||
return True
|
||||
|
||||
def list_to_str(list):
|
||||
if type(list) == type(str()):
|
||||
return list + " "
|
||||
else:
|
||||
result = ""
|
||||
# mulyiple imput in the list ...
|
||||
for elem in list:
|
||||
result += list_to_str(elem)
|
||||
return result
|
||||
|
||||
def add_prefix(prefix,list):
|
||||
if type(list) == type(None):
|
||||
return ""
|
||||
if type(list) == type(str()):
|
||||
return prefix+list
|
||||
else:
|
||||
if len(list)==0:
|
||||
return ''
|
||||
else:
|
||||
result=[]
|
||||
for elem in list:
|
||||
result.append(prefix+elem)
|
||||
return result
|
||||
|
||||
##
|
||||
## @brief Copy a specific file in a specific directory
|
||||
## @param[in] src Input file path
|
||||
## @param[in] dst Output file path
|
||||
## @param[in] cmd_file (default None) Path of file to store the command line used
|
||||
## @param[in] force (default False) Force copy of the file
|
||||
## @param[in] force_identical (default False) Force file to be identical (read it in binary)
|
||||
## @param[in,out] in_list (default None) Not real copy: set the request copy in the input list
|
||||
## @return True Something has/must been copied
|
||||
## @return False Nothing has/myst been copied
|
||||
##
|
||||
def copy_file(src, dst, cmd_file=None, force=False, force_identical=False, in_list=None):
|
||||
if os.path.exists(src) == False:
|
||||
debug.error("Request a copy a file that does not existed : '" + src + "'")
|
||||
cmd_line = "copy \"" + src + "\" \"" + dst + "\""
|
||||
if force == False \
|
||||
and depend.need_re_build(dst, src, file_cmd=cmd_file , cmd_line=cmd_line, force_identical=force_identical) == False:
|
||||
debug.verbose("no need to copy ...")
|
||||
if in_list != None:
|
||||
if dst in in_list:
|
||||
debug.verbose("replace copy file " + os.path.relpath(src) + " ==> " + os.path.relpath(dst))
|
||||
else:
|
||||
debug.verbose("append copy file " + os.path.relpath(src) + " ==> " + os.path.relpath(dst))
|
||||
# update element in dictionnary:
|
||||
in_list[dst] = {"src":src,
|
||||
"cmd_file":cmd_file,
|
||||
"need_copy":False}
|
||||
return False
|
||||
if in_list == None:
|
||||
debug.print_element("copy file ", os.path.relpath(src), "==>", os.path.relpath(dst))
|
||||
create_directory_of_file(dst)
|
||||
shutil.copyfile(src, dst)
|
||||
# copy property of the permition of the file ...
|
||||
stat_info = os.stat(src)
|
||||
os.chmod(dst, stat_info.st_mode)
|
||||
store_command(cmd_line, cmd_file)
|
||||
else:
|
||||
debug.verbose("append copy file " + os.path.relpath(src) + " ==> " + os.path.relpath(dst))
|
||||
# update element in dictionnary:
|
||||
in_list[dst] = {"src":src,
|
||||
"cmd_file":cmd_file,
|
||||
"need_copy":True}
|
||||
return True
|
||||
|
||||
##
|
||||
## @brief Get list of all Files in a specific path (with a regex)
|
||||
## @param[in] path (string) Full path of the machine to search files (start with / or x:)
|
||||
## @param[in] regex (string) Regular expression to search data
|
||||
## @param[in] recursive (bool) List file with recursive search
|
||||
## @param[in] remove_path (string) Data to remove in the path
|
||||
## @return (list) return files requested
|
||||
##
|
||||
def get_list_of_file_in_path(path, regex="*", recursive = False, remove_path=""):
|
||||
out = []
|
||||
debug.verbose(" List all in : '" + str(path) + "'")
|
||||
if os.path.isdir(os.path.realpath(path)):
|
||||
tmp_path = os.path.realpath(path)
|
||||
tmp_rule = regex
|
||||
else:
|
||||
debug.error("path does not exist : '" + str(path) + "'")
|
||||
|
||||
debug.verbose(" " + str(tmp_path) + ":")
|
||||
for root, dirnames, filenames in os.walk(tmp_path):
|
||||
deltaRoot = root[len(tmp_path):]
|
||||
while len(deltaRoot) > 0 \
|
||||
and ( deltaRoot[0] == '/' \
|
||||
or deltaRoot[0] == '\\' ):
|
||||
deltaRoot = deltaRoot[1:]
|
||||
if recursive == False \
|
||||
and deltaRoot != "":
|
||||
return out
|
||||
debug.verbose(" root='" + str(deltaRoot) + "'")
|
||||
debug.extreme_verbose(" files=" + str(filenames))
|
||||
tmpList = filenames
|
||||
if len(tmp_rule) > 0:
|
||||
tmpList = fnmatch.filter(filenames, tmp_rule)
|
||||
# Import the module :
|
||||
for cycleFile in tmpList:
|
||||
#for cycleFile in filenames:
|
||||
add_file = os.path.join(tmp_path, deltaRoot, cycleFile)
|
||||
if len(remove_path) != 0:
|
||||
if add_file[:len(remove_path)] != remove_path:
|
||||
debug.error("Request remove start of a path that is not the same: '" + add_file[:len(remove_path)] + "' demand remove of '" + str(remove_path) + "'")
|
||||
else:
|
||||
add_file = add_file[len(remove_path)+1:]
|
||||
debug.verbose(" '" + add_file + "'")
|
||||
out.append(add_file)
|
||||
return out;
|
||||
|
||||
##
|
||||
## @brief Copy a compleate directory in a specific folder
|
||||
## @param[in] src Input folder path
|
||||
## @param[in] dst Output folder path
|
||||
## @param[in] recursive (default False) Copy folder with all his dependency
|
||||
## @param[in] force (default False) Force copy of the file
|
||||
## @param[in,out] in_list (default None) Not real copy: set the request copy in the input list
|
||||
##
|
||||
def copy_anything(src, dst, recursive = False, force_identical=False, in_list=None):
|
||||
debug.verbose(" copy anything : '" + str(src) + "'")
|
||||
debug.verbose(" to : '" + str(dst) + "'")
|
||||
if os.path.isdir(os.path.realpath(src)):
|
||||
tmp_path = os.path.realpath(src)
|
||||
tmp_rule = ""
|
||||
else:
|
||||
tmp_path = os.path.dirname(os.path.realpath(src))
|
||||
tmp_rule = os.path.basename(src)
|
||||
|
||||
debug.verbose(" " + str(tmp_path) + ":")
|
||||
for root, dirnames, filenames in os.walk(tmp_path):
|
||||
deltaRoot = root[len(tmp_path):]
|
||||
while len(deltaRoot) > 0 \
|
||||
and ( deltaRoot[0] == '/' \
|
||||
or deltaRoot[0] == '\\' ):
|
||||
deltaRoot = deltaRoot[1:]
|
||||
if recursive == False \
|
||||
and deltaRoot != "":
|
||||
return
|
||||
debug.verbose(" root='" + str(deltaRoot) + "'")
|
||||
debug.verbose(" files=" + str(filenames))
|
||||
tmpList = filenames
|
||||
if len(tmp_rule) > 0:
|
||||
tmpList = fnmatch.filter(filenames, tmp_rule)
|
||||
# Import the module :
|
||||
for cycleFile in tmpList:
|
||||
#for cycleFile in filenames:
|
||||
debug.verbose(" '" + cycleFile + "'")
|
||||
debug.extreme_verbose("Might copy : '" + tmp_path + " " + deltaRoot + " " + cycleFile + "' ==> '" + dst + "'")
|
||||
copy_file(os.path.join(tmp_path, deltaRoot, cycleFile),
|
||||
os.path.join(dst, deltaRoot, cycleFile),
|
||||
force_identical=force_identical,
|
||||
in_list=in_list)
|
||||
|
||||
##
|
||||
## @brief real copy of files in a specific dictionnary list
|
||||
## @param[in] in_list Dictionnary of file to copy
|
||||
## @return True Something has been copied
|
||||
## @return False Nothing has been copied
|
||||
##
|
||||
def copy_list(in_list):
|
||||
has_file_copied = False
|
||||
for dst in in_list:
|
||||
if in_list[dst]["need_copy"] == False:
|
||||
continue
|
||||
# note we force the copy to disable the check of needed of copy (already done)
|
||||
copy_file(in_list[dst]["src"], dst, cmd_file=in_list[dst]["cmd_file"], force=True)
|
||||
has_file_copied = True
|
||||
return has_file_copied
|
||||
|
||||
##
|
||||
## @brief Clean a path from all un-needed element in a directory
|
||||
## @param[in] path Path to clean
|
||||
## @param[in] normal_list List of all files/path in the path
|
||||
## @return True Something has been removed
|
||||
## @return False Nothing has been removed
|
||||
##
|
||||
def clean_directory(path, normal_list):
|
||||
has_file_removed = False
|
||||
# get a list of all element in the path:
|
||||
for root, dirnames, filenames in os.walk(path):
|
||||
for file in filenames:
|
||||
file_name = os.path.join(root, file)
|
||||
if file_name not in normal_list:
|
||||
debug.print_element("remove file ", os.path.relpath(file_name), "==>", "---")
|
||||
os.remove(file_name)
|
||||
has_file_removed = True
|
||||
return has_file_removed
|
||||
|
||||
def filter_extention(list_files, extentions, invert=False):
|
||||
out = []
|
||||
for file in list_files:
|
||||
in_list = False
|
||||
for ext in extentions:
|
||||
if file[-len(ext):] == ext:
|
||||
in_list = True
|
||||
if in_list == True \
|
||||
and invert == False:
|
||||
out.append(file)
|
||||
elif in_list == False \
|
||||
and invert == True:
|
||||
out.append(file)
|
||||
return out
|
||||
|
||||
|
||||
def move_if_needed(src, dst):
|
||||
if not os.path.isfile(src):
|
||||
debug.error("request move if needed, but file does not exist: '" + str(src) + "' to '" + str(dst) + "'")
|
||||
return
|
||||
src_data = file_read_data(src)
|
||||
if os.path.isfile(dst):
|
||||
# file exist ==> must check ...
|
||||
dst_data = file_read_data(dst)
|
||||
if src_data == dst_data:
|
||||
# nothing to do ...
|
||||
return
|
||||
file_write_data(dst, src_data)
|
||||
remove_file(src)
|
||||
|
||||
def store_command(cmd_line, file):
|
||||
# write cmd line only after to prevent errors ...
|
||||
if file == "" \
|
||||
or file == None:
|
||||
return;
|
||||
debug.verbose("create cmd file: " + file)
|
||||
# Create directory:
|
||||
create_directory_of_file(file)
|
||||
# Store the command Line:
|
||||
file2 = open(file, "w")
|
||||
file2.write(cmd_line)
|
||||
file2.flush()
|
||||
file2.close()
|
||||
|
||||
def store_warning(file, output, err):
|
||||
# write warning line only after to prevent errors ...
|
||||
if file == "" \
|
||||
or file == None:
|
||||
return;
|
||||
if env.get_warning_mode() == False:
|
||||
debug.verbose("remove warning file: " + file)
|
||||
# remove file if exist...
|
||||
remove_file(file);
|
||||
return;
|
||||
debug.verbose("create warning file: " + file)
|
||||
# Create directory:
|
||||
create_directory_of_file(file)
|
||||
# Store the command Line:
|
||||
file2 = open(file, "w")
|
||||
file2.write("===== output =====\n")
|
||||
file2.write(output)
|
||||
file2.write("\n\n")
|
||||
file2.write("===== error =====\n")
|
||||
file2.write(err)
|
||||
file2.write("\n\n")
|
||||
file2.flush()
|
||||
file2.close()
|
||||
|
||||
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):
|
||||
for element in listout:
|
||||
if element==newElement:
|
||||
return
|
||||
listout.append(newElement)
|
||||
if order == True:
|
||||
if type(newElement) is not dict:
|
||||
listout.sort()
|
||||
|
||||
def list_append_to(out_list, in_list, order=False):
|
||||
if type(in_list) == str:
|
||||
list_append_and_check(out_list, in_list, order)
|
||||
elif type(in_list) == list:
|
||||
# mulyiple imput in the list ...
|
||||
for elem in in_list:
|
||||
list_append_and_check(out_list, elem, order)
|
||||
elif type(in_list) == dict:
|
||||
list_append_and_check(out_list, in_list, order)
|
||||
else:
|
||||
debug.warning("can not add in list other than {list/dict/str} : " + str(type(in_list)))
|
||||
|
||||
def list_append_to_2(listout, module, in_list, order=False):
|
||||
# sepcial cse of bool
|
||||
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], 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;
|
||||
|
||||
|
||||
9
lutin/z_builder/__init__.py
Normal file
9
lutin/z_builder/__init__.py
Normal file
@ -0,0 +1,9 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
191
lutin/z_builder/lutinBuilder_binary.py
Normal file
191
lutin/z_builder/lutinBuilder_binary.py
Normal file
@ -0,0 +1,191 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
##
|
||||
## Executable/binary builder
|
||||
##
|
||||
from lutin import multiprocess
|
||||
from lutin import tools
|
||||
from realog import debug
|
||||
from lutin import depend
|
||||
from lutin import env
|
||||
import os
|
||||
|
||||
##
|
||||
## Initialize the builder, if needed ... to get dependency between builder (for example)
|
||||
##
|
||||
def init():
|
||||
pass
|
||||
|
||||
##
|
||||
## Get the current builder type.
|
||||
## Return the type of builder
|
||||
##
|
||||
def get_type():
|
||||
return "linker"
|
||||
|
||||
|
||||
##
|
||||
## @brief Get builder input file type
|
||||
## @return List of extention supported
|
||||
##
|
||||
def get_input_type():
|
||||
return ["o"]
|
||||
|
||||
##
|
||||
## @brief Get builder output file type
|
||||
## @return List of extention supported
|
||||
##
|
||||
def get_output_type():
|
||||
return ["", "exe", "bin"]
|
||||
|
||||
##
|
||||
## @brief Get builder support multi-threading or not
|
||||
## @return True Multithreading supported
|
||||
## @return False Multithreading NOT supported
|
||||
##
|
||||
def get_support_multithreading():
|
||||
return False
|
||||
|
||||
##
|
||||
## @brief Commands for running gcc to link an executable.
|
||||
##
|
||||
def link(file, binary, target, depancy, flags, name, basic_path, static = False):
|
||||
file_src = file
|
||||
file_dst = target.get_build_file_bin(name, static)
|
||||
file_depend = file_dst + target.suffix_dependence
|
||||
file_cmd = file_dst + target.suffix_cmd_line
|
||||
file_warning = file_dst + target.suffix_warning
|
||||
|
||||
debug.extreme_verbose("list files = " + str(depancy.src))
|
||||
list_static = []
|
||||
list_dynamic = []
|
||||
if static == True:
|
||||
#get all parent static libs
|
||||
list_static = depancy.src['static']
|
||||
# get only parent shared that is not static
|
||||
for elem in depancy.src['dynamic']:
|
||||
lib_name = elem[:-len(target.suffix_lib_dynamic)] + target.suffix_lib_static
|
||||
if lib_name not in depancy.src['static']:
|
||||
list_dynamic.append(elem)
|
||||
else:
|
||||
#get all parent dynamic libs
|
||||
list_dynamic = depancy.src['dynamic']
|
||||
# get only parent shared that is not static
|
||||
for elem in depancy.src['static']:
|
||||
lib_name = elem[:-len(target.suffix_lib_static)] + target.suffix_lib_dynamic
|
||||
if lib_name not in depancy.src['dynamic']:
|
||||
list_static.append(elem)
|
||||
# set ccache interface:
|
||||
compilator_ccache = ""
|
||||
if env.get_ccache() == True:
|
||||
compilator_ccache = "ccache"
|
||||
#create comand line:
|
||||
cmd = [compilator_ccache]
|
||||
# a specific case to not depend on the libstdc++ automaticly added by the G++ or clang++ compilator ==> then need to compile with GCC or CLANG if use libcxx from llvm or other ...
|
||||
if "need-libstdc++" in depancy.flags \
|
||||
and depancy.flags["need-libstdc++"] == True:
|
||||
cmd.append(target.xx)
|
||||
else:
|
||||
cmd.append(target.cc)
|
||||
|
||||
try:
|
||||
cmd.append(target.arch)
|
||||
except:
|
||||
pass
|
||||
try:
|
||||
cmd.append(target.sysroot)
|
||||
except:
|
||||
pass
|
||||
try:
|
||||
cmd.append(["-o", file_dst])
|
||||
except:
|
||||
pass
|
||||
try:
|
||||
cmd.append(file_src)
|
||||
except:
|
||||
pass
|
||||
try:
|
||||
cmd.append(depancy.src['src'])
|
||||
except:
|
||||
pass
|
||||
try:
|
||||
cmd.append(list_static)
|
||||
except:
|
||||
pass
|
||||
try:
|
||||
for elem in list_dynamic:
|
||||
lib_path = os.path.dirname(elem)
|
||||
lib_name = elem[len(lib_path)+len(target.prefix_lib)+1:-len(target.suffix_lib_dynamic)]
|
||||
cmd.append("-L" + lib_path)
|
||||
cmd.append("-l" + lib_name)
|
||||
if target.name != "MacOs" \
|
||||
and target.name != "Android":
|
||||
if len(list_dynamic) > 0:
|
||||
cmd.append("-Wl,-R$ORIGIN/../lib/")
|
||||
except:
|
||||
pass
|
||||
cmd.append("-Wl,-rpath,\"$ORIGIN/../lib\"")
|
||||
try:
|
||||
cmd.append(flags["local"]["link"])
|
||||
except:
|
||||
pass
|
||||
try:
|
||||
cmd.append(depancy.flags["link"])
|
||||
except:
|
||||
pass
|
||||
try:
|
||||
cmd.append(target.global_flags["link"])
|
||||
except:
|
||||
pass
|
||||
for view in ["local", "export"]:
|
||||
if view not in flags:
|
||||
continue
|
||||
for type in ["link-lib"]:
|
||||
if type in flags[view]:
|
||||
cmd.append([("-l" + sss).replace("-l/", "/") for sss in flags[view][type] ])
|
||||
for type in ["link-bin"]:
|
||||
if type in flags[view]:
|
||||
cmd.append(flags[view][type])
|
||||
for type in ["link-lib"]:
|
||||
if type in depancy.flags:
|
||||
cmd.append([("-l" + sss).replace("-l/", "/") for sss in depancy.flags[type] ])
|
||||
for type in ["link-lib"]:
|
||||
if type in target.global_flags:
|
||||
cmd.append([("-l" + sss).replace("-l/", "/") for sss in target.global_flags[type] ])
|
||||
for type in ["link-bin"]:
|
||||
if type in target.global_flags:
|
||||
cmd.append(target.global_flags[type])
|
||||
if type in depancy.flags:
|
||||
cmd.append(depancy.flags[type])
|
||||
cmd_line = tools.list_to_str(cmd)
|
||||
# check the dependency for this file :
|
||||
if depend.need_re_package(file_dst, file_src, True, file_cmd=file_cmd, cmd_line=cmd_line) == False \
|
||||
and depend.need_re_package(file_dst, depancy.src, False, file_cmd=file_cmd, cmd_line=cmd_line) == False:
|
||||
return file_dst
|
||||
tools.create_directory_of_file(file_dst)
|
||||
debug.print_element("Executable", name, "==>", os.path.relpath(file_dst))
|
||||
|
||||
multiprocess.run_command(cmd_line, store_output_file=file_warning)
|
||||
if target.config["mode"] == "release"\
|
||||
or env.get_force_strip_mode() == True:
|
||||
# get the file size of the non strip file
|
||||
originSize = tools.file_size(file_dst);
|
||||
debug.print_element("Executable(strip)", name, "", "")
|
||||
cmd_lineStrip=tools.list_to_str([
|
||||
target.strip,
|
||||
file_dst])
|
||||
multiprocess.run_command(cmd_lineStrip, store_output_file=file_warning)
|
||||
# get the stip size of the binary
|
||||
strip_size = tools.file_size(file_dst)
|
||||
debug.debug("file reduce size : " + str(originSize/1024) + "ko ==> " + str(strip_size/1024) + "ko")
|
||||
# write cmd line only after to prevent errors ...
|
||||
tools.store_command(cmd_line, file_cmd)
|
||||
|
||||
179
lutin/z_builder/lutinBuilder_c.py
Normal file
179
lutin/z_builder/lutinBuilder_c.py
Normal file
@ -0,0 +1,179 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
##
|
||||
## C builder
|
||||
##
|
||||
from lutin import multiprocess
|
||||
from lutin import tools
|
||||
from realog import debug
|
||||
from lutin import depend
|
||||
from lutin import env
|
||||
|
||||
# C version:
|
||||
default_version = 1989
|
||||
default_version_gnu = False
|
||||
|
||||
##
|
||||
## Initialize the builder, if needed ... to get dependency between builder (for example)
|
||||
##
|
||||
def init():
|
||||
pass
|
||||
|
||||
##
|
||||
## Get the current builder type.
|
||||
## Return the type of builder
|
||||
##
|
||||
def get_type():
|
||||
return "compiler"
|
||||
|
||||
##
|
||||
## @brief Get builder input file type
|
||||
## @return List of extention supported
|
||||
##
|
||||
def get_input_type():
|
||||
return ["c", "C"]
|
||||
|
||||
##
|
||||
## @brief Get builder output file type
|
||||
## @return List of extention supported
|
||||
##
|
||||
def get_output_type():
|
||||
return ["o"]
|
||||
|
||||
##
|
||||
## @brief Get builder support multi-threading or not
|
||||
## @return True Multithreading supported
|
||||
## @return False Multithreading NOT supported
|
||||
##
|
||||
def get_support_multithreading():
|
||||
return True
|
||||
|
||||
##
|
||||
## @brief Commands for running gcc to compile a C file in object file.
|
||||
##
|
||||
def compile(file, binary, target, depancy, flags, path, name, basic_path, module_src):
|
||||
file_src = target.get_full_name_source(basic_path, file)
|
||||
file_cmd = target.get_full_name_cmd(name, basic_path, file)
|
||||
file_dst = target.get_full_name_destination(name, basic_path, file, get_output_type())
|
||||
file_depend = target.get_full_dependency(name, basic_path, file)
|
||||
file_warning = target.get_full_name_warning(name, basic_path, file)
|
||||
|
||||
# set ccache interface:
|
||||
compilator_ccache = ""
|
||||
if env.get_ccache() == True:
|
||||
compilator_ccache = "ccache"
|
||||
# create the command line befor requesting start:
|
||||
cmd = [
|
||||
compilator_ccache,
|
||||
target.cc,
|
||||
"-o", file_dst,
|
||||
target.arch,
|
||||
target.sysroot]
|
||||
for view in ["export", "local"]:
|
||||
try:
|
||||
cmd.append(tools.add_prefix("-I", path[view]["c"]))
|
||||
except:
|
||||
pass
|
||||
try:
|
||||
cmd.append(tools.add_prefix("-I", depancy.path["c"]))
|
||||
except:
|
||||
pass
|
||||
cmd.append(target.global_include_cc)
|
||||
try:
|
||||
cmd.append(get_version_compilation_flags(flags, depancy.flags))
|
||||
except:
|
||||
pass
|
||||
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"]:
|
||||
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")
|
||||
cmd.append(file_src)
|
||||
# Create cmd line
|
||||
cmdLine=tools.list_to_str(cmd)
|
||||
# check the dependency for this file :
|
||||
if depend.need_re_build(file_dst, file_src, file_depend, file_cmd, cmdLine) == False:
|
||||
return {"action":"add", "file":file_dst}
|
||||
tools.create_directory_of_file(file_dst)
|
||||
comment = ["c", name, "<==", file]
|
||||
# process element
|
||||
multiprocess.run_in_pool(cmdLine, comment, file_cmd, store_output_file=file_warning)
|
||||
return {"action":"add", "file":file_dst}
|
||||
|
||||
|
||||
def get_version_compilation_flags(flags, dependency_flags):
|
||||
try:
|
||||
version_local = flags["local"]["c-version"]["version"]
|
||||
except:
|
||||
version_local = default_version
|
||||
try:
|
||||
dependency_version = dependency_flags["c-version"]
|
||||
except:
|
||||
dependency_version = default_version
|
||||
try:
|
||||
is_gnu = flags["local"]["c-version"]["gnu"]
|
||||
except:
|
||||
is_gnu = default_version_gnu
|
||||
|
||||
version = max(version_local, dependency_version)
|
||||
if version == 2018:
|
||||
if is_gnu ==True:
|
||||
out = ["-std=gnu18", "-D__C_VERSION__=2018"]
|
||||
else:
|
||||
out = ["-std=c18", "-D__C_VERSION__=2018"]
|
||||
elif version == 2017:
|
||||
if is_gnu ==True:
|
||||
out = ["-std=gnu17", "-D__C_VERSION__=2017"]
|
||||
else:
|
||||
out = ["-std=c17", "-D__C_VERSION__=2017"]
|
||||
elif version == 2011:
|
||||
if is_gnu ==True:
|
||||
out = ["-std=gnu11", "-D__C_VERSION__=2011"]
|
||||
else:
|
||||
out = ["-std=c11", "-D__C_VERSION__=2011"]
|
||||
elif version == 1999:
|
||||
if is_gnu ==True:
|
||||
out = ["-std=gnu99", "-D__C_VERSION__=1999"]
|
||||
else:
|
||||
out = ["-std=c99", "-D__C_VERSION__=1999"]
|
||||
elif version == 1990:
|
||||
if is_gnu ==True:
|
||||
out = ["-std=gnu90", "-D__C_VERSION__=1990"]
|
||||
else:
|
||||
out = ["-std=c90", "-D__C_VERSION__=1990"]
|
||||
else:
|
||||
if is_gnu ==True:
|
||||
out = ["-std=gnu89", "-D__C_VERSION__=1989"]
|
||||
else:
|
||||
out = ["-std=c89", "-D__C_VERSION__=1989"]
|
||||
return out
|
||||
185
lutin/z_builder/lutinBuilder_cpp.py
Normal file
185
lutin/z_builder/lutinBuilder_cpp.py
Normal file
@ -0,0 +1,185 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
##
|
||||
## C++ builder
|
||||
##
|
||||
from lutin import multiprocess
|
||||
from lutin import tools
|
||||
from realog import debug
|
||||
from lutin import depend
|
||||
from lutin import env
|
||||
# C++ default version:
|
||||
default_version = 1999
|
||||
default_version_gnu = False
|
||||
|
||||
##
|
||||
## Initialize the builder, if needed ... to get dependency between builder (for example)
|
||||
##
|
||||
def init():
|
||||
pass
|
||||
|
||||
##
|
||||
## Get the current builder type.
|
||||
## Return the type of builder
|
||||
##
|
||||
def get_type():
|
||||
return "compiler"
|
||||
|
||||
##
|
||||
## @brief Get builder input file type
|
||||
## @return List of extention supported
|
||||
##
|
||||
def get_input_type():
|
||||
return ["cpp", "CPP", "cxx", "CXX", "xx", "XX", "CC", "cc"]
|
||||
|
||||
##
|
||||
## @brief Get builder output file type
|
||||
## @return List of extention supported
|
||||
##
|
||||
def get_output_type():
|
||||
return ["o"]
|
||||
|
||||
##
|
||||
## @brief Get builder support multi-threading or not
|
||||
## @return True Multithreading supported
|
||||
## @return False Multithreading NOT supported
|
||||
##
|
||||
def get_support_multithreading():
|
||||
return True
|
||||
|
||||
|
||||
##
|
||||
## @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)
|
||||
# set ccache interface:
|
||||
compilator_ccache = ""
|
||||
if env.get_ccache() == True:
|
||||
compilator_ccache = "ccache"
|
||||
# create the command line befor requesting start:
|
||||
cmd = [
|
||||
compilator_ccache,
|
||||
target.xx,
|
||||
"-o", file_dst,
|
||||
target.arch,
|
||||
target.sysroot
|
||||
]
|
||||
for view in ["export", "local"]:
|
||||
for type in ["c", "c++"]:
|
||||
try:
|
||||
cmd.append(tools.add_prefix("-I",path[view][type]))
|
||||
except:
|
||||
pass
|
||||
for type in ["c", "c++"]:
|
||||
try:
|
||||
cmd.append(tools.add_prefix("-I",depancy.path[type]))
|
||||
except:
|
||||
pass
|
||||
cmd.append(target.global_include_cc)
|
||||
try:
|
||||
cmd.append(get_version_compilation_flags(flags, depancy.flags))
|
||||
except:
|
||||
pass
|
||||
list_flags = [];
|
||||
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++"])
|
||||
for type in ["c", "c++"]:
|
||||
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++"]:
|
||||
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"])
|
||||
for type in ["c-remove", "c++-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"]:
|
||||
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(file_src)
|
||||
# Create cmd line
|
||||
cmdLine = tools.list_to_str(cmd)
|
||||
# check the dependency for this file :
|
||||
if depend.need_re_build(file_dst, file_src, file_depend, file_cmd, cmdLine) == False:
|
||||
return {"action":"add", "file":file_dst}
|
||||
tools.create_directory_of_file(file_dst)
|
||||
comment = ["c++", name, "<==", file]
|
||||
#process element
|
||||
multiprocess.run_in_pool(cmdLine, comment, file_cmd, store_output_file=file_warning)
|
||||
return {"action":"add", "file":file_dst}
|
||||
|
||||
def get_version_compilation_flags(flags, dependency_flags):
|
||||
try:
|
||||
version_local = flags["local"]["c++-version"]["version"]
|
||||
except:
|
||||
version_local = default_version
|
||||
try:
|
||||
dependency_version = dependency_flags["c++-version"]
|
||||
except:
|
||||
dependency_version = default_version
|
||||
try:
|
||||
is_gnu = flags["local"]["c++-version"]["gnu"]
|
||||
except:
|
||||
is_gnu = default_version_gnu
|
||||
|
||||
version = max(version_local, dependency_version)
|
||||
if version == 2020:
|
||||
if is_gnu == True:
|
||||
out = ["-std=gnu++2a", "-D__CPP_VERSION__=2020"]
|
||||
else:
|
||||
out = ["-std=c++2a", "-D__CPP_VERSION__=2020"]
|
||||
elif version == 2017:
|
||||
if is_gnu == True:
|
||||
out = ["-std=gnu++17", "-D__CPP_VERSION__=2017"]
|
||||
else:
|
||||
out = ["-std=c++17", "-D__CPP_VERSION__=2017"]
|
||||
elif version == 2014:
|
||||
if is_gnu == True:
|
||||
out = ["-std=gnu++14", "-D__CPP_VERSION__=2014"]
|
||||
else:
|
||||
out = ["-std=c++14", "-D__CPP_VERSION__=2014"]
|
||||
elif version == 2011:
|
||||
if is_gnu == True:
|
||||
out = ["-std=gnu++11", "-D__CPP_VERSION__=2011"]
|
||||
else:
|
||||
out = ["-std=c++11", "-D__CPP_VERSION__=2011"]
|
||||
elif version == 2003:
|
||||
if is_gnu == True:
|
||||
out = ["-std=gnu++03", "-D__CPP_VERSION__=2003"]
|
||||
else:
|
||||
out = ["-std=c++03", "-D__CPP_VERSION__=2003"]
|
||||
else:
|
||||
if is_gnu == True:
|
||||
out = ["-std=gnu++98", "-D__CPP_VERSION__=1999"]
|
||||
else:
|
||||
out = ["-std=c++98", "-D__CPP_VERSION__=1999"]
|
||||
return out
|
||||
96
lutin/z_builder/lutinBuilder_jar.py
Normal file
96
lutin/z_builder/lutinBuilder_jar.py
Normal file
@ -0,0 +1,96 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
##
|
||||
## Dynamic library builder
|
||||
##
|
||||
from lutin import multiprocess
|
||||
from lutin import tools
|
||||
from realog import debug
|
||||
from lutin import depend
|
||||
from lutin import env
|
||||
import os
|
||||
|
||||
##
|
||||
## Initialize the builder, if needed ... to get dependency between builder (for example)
|
||||
##
|
||||
def init():
|
||||
pass
|
||||
|
||||
##
|
||||
## Get the current builder type.
|
||||
## Return the type of builder
|
||||
##
|
||||
def get_type():
|
||||
return "linker"
|
||||
|
||||
##
|
||||
## @brief Get builder input file type
|
||||
## @return List of extention supported
|
||||
##
|
||||
def get_input_type():
|
||||
return ["class"]
|
||||
|
||||
##
|
||||
## @brief Get builder output file type
|
||||
## @return List of extention supported
|
||||
##
|
||||
def get_output_type():
|
||||
return ["jar"]
|
||||
|
||||
##
|
||||
## @brief Get builder support multi-threading or not
|
||||
## @return True Multithreading supported
|
||||
## @return False Multithreading NOT supported
|
||||
##
|
||||
def get_support_multithreading():
|
||||
return False
|
||||
|
||||
##
|
||||
## @brief Commands for running gcc to link a shared library.
|
||||
##
|
||||
def link(file, binary, target, depancy, flags, name, basic_path):
|
||||
file_src = file
|
||||
file_dst = os.path.join(target.get_build_path(name), name + ".jar")
|
||||
file_depend = file_dst + target.suffix_dependence
|
||||
file_cmd = file_dst + target.suffix_cmd_line
|
||||
file_warning = file_dst + target.suffix_warning
|
||||
|
||||
#create command Line
|
||||
cmd = [
|
||||
target.jar,
|
||||
"cf", file_dst,
|
||||
]
|
||||
for file in file_src:
|
||||
path = ""
|
||||
for elem in ["org/", "com/"]:
|
||||
pos = file.find(elem);
|
||||
if pos > 0:
|
||||
path = file[:pos]
|
||||
file = file[pos:]
|
||||
cmd.append("-C")
|
||||
cmd.append(path)
|
||||
cmd.append(file)
|
||||
cmdLine=tools.list_to_str(cmd)
|
||||
"""
|
||||
# check the dependency for this file :
|
||||
if depend.need_re_package(file_dst, file_src, True, file_cmd, cmdLine) == False:
|
||||
return tmpList[1]
|
||||
"""
|
||||
tools.create_directory_of_file(file_dst)
|
||||
debug.print_element("jar", name, "==>", file_dst)
|
||||
multiprocess.run_command(cmdLine, store_output_file=file_warning)
|
||||
# write cmd line only after to prevent errors ...
|
||||
tools.store_command(cmdLine, file_cmd)
|
||||
#debug.print_element("SharedLib", self.name, "==>", tmpList[1])
|
||||
return file_dst
|
||||
|
||||
|
||||
|
||||
141
lutin/z_builder/lutinBuilder_java.py
Normal file
141
lutin/z_builder/lutinBuilder_java.py
Normal file
@ -0,0 +1,141 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
##
|
||||
## Java builder
|
||||
##
|
||||
from lutin import multiprocess
|
||||
from lutin import tools
|
||||
from realog import debug
|
||||
from lutin import depend
|
||||
|
||||
##
|
||||
## Initialize the builder, if needed ... to get dependency between builder (for example)
|
||||
##
|
||||
def init():
|
||||
pass
|
||||
|
||||
##
|
||||
## Get the current builder type.
|
||||
## Return the type of builder
|
||||
##
|
||||
def get_type():
|
||||
return "compiler"
|
||||
|
||||
##
|
||||
## @brief Get builder input file type
|
||||
## @return List of extention supported
|
||||
##
|
||||
def get_input_type():
|
||||
return ["java"]
|
||||
|
||||
##
|
||||
## @brief Get builder output file type
|
||||
## @return List of extention supported
|
||||
##
|
||||
def get_output_type():
|
||||
return ["class"]
|
||||
|
||||
##
|
||||
## @brief Get builder support multi-threading or not
|
||||
## @return True Multithreading supported
|
||||
## @return False Multithreading NOT supported
|
||||
##
|
||||
def get_support_multithreading():
|
||||
return False
|
||||
|
||||
def create_dependency_files(target, src, heritage_src, basic_path):
|
||||
depend = []
|
||||
for elem in src:
|
||||
extention = elem.split('.')[-1]
|
||||
if extention == 'jar' \
|
||||
or extention == 'java':
|
||||
debug.extreme_verbose("add java depedence ... " + elem)
|
||||
depend.append(target.get_full_name_source(basic_path, elem))
|
||||
|
||||
for elem in heritage_src:
|
||||
extention = elem.split('.')[-1]
|
||||
if extention == 'jar' \
|
||||
or extention == 'java':
|
||||
debug.extreme_verbose("add java depedence ... " + elem)
|
||||
depend.append(elem)
|
||||
return depend
|
||||
|
||||
##
|
||||
## @brief Commands for running gcc to compile a C++ file in object file.
|
||||
##
|
||||
def compile(file, binary, target, depancy, flags, path, name, basic_path, module_src):
|
||||
file_src = target.get_full_name_source(basic_path, file)
|
||||
file_cmd = target.get_full_name_cmd(name, basic_path, file)
|
||||
file_dst = target.get_full_name_destination(name, basic_path, file, get_output_type(), remove_suffix=True)
|
||||
file_depend = target.get_full_dependency(name, basic_path, file)
|
||||
file_warning = target.get_full_name_warning(name, basic_path, file)
|
||||
depend_files = create_dependency_files(target, module_src, depancy.src['src'], basic_path)
|
||||
"""
|
||||
debug.warning("file_src = " + file_src)
|
||||
debug.warning("file_cmd = " + file_cmd)
|
||||
debug.warning("file_dst = " + file_dst)
|
||||
debug.warning("file_depend = " + file_depend)
|
||||
debug.warning("file_warning = " + file_warning)
|
||||
"""
|
||||
# create the command line befor requesting start:
|
||||
cmd = [
|
||||
target.java,
|
||||
"-d", target.get_build_path_object(name)
|
||||
]
|
||||
# add source dependency:
|
||||
list_sources_path = []
|
||||
for view in ["export", "local"]:
|
||||
try:
|
||||
list = path[view]["java"]
|
||||
for elem in list:
|
||||
list_sources_path.append(elem)
|
||||
except:
|
||||
pass
|
||||
if len(list_sources_path) > 0:
|
||||
cmd.append("-sourcepath")
|
||||
out = ""
|
||||
for elem in list_sources_path:
|
||||
if len(out) > 0:
|
||||
out += ":"
|
||||
out += elem
|
||||
cmd.append(out)
|
||||
class_extern = []
|
||||
upper_jar = tools.filter_extention(depancy.src['src'], ["jar"])
|
||||
#debug.warning("ploppppp = " + str(upper_jar))
|
||||
for elem in upper_jar:
|
||||
class_extern.append(elem)
|
||||
if len(class_extern) > 0:
|
||||
cmd.append("-classpath")
|
||||
out = ""
|
||||
for elem in class_extern:
|
||||
if len(out) > 0:
|
||||
out += ":"
|
||||
out += elem
|
||||
cmd.append(out)
|
||||
|
||||
cmd.append(file_src)
|
||||
# Create cmd line
|
||||
cmdLine=tools.list_to_str(cmd)
|
||||
|
||||
# check the dependency for this file :
|
||||
if depend.need_re_build(file_dst, file_src, file_depend, file_cmd, cmdLine) == False:
|
||||
return {"action":"add", "file":file_dst}
|
||||
tools.create_directory_of_file(file_dst)
|
||||
comment = ["java", name, "<==", file]
|
||||
#process element
|
||||
multiprocess.run_in_pool(cmdLine,
|
||||
comment,
|
||||
file_cmd,
|
||||
store_output_file = file_warning,
|
||||
depend_data = {"file":file_depend,
|
||||
"data":depend_files})
|
||||
return {"action":"add", "file":file_dst}
|
||||
|
||||
113
lutin/z_builder/lutinBuilder_javah.py
Normal file
113
lutin/z_builder/lutinBuilder_javah.py
Normal file
@ -0,0 +1,113 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
##
|
||||
## Java builder
|
||||
##
|
||||
from lutin import multiprocess
|
||||
from lutin import tools
|
||||
from realog import debug
|
||||
from lutin import depend
|
||||
|
||||
##
|
||||
## Initialize the builder, if needed ... to get dependency between builder (for example)
|
||||
##
|
||||
def init():
|
||||
pass
|
||||
|
||||
##
|
||||
## Get the current builder type.
|
||||
## Return the type of builder
|
||||
##
|
||||
def get_type():
|
||||
return "compiler"
|
||||
|
||||
##
|
||||
## @brief Get builder input file type
|
||||
## @return List of extention supported
|
||||
##
|
||||
def get_input_type():
|
||||
return ["javah"]
|
||||
|
||||
##
|
||||
## @brief Get builder output file type
|
||||
## @return List of extention supported
|
||||
##
|
||||
def get_output_type():
|
||||
return ["h"]
|
||||
|
||||
##
|
||||
## @brief Get builder support multi-threading or not
|
||||
## @return True Multithreading supported
|
||||
## @return False Multithreading NOT supported
|
||||
##
|
||||
def get_support_multithreading():
|
||||
return False
|
||||
|
||||
def create_dependency_files(target, src, heritage_src, basic_path):
|
||||
depend = []
|
||||
for elem in src:
|
||||
extention = elem.split('.')[-1]
|
||||
if extention == 'jar' \
|
||||
or extention == 'java':
|
||||
debug.extreme_verbose("add java depedence ... " + elem)
|
||||
depend.append(target.get_full_name_source(basic_path, elem))
|
||||
|
||||
for elem in heritage_src:
|
||||
extention = elem.split('.')[-1]
|
||||
if extention == 'jar' \
|
||||
or extention == 'java':
|
||||
debug.extreme_verbose("add java depedence ... " + elem)
|
||||
depend.append(elem)
|
||||
return depend
|
||||
|
||||
##
|
||||
## @brief Commands for running gcc to compile a C++ file in object file.
|
||||
##
|
||||
def compile(file, binary, target, depancy, flags, path, name, basic_path, module_src):
|
||||
# file_src = target.get_full_name_source(basic_path, file)
|
||||
file_cmd = target.get_full_name_cmd(name, basic_path, file)
|
||||
# file_dst = target.get_full_name_destination(name, basic_path, file, get_output_type())
|
||||
file_depend = target.get_full_dependency(name, basic_path, file)
|
||||
file_warning = target.get_full_name_warning(name, basic_path, file)
|
||||
depend_files = create_dependency_files(target, module_src, depancy.src['src'], basic_path)
|
||||
# create the command line befor requesting start:
|
||||
cmd = [
|
||||
target.javah,
|
||||
"-d", target.get_build_path(name) + target.path_generate_code
|
||||
]
|
||||
|
||||
if debug.get_level() >= 5:
|
||||
cmd.append("-verbose")
|
||||
|
||||
cmd.append("-classpath")
|
||||
cmd.append(target.get_build_path_object(name))
|
||||
class_to_build = file[:-6]
|
||||
cmd.append(class_to_build)
|
||||
# Create cmd line
|
||||
cmd_line = tools.list_to_str(cmd)
|
||||
|
||||
file_dst = target.get_build_path(name) + "/generate_header/" + class_to_build.replace(".", "_") + ".h"
|
||||
# check the dependency for this file :
|
||||
if depend.need_re_build(file_dst, None, file_depend, file_cmd, cmd_line) == False:
|
||||
return {"action":"path", "path":target.get_build_path(name) + target.path_generate_code}
|
||||
#tools.create_directory_of_file(file_dst)
|
||||
comment = ["javah", class_to_build.replace(".", "_") + ".h", "<==", class_to_build]
|
||||
#process element
|
||||
multiprocess.run_in_pool(cmd_line,
|
||||
comment,
|
||||
file_cmd,
|
||||
store_output_file = file_warning,
|
||||
depend_data = {"file":file_depend,
|
||||
"data":depend_files})
|
||||
debug.verbose("file= " + file_dst)
|
||||
#return file_dst
|
||||
return {"action":"path", "path":target.get_build_path(name) + target.path_generate_code}
|
||||
|
||||
188
lutin/z_builder/lutinBuilder_libraryDynamic.py
Normal file
188
lutin/z_builder/lutinBuilder_libraryDynamic.py
Normal file
@ -0,0 +1,188 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
##
|
||||
## Dynamic library builder
|
||||
##
|
||||
from lutin import multiprocess
|
||||
from lutin import tools
|
||||
from realog import debug
|
||||
from lutin import depend
|
||||
from lutin import env
|
||||
import os
|
||||
|
||||
##
|
||||
## Initialize the builder, if needed ... to get dependency between builder (for example)
|
||||
##
|
||||
def init():
|
||||
pass
|
||||
|
||||
##
|
||||
## Get the current builder type.
|
||||
## Return the type of builder
|
||||
##
|
||||
def get_type():
|
||||
return "linker"
|
||||
|
||||
##
|
||||
## @brief Get builder input file type
|
||||
## @return List of extention supported
|
||||
##
|
||||
def get_input_type():
|
||||
return ["o", "a"]
|
||||
|
||||
##
|
||||
## @brief Get builder output file type
|
||||
## @return List of extention supported
|
||||
##
|
||||
def get_output_type():
|
||||
return ["so", "dynlib", "dll"]
|
||||
|
||||
##
|
||||
## @brief Get builder support multi-threading or not
|
||||
## @return True Multithreading supported
|
||||
## @return False Multithreading NOT supported
|
||||
##
|
||||
def get_support_multithreading():
|
||||
return False
|
||||
|
||||
##
|
||||
## @brief Commands for running gcc to link a shared library.
|
||||
##
|
||||
def link(file, binary, target, depancy, flags, name, basic_path, static=False):
|
||||
file_src = file
|
||||
file_dst = target.get_build_file_dynamic(name)
|
||||
file_depend = file_dst + target.suffix_dependence
|
||||
file_cmd = file_dst + target.suffix_cmd_line
|
||||
file_warning = file_dst + target.suffix_warning
|
||||
|
||||
debug.extreme_verbose("file_dst = " + file_dst)
|
||||
debug.extreme_verbose("file_depend = " + file_depend)
|
||||
debug.extreme_verbose("file_cmd = " + file_cmd)
|
||||
debug.extreme_verbose("file_warning = " + file_warning)
|
||||
|
||||
list_static = []
|
||||
list_dynamic = []
|
||||
if static == True:
|
||||
#get all parent static libs
|
||||
list_static = depancy.src['static']
|
||||
# get only parent shared that is not static
|
||||
for elem in depancy.src['dynamic']:
|
||||
lib_name = elem[:-len(target.suffix_lib_dynamic)] + target.suffix_lib_static
|
||||
if lib_name not in depancy.src['static']:
|
||||
list_dynamic.append(elem)
|
||||
else:
|
||||
#get all parent dynamic libs
|
||||
list_dynamic = depancy.src['dynamic']
|
||||
# get only parent shared that is not static
|
||||
for elem in depancy.src['static']:
|
||||
lib_name = elem[:-len(target.suffix_lib_static)] + target.suffix_lib_dynamic
|
||||
if lib_name not in depancy.src['dynamic']:
|
||||
list_static.append(elem)
|
||||
# set ccache interface:
|
||||
compilator_ccache = ""
|
||||
if env.get_ccache() == True:
|
||||
compilator_ccache = "ccache"
|
||||
#create command Line
|
||||
cmd = [compilator_ccache]
|
||||
# a specific case to not depend on the libstdc++ automaticly added by the G++ or clang++ compilator ==> then need to compile with GCC or CLANG if use libcxx from llvm or other ...
|
||||
if "need-libstdc++" in depancy.flags \
|
||||
and depancy.flags["need-libstdc++"] == True:
|
||||
cmd.append(target.xx)
|
||||
else:
|
||||
cmd.append(target.cc)
|
||||
|
||||
cmd.append(["-o", file_dst])
|
||||
try:
|
||||
cmd.append(target.sysroot)
|
||||
except:
|
||||
pass
|
||||
try:
|
||||
cmd.append(target.arch)
|
||||
except:
|
||||
pass
|
||||
cmd.append("-shared")
|
||||
try:
|
||||
cmd.append(file_src)
|
||||
except:
|
||||
pass
|
||||
try:
|
||||
cmd.append(list_static)
|
||||
except:
|
||||
pass
|
||||
for view in ["local", "export"]:
|
||||
if view not in flags:
|
||||
continue
|
||||
for type in ["link", "link-dynamic"]:
|
||||
if type in flags[view]:
|
||||
cmd.append(flags[view][type])
|
||||
for type in ["link", "link-dynamic"]:
|
||||
if type in depancy.flags:
|
||||
cmd.append(depancy.flags[type])
|
||||
for type in ["link", "link-dynamic"]:
|
||||
if type in target.global_flags:
|
||||
cmd.append(target.global_flags[type])
|
||||
if 'src' in depancy.src:
|
||||
cmd.append(tools.filter_extention(depancy.src['src'], get_input_type()))
|
||||
try:
|
||||
for elem in list_dynamic:
|
||||
lib_path = os.path.dirname(elem)
|
||||
lib_name = elem[len(lib_path)+len(target.prefix_lib)+1:-len(target.suffix_lib_dynamic)]
|
||||
cmd.append("-L" + lib_path)
|
||||
cmd.append("-l" + lib_name)
|
||||
if target.name != "MacOs" \
|
||||
and target.name != "Android":
|
||||
if len(list_dynamic) > 0:
|
||||
cmd.append("-Wl,-R$ORIGIN/../lib/")
|
||||
except:
|
||||
pass
|
||||
for view in ["local", "export"]:
|
||||
if view not in flags:
|
||||
continue
|
||||
for type in ["link-lib"]:
|
||||
if type in flags[view]:
|
||||
cmd.append([("-l" + sss).replace("-l/", "/") for sss in flags[view][type] ])
|
||||
for type in ["link-lib"]:
|
||||
if type in depancy.flags:
|
||||
cmd.append([("-l" + sss).replace("-l/", "/") for sss in depancy.flags[type] ])
|
||||
for type in ["link-lib"]:
|
||||
if type in target.global_flags:
|
||||
cmd.append([("-l" + sss).replace("-l/", "/") for sss in target.global_flags[type] ])
|
||||
cmdLine=tools.list_to_str(cmd)
|
||||
# check the dependency for this file :
|
||||
if depend.need_re_package(file_dst, file_src, True, file_cmd, cmdLine) == False \
|
||||
and depend.need_re_package(file_dst, depancy.src, False, file_cmd, cmdLine) == False:
|
||||
return file_dst
|
||||
tools.create_directory_of_file(file_dst)
|
||||
debug.print_element("SharedLib", name, "==>", os.path.relpath(file_dst))
|
||||
multiprocess.run_command(cmdLine, store_output_file=file_warning)
|
||||
# strip the output file:
|
||||
if target.config["mode"] == "release" \
|
||||
or env.get_force_strip_mode() == True:
|
||||
# get the file size of the non strip file
|
||||
originSize = tools.file_size(file_dst);
|
||||
debug.print_element("SharedLib(strip)", name, "", "")
|
||||
if "MacOs" in target.get_type():
|
||||
cmdLineStrip=tools.list_to_str([
|
||||
target.strip,
|
||||
"-u",
|
||||
file_dst])
|
||||
else:
|
||||
cmdLineStrip=tools.list_to_str([
|
||||
target.strip,
|
||||
file_dst])
|
||||
multiprocess.run_command(cmdLineStrip, store_output_file=file_warning)
|
||||
# get the stip size of the binary
|
||||
stripSize = tools.file_size(file_dst)
|
||||
debug.debug("file reduce size : " + str(originSize/1024) + "ko ==> " + str(stripSize/1024) + "ko")
|
||||
# write cmd line only after to prevent errors ...
|
||||
tools.store_command(cmdLine, file_cmd)
|
||||
#debug.print_element("SharedLib", self.name, "==>", tmpList[1])
|
||||
return file_dst
|
||||
115
lutin/z_builder/lutinBuilder_libraryStatic.py
Normal file
115
lutin/z_builder/lutinBuilder_libraryStatic.py
Normal file
@ -0,0 +1,115 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
##
|
||||
## Static library builder
|
||||
##
|
||||
from lutin import multiprocess
|
||||
from lutin import tools
|
||||
from realog import debug
|
||||
from lutin import depend
|
||||
from lutin import env
|
||||
import os
|
||||
|
||||
##
|
||||
## Initialize the builder, if needed ... to get dependency between builder (for example)
|
||||
##
|
||||
def init():
|
||||
pass
|
||||
|
||||
##
|
||||
## Get the current builder type.
|
||||
## Return the type of builder
|
||||
##
|
||||
def get_type():
|
||||
return "linker"
|
||||
|
||||
##
|
||||
## @brief Get builder input file type
|
||||
## @return List of extention supported
|
||||
##
|
||||
def get_input_type():
|
||||
return ["o", "a"]
|
||||
|
||||
##
|
||||
## @brief Get builder output file type
|
||||
## @return List of extention supported
|
||||
##
|
||||
def get_output_type():
|
||||
return ["a"]
|
||||
|
||||
##
|
||||
## @brief Get builder support multi-threading or not
|
||||
## @return True Multithreading supported
|
||||
## @return False Multithreading NOT supported
|
||||
##
|
||||
def get_support_multithreading():
|
||||
return False
|
||||
|
||||
##
|
||||
## @brief Commands for running ar.
|
||||
##
|
||||
def link(file, binary, target, depancy, flags, name, basic_path):
|
||||
file_src = file
|
||||
file_dst = target.get_build_file_static(name)
|
||||
file_depend = file_dst + target.suffix_dependence
|
||||
file_cmd = file_dst + target.suffix_cmd_line
|
||||
file_warning = file_dst + target.suffix_warning
|
||||
|
||||
debug.extreme_verbose("file_dst = " + file_dst)
|
||||
debug.extreme_verbose("file_depend = " + file_depend)
|
||||
debug.extreme_verbose("file_cmd = " + file_cmd)
|
||||
debug.extreme_verbose("file_warning = " + file_warning)
|
||||
|
||||
# set ccache interface:
|
||||
compilator_ccache = ""
|
||||
if env.get_ccache() == True:
|
||||
compilator_ccache = "ccache"
|
||||
cmd = [
|
||||
compilator_ccache,
|
||||
target.ar
|
||||
]
|
||||
try:
|
||||
cmd.append(target.global_flags["ar"])
|
||||
except:
|
||||
pass
|
||||
try:
|
||||
cmd.append(flags["local"]["link"])
|
||||
except:
|
||||
pass
|
||||
try:
|
||||
cmd.append(file_dst)
|
||||
except:
|
||||
pass
|
||||
try:
|
||||
cmd.append(file_src)
|
||||
except:
|
||||
pass
|
||||
cmdLine=tools.list_to_str(cmd)
|
||||
# check the dependency for this file :
|
||||
if depend.need_re_package(file_dst, file_src, True, file_cmd, cmdLine) == False \
|
||||
and depend.need_re_package(file_dst, depancy.src, False, file_cmd, cmdLine) == False:
|
||||
return file_dst
|
||||
|
||||
tools.create_directory_of_file(file_dst)
|
||||
debug.print_element("StaticLib", name, "==>", os.path.relpath(file_dst))
|
||||
# explicitly remove the destination to prevent error ...
|
||||
if os.path.exists(file_dst) and os.path.isfile(file_dst):
|
||||
os.remove(file_dst)
|
||||
multiprocess.run_command(cmdLine, store_output_file=file_warning)
|
||||
#$(Q)$(TARGET_RANLIB) $@
|
||||
if target.ranlib != "":
|
||||
cmdLineRanLib=tools.list_to_str([
|
||||
target.ranlib,
|
||||
file_dst ])
|
||||
multiprocess.run_command(cmdLineRanLib, store_output_file=file_warning)
|
||||
# write cmd line only after to prevent errors ...
|
||||
tools.store_command(cmdLine, file_cmd)
|
||||
return file_dst
|
||||
140
lutin/z_builder/lutinBuilder_m.py
Normal file
140
lutin/z_builder/lutinBuilder_m.py
Normal file
@ -0,0 +1,140 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
##
|
||||
## Objective-C builder
|
||||
##
|
||||
from lutin import multiprocess
|
||||
from lutin import tools
|
||||
from lutin import builder
|
||||
from realog import debug
|
||||
from lutin import depend
|
||||
from lutin import env
|
||||
|
||||
local_ref_on_builder_c = None
|
||||
|
||||
##
|
||||
## Initialize the builder, if needed ... to get dependency between builder (for example)
|
||||
##
|
||||
def init():
|
||||
global local_ref_on_builder_c
|
||||
debug.debug("m builder get dependency on the C builder")
|
||||
local_ref_on_builder_c = builder.get_builder("c")
|
||||
|
||||
##
|
||||
## Get the current builder type.
|
||||
## Return the type of builder
|
||||
##
|
||||
def get_type():
|
||||
return "compiler"
|
||||
|
||||
##
|
||||
## @brief Get builder input file type
|
||||
## @return List of extention supported
|
||||
##
|
||||
def get_input_type():
|
||||
return ["m", "M"]
|
||||
|
||||
##
|
||||
## @brief Get builder output file type
|
||||
## @return List of extention supported
|
||||
##
|
||||
def get_output_type():
|
||||
return ["o"]
|
||||
|
||||
##
|
||||
## @brief Get builder support multi-threading or not
|
||||
## @return True Multithreading supported
|
||||
## @return False Multithreading NOT supported
|
||||
##
|
||||
def get_support_multithreading():
|
||||
return True
|
||||
|
||||
##
|
||||
## @brief Commands for running gcc to compile a m file in object file.
|
||||
##
|
||||
def compile(file, binary, target, depancy, flags, path, name, basic_path, module_src):
|
||||
file_src = target.get_full_name_source(basic_path, file)
|
||||
file_cmd = target.get_full_name_cmd(name, basic_path, file)
|
||||
file_dst = target.get_full_name_destination(name, basic_path, file, get_output_type())
|
||||
file_depend = target.get_full_dependency(name, basic_path, file)
|
||||
file_warning = target.get_full_name_warning(name, basic_path, file)
|
||||
# set ccache interface:
|
||||
compilator_ccache = ""
|
||||
if env.get_ccache() == True:
|
||||
compilator_ccache = "ccache"
|
||||
# create the command line befor requesting start:
|
||||
cmd = [
|
||||
compilator_ccache,
|
||||
target.cc,
|
||||
"-o", file_dst ,
|
||||
target.arch,
|
||||
target.sysroot,
|
||||
target.global_include_cc]
|
||||
for view in ["export", "local"]:
|
||||
for type in ["c", "m"]:
|
||||
try:
|
||||
cmd.append(tools.add_prefix("-I",path[view][type]))
|
||||
except:
|
||||
pass
|
||||
for type in ["c", "m"]:
|
||||
try:
|
||||
cmd.append(tools.add_prefix("-I",depancy.path[type]))
|
||||
except:
|
||||
pass
|
||||
try:
|
||||
cmd.append(local_ref_on_builder_c.get_version_compilation_flags(flags, depancy.flags))
|
||||
except:
|
||||
pass
|
||||
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"]:
|
||||
if type in depancy.flags:
|
||||
list_flags.append(depancy.flags[type])
|
||||
for view in ["local", "export"]:
|
||||
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)
|
||||
# Create cmd line
|
||||
cmdLine=tools.list_to_str(cmd)
|
||||
# check the dependency for this file :
|
||||
if depend.need_re_build(file_dst, file_src, file_depend, file_cmd, cmdLine) == False:
|
||||
return {"action":"add", "file":file_dst}
|
||||
tools.create_directory_of_file(file_dst)
|
||||
comment = ["m", name, "<==", file]
|
||||
#process element
|
||||
multiprocess.run_in_pool(cmdLine, comment, file_cmd, store_output_file=file_warning)
|
||||
return {"action":"add", "file":file_dst}
|
||||
|
||||
147
lutin/z_builder/lutinBuilder_mm.py
Normal file
147
lutin/z_builder/lutinBuilder_mm.py
Normal file
@ -0,0 +1,147 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
##
|
||||
## Objective C++ builder
|
||||
##
|
||||
from lutin import multiprocess
|
||||
from lutin import tools
|
||||
from lutin import builder
|
||||
from realog import debug
|
||||
from lutin import depend
|
||||
from lutin import env
|
||||
|
||||
local_ref_on_builder_cpp = None
|
||||
|
||||
##
|
||||
## Initialize the builder, if needed ... to get dependency between builder (for example)
|
||||
##
|
||||
def init():
|
||||
global local_ref_on_builder_cpp
|
||||
debug.debug("mm builder get dependency on the CPP builder")
|
||||
local_ref_on_builder_cpp = builder.get_builder("cpp")
|
||||
|
||||
##
|
||||
## Get the current builder type.
|
||||
## Return the type of builder
|
||||
##
|
||||
def get_type():
|
||||
return "compiler"
|
||||
|
||||
##
|
||||
## @brief Get builder input file type
|
||||
## @return List of extention supported
|
||||
##
|
||||
def get_input_type():
|
||||
return ["mm", "MM"]
|
||||
|
||||
##
|
||||
## @brief Get builder output file type
|
||||
## @return List of extention supported
|
||||
##
|
||||
def get_output_type():
|
||||
return ["o"]
|
||||
|
||||
##
|
||||
## @brief Get builder support multi-threading or not
|
||||
## @return True Multithreading supported
|
||||
## @return False Multithreading NOT supported
|
||||
##
|
||||
def get_support_multithreading():
|
||||
return True
|
||||
|
||||
##
|
||||
## @brief Commands for running gcc to compile a m++ file in object file.
|
||||
##
|
||||
def compile(file, binary, target, depancy, flags, path, name, basic_path, module_src):
|
||||
file_src = target.get_full_name_source(basic_path, file)
|
||||
file_cmd = target.get_full_name_cmd(name, basic_path, file)
|
||||
file_dst = target.get_full_name_destination(name, basic_path, file, get_output_type())
|
||||
file_depend = target.get_full_dependency(name, basic_path, file)
|
||||
file_warning = target.get_full_name_warning(name, basic_path, file)
|
||||
# set ccache interface:
|
||||
compilator_ccache = ""
|
||||
if env.get_ccache() == True:
|
||||
compilator_ccache = "ccache"
|
||||
# create the command line befor requesting start:
|
||||
cmd = [
|
||||
compilator_ccache,
|
||||
target.xx,
|
||||
"-o", file_dst,
|
||||
target.arch,
|
||||
target.sysroot,
|
||||
target.global_include_cc]
|
||||
for view in ["export", "local"]:
|
||||
for type in ["c", "c++", "m", "mm"]:
|
||||
try:
|
||||
cmd.append(tools.add_prefix("-I",path[view][type]))
|
||||
except:
|
||||
pass
|
||||
for type in ["c", "c++", "m", "mm"]:
|
||||
try:
|
||||
cmd.append(tools.add_prefix("-I",depancy.path[type]))
|
||||
except:
|
||||
pass
|
||||
try:
|
||||
cmd.append(local_ref_on_builder_cpp.get_version_compilation_flags(flags, depancy.flags))
|
||||
except:
|
||||
pass
|
||||
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"]:
|
||||
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)
|
||||
# Create cmd line
|
||||
cmdLine=tools.list_to_str(cmd)
|
||||
# check the dependency for this file :
|
||||
if False==depend.need_re_build(file_dst, file_src, file_depend, file_cmd, cmdLine):
|
||||
return {"action":"add", "file":file_dst}
|
||||
tools.create_directory_of_file(file_dst)
|
||||
comment = ["m++", name, "<==", file]
|
||||
#process element
|
||||
multiprocess.run_in_pool(cmdLine, comment, file_cmd, store_output_file=file_warning)
|
||||
return {"action":"add", "file":file_dst}
|
||||
111
lutin/z_builder/lutinBuilder_s.py
Normal file
111
lutin/z_builder/lutinBuilder_s.py
Normal file
@ -0,0 +1,111 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
##
|
||||
## ASM builder
|
||||
##
|
||||
from lutin import multiprocess
|
||||
from lutin import tools
|
||||
from lutin import depend
|
||||
from lutin import env
|
||||
|
||||
##
|
||||
## Initialize the builder, if needed ... to get dependency between builder (for example)
|
||||
##
|
||||
def init():
|
||||
pass
|
||||
|
||||
##
|
||||
## Get the current builder type.
|
||||
## Return the type of builder
|
||||
##
|
||||
def get_type():
|
||||
return "compiler"
|
||||
|
||||
##
|
||||
## @brief Get builder input file type
|
||||
## @return List of extention supported
|
||||
##
|
||||
def get_input_type():
|
||||
return ["s", "S"]
|
||||
|
||||
##
|
||||
## @brief Get builder output file type
|
||||
## @return List of extention supported
|
||||
##
|
||||
def get_output_type():
|
||||
return ["o"]
|
||||
|
||||
##
|
||||
## @brief Get builder support multi-threading or not
|
||||
## @return True Multithreading supported
|
||||
## @return False Multithreading NOT supported
|
||||
##
|
||||
def get_support_multithreading():
|
||||
return True
|
||||
|
||||
##
|
||||
## @brief Commands for running gcc to compile a C file in object file.
|
||||
##
|
||||
def compile(file, binary, target, depancy, flags, path, name, basic_path, module_src):
|
||||
file_src = target.get_full_name_source(basic_path, file)
|
||||
file_cmd = target.get_full_name_cmd(name, basic_path, file)
|
||||
file_dst = target.get_full_name_destination(name, basic_path, file, get_output_type())
|
||||
file_depend = target.get_full_dependency(name, basic_path, file)
|
||||
file_warning = target.get_full_name_warning(name, basic_path, file)
|
||||
|
||||
# set ccache interface:
|
||||
compilator_ccache = ""
|
||||
if env.get_ccache() == True:
|
||||
compilator_ccache = "ccache"
|
||||
# create the command line befor requesting start:
|
||||
cmd = [
|
||||
compilator_ccache,
|
||||
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}
|
||||
9
lutin/z_system/__init__.py
Normal file
9
lutin/z_system/__init__.py
Normal file
@ -0,0 +1,9 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
117
lutin/z_system/lutinSystem_Android_ADMOD.py
Normal file
117
lutin/z_system/lutinSystem_Android_ADMOD.py
Normal file
@ -0,0 +1,117 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
from realog import debug
|
||||
from lutin import system
|
||||
from lutin import tools
|
||||
from lutin import env
|
||||
import os
|
||||
|
||||
class System(system.System):
|
||||
def __init__(self, target):
|
||||
system.System.__init__(self)
|
||||
# create some HELP:
|
||||
self.set_help("ADMOD: Android SDK ad-mod interface (auto-create interface for admod)\n")
|
||||
# todo : Check if present ...
|
||||
self.set_valid(True)
|
||||
# todo : create a searcher of the presence of the library:
|
||||
self.add_sources(target.path_sdk + "/extras/google/google_play_services/libproject/google-play-services_lib/libs/google-play-services.jar")
|
||||
self.add_action("PACKAGE", 10, "admod-auto-wrapper", tool_generate_main_java_class)
|
||||
|
||||
|
||||
|
||||
##################################################################
|
||||
##
|
||||
## Android specific section
|
||||
##
|
||||
##################################################################
|
||||
def tool_generate_main_java_class(target, module, package_name):
|
||||
if "ADMOD_ID" not in module.package_prop:
|
||||
debug.warning("Missing parameter ADMOD_ID wen you resuested dependency of ADMOD")
|
||||
return
|
||||
|
||||
module.package_prop["RIGHT"].append("INTERNET")
|
||||
module.package_prop["RIGHT"].append("ACCESS_NETWORK_STATE")
|
||||
|
||||
module.pkg_add("GENERATE_SECTION__IMPORT", [
|
||||
"import com.google.android.gms.ads.AdRequest;",
|
||||
"import com.google.android.gms.ads.AdSize;",
|
||||
"import com.google.android.gms.ads.AdView;",
|
||||
"import android.widget.LinearLayout;",
|
||||
"import android.widget.Button;"
|
||||
])
|
||||
module.pkg_add("GENERATE_SECTION__DECLARE", [
|
||||
"/** The view to show the ad. */",
|
||||
"private AdView adView;",
|
||||
"private LinearLayout mLayout = null;"
|
||||
])
|
||||
list_create = [
|
||||
"mLayout = new LinearLayout(this);"
|
||||
"mLayout.setOrientation(android.widget.LinearLayout.VERTICAL);",
|
||||
"LinearLayout.LayoutParams paramsWindows = new LinearLayout.LayoutParams(",
|
||||
" LinearLayout.LayoutParams.FILL_PARENT,",
|
||||
" LinearLayout.LayoutParams.FILL_PARENT);",
|
||||
"",
|
||||
"setContentView(mLayout, paramsWindows);",
|
||||
"",
|
||||
"LinearLayout.LayoutParams paramsAdds = new LinearLayout.LayoutParams(",
|
||||
" LinearLayout.LayoutParams.FILL_PARENT,",
|
||||
" LinearLayout.LayoutParams.WRAP_CONTENT);",
|
||||
"paramsAdds.weight = 0;",
|
||||
"",
|
||||
"LinearLayout.LayoutParams paramsGLView = new LinearLayout.LayoutParams(",
|
||||
" LinearLayout.LayoutParams.FILL_PARENT,",
|
||||
" LinearLayout.LayoutParams.FILL_PARENT);",
|
||||
"paramsGLView.weight = 1;",
|
||||
"paramsGLView.height = 0;",
|
||||
"",
|
||||
"mLayout.setGravity(android.view.Gravity.TOP);",
|
||||
"",
|
||||
"// Create an adds.",
|
||||
"adView = new AdView(this);",
|
||||
"adView.setAdSize(AdSize.SMART_BANNER);",
|
||||
"adView.setAdUnitId(\"" + module.package_prop["ADMOD_ID"] + "\");",
|
||||
"",
|
||||
"// Create an ad request. Check logcat output for the hashed device ID to get test ads on a physical device.",
|
||||
"AdRequest adRequest = new AdRequest.Builder()",
|
||||
" .addTestDevice(AdRequest.DEVICE_ID_EMULATOR)",
|
||||
" .build();",
|
||||
"",
|
||||
"// Add the AdView to the view hierarchy. The view will have no size until the ad is loaded."]
|
||||
if "ADMOD_POSITION" in module.package_prop \
|
||||
and module.package_prop["ADMOD_POSITION"] == "top":
|
||||
list_create.append("mLayout.addView(adView, paramsAdds);")
|
||||
list_create.append("mLayout.addView(mGLView, paramsGLView);")
|
||||
else:
|
||||
list_create.append("mLayout.addView(mGLView, paramsGLView);")
|
||||
list_create.append("mLayout.addView(adView, paramsAdds);")
|
||||
list_create.append("")
|
||||
list_create.append("// Start loading the ad in the background.")
|
||||
list_create.append("adView.loadAd(adRequest);")
|
||||
module.pkg_add("GENERATE_SECTION__ON_CREATE", list_create)
|
||||
module.pkg_add("GENERATE_SECTION__ON_RESUME", [
|
||||
"if (adView != null) {",
|
||||
" adView.resume();",
|
||||
"}"
|
||||
])
|
||||
module.pkg_add("GENERATE_SECTION__ON_PAUSE", [
|
||||
"if (adView != null) {",
|
||||
" adView.pause();",
|
||||
"}"
|
||||
])
|
||||
module.pkg_add("GENERATE_SECTION__ON_DESTROY", [
|
||||
"// Destroy the AdView.",
|
||||
"if (adView != null) {",
|
||||
" adView.destroy();",
|
||||
"}"
|
||||
])
|
||||
|
||||
|
||||
|
||||
32
lutin/z_system/lutinSystem_Android_SDK.py
Normal file
32
lutin/z_system/lutinSystem_Android_SDK.py
Normal file
@ -0,0 +1,32 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
from realog import debug
|
||||
from lutin import system
|
||||
from lutin import tools
|
||||
from lutin import env
|
||||
import os
|
||||
|
||||
class System(system.System):
|
||||
def __init__(self, target):
|
||||
system.System.__init__(self)
|
||||
# create some HELP:
|
||||
self.set_help("SDK: Android SDK basic interface java")
|
||||
# jar file:
|
||||
jar_file_path=os.path.join(target.path_sdk, "platforms", "android-" + str(target.board_id), "android.jar")
|
||||
# TODO : Check if the android sdk android.jar is present ...
|
||||
self.set_valid(True)
|
||||
# todo : create a searcher of the presence of the library:
|
||||
self.add_sources(jar_file_path)
|
||||
self.add_flag("link-lib", "dl")
|
||||
self.add_flag("link-lib", "log")
|
||||
self.add_flag("link-lib", "android")
|
||||
|
||||
|
||||
23
lutin/z_system/lutinSystem_Android_c.py
Normal file
23
lutin/z_system/lutinSystem_Android_c.py
Normal file
@ -0,0 +1,23 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
from realog 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)
|
||||
|
||||
77
lutin/z_system/lutinSystem_Android_cxx.py
Normal file
77
lutin/z_system/lutinSystem_Android_cxx.py
Normal file
@ -0,0 +1,77 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
from realog import debug
|
||||
from lutin import system
|
||||
from lutin import tools
|
||||
from lutin import env
|
||||
import os
|
||||
|
||||
class System(system.System):
|
||||
def __init__(self, target):
|
||||
system.System.__init__(self)
|
||||
# create some HELP:
|
||||
self.set_help("CXX: Generic C++ library")
|
||||
self.set_valid(True)
|
||||
if target.config["compilator"] == "clang":
|
||||
if target.board_id < 21:
|
||||
debug.error("Clang work only with the board wersion >= 21 : android 5.x.x")
|
||||
self.valid = False
|
||||
return
|
||||
self.add_flag("c++", "-D__STDCPP_LLVM__")
|
||||
# llvm is BSD-like licence
|
||||
self.add_path(os.path.join(target.path_ndk, "sources", "cxx-stl", "llvm-libc++", "libcxx", "include"))
|
||||
if target.type_arch == "armv5":
|
||||
stdCppBasePath = os.path.join(target.path_ndk, "sources", "cxx-stl", "llvm-libc++", "libcxx", "libs", "armeabi")
|
||||
self.add_path( os.path.join(stdCppBasePath, "include"))
|
||||
self.add_flag("link", os.path.join(stdCppBasePath, "libc++_static.a"))
|
||||
elif target.type_arch == "armv7":
|
||||
stdCppBasePath = os.path.join(target.path_ndk, "sources", "cxx-stl", "llvm-libc++", "libs", "armeabi-v7a")
|
||||
self.add_path( os.path.join(stdCppBasePath + "include"))
|
||||
self.add_flag("link", os.path.join(stdCppBasePath, "thumb", "libc++_static.a"))
|
||||
elif target.type_arch == "mips":
|
||||
stdCppBasePath = os.path.join(target.path_ndk, "sources", "cxx-stl", "llvm-libc++", "libcxx", "libs", "mips")
|
||||
self.add_path( os.path.join(stdCppBasePath + "include"))
|
||||
self.add_flag("link", os.path.join(stdCppBasePath + "libc++_static.a"))
|
||||
elif target.type_arch == "x86":
|
||||
stdCppBasePath = os.path.join(target.path_ndk, "sources", "cxx-stl", "llvm-libc++", "libcxx", "libs", "x86")
|
||||
self.add_path( os.path.join(stdCppBasePath, "include"))
|
||||
self.add_flag("link", os.path.join(stdCppBasePath, "libc++_static.a"))
|
||||
else:
|
||||
debug.warning("unknow architecture: '" + str(target.arch) + "'");
|
||||
else:
|
||||
self.add_flag("c++", "-D__STDCPP_GNU__")
|
||||
self.add_flag("c++-remove","-nostdlib")
|
||||
self.add_flag("need-libstdc++", True)
|
||||
# GPL v3 (+ exception link for gcc compilator)
|
||||
self.add_path(os.path.join(target.path_ndk, "sources", "cxx-stl", "gnu-libstdc++", target.compilator_version, "include"))
|
||||
if target.type_arch == "armv5":
|
||||
stdCppBasePath = os.path.join(target.path_ndk, "sources", "cxx-stl", "gnu-libstdc++", target.compilator_version, "libs", "armeabi")
|
||||
self.add_path( os.path.join(stdCppBasePath, "include"))
|
||||
self.add_flag("link", os.path.join(stdCppBasePath, "thumb", "libgnustl_static.a"))
|
||||
self.add_flag("link", os.path.join(stdCppBasePath, "thumb", "libsupc++.a"))
|
||||
elif target.type_arch == "armv7":
|
||||
stdCppBasePath = os.path.join(target.path_ndk, "sources", "cxx-stl", "gnu-libstdc++", target.compilator_version, "libs", "armeabi-v7a")
|
||||
self.add_path( os.path.join(stdCppBasePath, "include"))
|
||||
self.add_flag("link", os.path.join(stdCppBasePath, "thumb", "libgnustl_static.a"))
|
||||
self.add_flag("link", os.path.join(stdCppBasePath, "thumb", "libsupc++.a"))
|
||||
elif target.type_arch == "mips":
|
||||
stdCppBasePath = os.path.join(target.path_ndk, "sources", "cxx-stl", "gnu-libstdc++", target.compilator_version, "libs", "mips")
|
||||
self.add_path( os.path.join(stdCppBasePath, "include/"))
|
||||
self.add_flag("link", os.path.join(stdCppBasePath, "libgnustl_static.a"))
|
||||
self.add_flag("link", os.path.join(stdCppBasePath, "libsupc++.a"))
|
||||
elif target.type_arch == "x86":
|
||||
stdCppBasePath = os.path.join(target.path_ndk, "sources", "cxx-stl", "gnu-libstdc++", target.compilator_version, "libs", "x86")
|
||||
self.add_path( os.path.join(stdCppBasePath, "include"))
|
||||
self.add_flag("link", os.path.join(stdCppBasePath, "libgnustl_static.a"))
|
||||
self.add_flag("link", os.path.join(stdCppBasePath, "libsupc++.a"))
|
||||
else:
|
||||
debug.warning("unknow architecture: '" + str(target.arch) + "'");
|
||||
debug.warning("plop")
|
||||
27
lutin/z_system/lutinSystem_Android_m.py
Normal file
27
lutin/z_system/lutinSystem_Android_m.py
Normal file
@ -0,0 +1,27 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
from realog import debug
|
||||
from lutin import system
|
||||
from lutin import tools
|
||||
from lutin import env
|
||||
import os
|
||||
|
||||
class System(system.System):
|
||||
def __init__(self, target):
|
||||
system.System.__init__(self)
|
||||
# create some HELP:
|
||||
self.set_help("M : m library \n base of std libs (availlagle in GNU C lib and bionic")
|
||||
# No check ==> on the basic std libs:
|
||||
self.set_valid(True)
|
||||
# todo : create a searcher of the presence of the library:
|
||||
self.add_flag("link-lib", "m")
|
||||
|
||||
|
||||
36
lutin/z_system/lutinSystem_Android_opengl.py
Normal file
36
lutin/z_system/lutinSystem_Android_opengl.py
Normal file
@ -0,0 +1,36 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
from realog 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', "GLESv3")
|
||||
|
||||
|
||||
35
lutin/z_system/lutinSystem_Android_pthread.py
Normal file
35
lutin/z_system/lutinSystem_Android_pthread.py
Normal file
@ -0,0 +1,35 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
from realog 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'
|
||||
])
|
||||
|
||||
|
||||
29
lutin/z_system/lutinSystem_Android_z.py
Normal file
29
lutin/z_system/lutinSystem_Android_z.py
Normal file
@ -0,0 +1,29 @@
|
||||
#!/usr/bin/python
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
from realog import debug
|
||||
from lutin import system
|
||||
from lutin import tools
|
||||
from lutin import env
|
||||
import os
|
||||
|
||||
class System(system.System):
|
||||
def __init__(self, target):
|
||||
system.System.__init__(self)
|
||||
# create some HELP:
|
||||
self.set_help("Z : z library \n Can be install with the package:\n - zlib1g-dev")
|
||||
# check if the library exist:
|
||||
if not os.path.isfile("/usr/include/zlib.h"):
|
||||
# we did not find the library reqiested (just return) (automaticly set at false)
|
||||
return;
|
||||
self.set_valid(True)
|
||||
# todo : create a searcher of the presence of the library:
|
||||
self.add_flag("link-lib", "z")
|
||||
|
||||
|
||||
27
lutin/z_system/lutinSystem_IOs_CoreAudio.py
Normal file
27
lutin/z_system/lutinSystem_IOs_CoreAudio.py
Normal file
@ -0,0 +1,27 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
from realog import debug
|
||||
from lutin import system
|
||||
from lutin import tools
|
||||
from lutin import env
|
||||
import os
|
||||
|
||||
class System(system.System):
|
||||
def __init__(self, target):
|
||||
system.System.__init__(self)
|
||||
# create some HELP:
|
||||
self.set_help("CoreAudio : Ios interface for audio (all time present, just system interface)")
|
||||
self.set_valid(True)
|
||||
# todo : create a searcher of the presence of the library:
|
||||
self.add_flag("link", "-framework CoreAudio")
|
||||
self.add_flag("link", "-framework AudioToolbox")
|
||||
|
||||
|
||||
27
lutin/z_system/lutinSystem_IOs_CoreGraphics.py
Normal file
27
lutin/z_system/lutinSystem_IOs_CoreGraphics.py
Normal file
@ -0,0 +1,27 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
from realog 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")
|
||||
|
||||
|
||||
27
lutin/z_system/lutinSystem_IOs_Foundation.py
Normal file
27
lutin/z_system/lutinSystem_IOs_Foundation.py
Normal file
@ -0,0 +1,27 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
from realog 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")
|
||||
|
||||
|
||||
27
lutin/z_system/lutinSystem_IOs_GLKit.py
Normal file
27
lutin/z_system/lutinSystem_IOs_GLKit.py
Normal file
@ -0,0 +1,27 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
from realog 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")
|
||||
|
||||
|
||||
26
lutin/z_system/lutinSystem_IOs_QuartzCore.py
Normal file
26
lutin/z_system/lutinSystem_IOs_QuartzCore.py
Normal file
@ -0,0 +1,26 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
from realog 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")
|
||||
|
||||
|
||||
27
lutin/z_system/lutinSystem_IOs_UIKit.py
Normal file
27
lutin/z_system/lutinSystem_IOs_UIKit.py
Normal file
@ -0,0 +1,27 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
from realog 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")
|
||||
|
||||
|
||||
24
lutin/z_system/lutinSystem_IOs_c.py
Normal file
24
lutin/z_system/lutinSystem_IOs_c.py
Normal file
@ -0,0 +1,24 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
from realog 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)
|
||||
|
||||
28
lutin/z_system/lutinSystem_IOs_cxx.py
Normal file
28
lutin/z_system/lutinSystem_IOs_cxx.py
Normal file
@ -0,0 +1,28 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
from realog import debug
|
||||
from lutin import system
|
||||
from lutin import tools
|
||||
from lutin import env
|
||||
import os
|
||||
|
||||
class System(system.System):
|
||||
def __init__(self, target):
|
||||
system.System.__init__(self)
|
||||
# create some HELP:
|
||||
self.set_help("CXX: Generic C++ library")
|
||||
self.set_valid(True)
|
||||
# no check needed ==> just add this:
|
||||
self.add_flag("c++", "-D__STDCPP_LLVM__")
|
||||
self.add_flag("c++-remove", "-nostdlib")
|
||||
self.add_flag("need-libstdc++", True)
|
||||
|
||||
|
||||
27
lutin/z_system/lutinSystem_IOs_m.py
Normal file
27
lutin/z_system/lutinSystem_IOs_m.py
Normal file
@ -0,0 +1,27 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
from realog import debug
|
||||
from lutin import system
|
||||
from lutin import tools
|
||||
from lutin import env
|
||||
import os
|
||||
|
||||
class System(system.System):
|
||||
def __init__(self, target):
|
||||
system.System.__init__(self)
|
||||
# create some HELP:
|
||||
self.set_help("M : m library \n base of std libs (availlagle in GNU C lib and bionic")
|
||||
# No check ==> on the basic std libs:
|
||||
self.set_valid(True)
|
||||
# todo : create a searcher of the presence of the library:
|
||||
self.add_flag("link-lib", "m")
|
||||
|
||||
|
||||
30
lutin/z_system/lutinSystem_IOs_opengl.py
Normal file
30
lutin/z_system/lutinSystem_IOs_opengl.py
Normal file
@ -0,0 +1,30 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
from realog 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"])
|
||||
|
||||
|
||||
44
lutin/z_system/lutinSystem_IOs_pthread.py
Normal file
44
lutin/z_system/lutinSystem_IOs_pthread.py
Normal file
@ -0,0 +1,44 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
from realog 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/")
|
||||
"""
|
||||
|
||||
|
||||
|
||||
46
lutin/z_system/lutinSystem_Linux_SDL.py
Normal file
46
lutin/z_system/lutinSystem_Linux_SDL.py
Normal file
@ -0,0 +1,46 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
from realog 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)
|
||||
else:
|
||||
self.add_path("/usr/include/SDL/")
|
||||
|
||||
|
||||
35
lutin/z_system/lutinSystem_Linux_X11.py
Normal file
35
lutin/z_system/lutinSystem_Linux_X11.py
Normal file
@ -0,0 +1,35 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
from realog 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', 'Xv')
|
||||
self.add_flag('link-lib', 'Xt')
|
||||
self.add_flag('link-lib', 'X11')
|
||||
if env.get_isolate_system() == True:
|
||||
self.add_header_file([
|
||||
"/usr/include/X11/*"
|
||||
],
|
||||
destination_path="X11",
|
||||
recursive=True)
|
||||
|
||||
|
||||
46
lutin/z_system/lutinSystem_Linux_alsa.py
Normal file
46
lutin/z_system/lutinSystem_Linux_alsa.py
Normal file
@ -0,0 +1,46 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
from realog import debug
|
||||
from lutin import system
|
||||
from lutin import tools
|
||||
from lutin import env
|
||||
import os
|
||||
|
||||
class System(system.System):
|
||||
def __init__(self, target):
|
||||
system.System.__init__(self)
|
||||
# create some HELP:
|
||||
self.set_help("ALSA : Advanced Linux Sound Architecture\n Can be install with the package:\n - libasound2-dev")
|
||||
# check if the library exist:
|
||||
if not os.path.isfile("/usr/include/alsa/asoundlib.h") \
|
||||
and not os.path.isfile("/usr/include/dssi/alsa/asoundlib.h"):
|
||||
# we did not find the library reqiested (just return) (automaticly set at false)
|
||||
return;
|
||||
self.set_valid(True)
|
||||
if env.get_isolate_system() == False:
|
||||
self.add_flag("link-lib", "asound")
|
||||
else:
|
||||
self.add_flag("link-lib", "asound")
|
||||
self.add_header_file([
|
||||
"/usr/include/alsa/*",
|
||||
],
|
||||
destination_path="alsa",
|
||||
recursive=True)
|
||||
self.add_header_file([
|
||||
"/usr/include/dssi/*",
|
||||
],
|
||||
destination_path="dssi",
|
||||
recursive=True)
|
||||
self.add_depend([
|
||||
'c'
|
||||
])
|
||||
|
||||
|
||||
41
lutin/z_system/lutinSystem_Linux_arpa.py
Normal file
41
lutin/z_system/lutinSystem_Linux_arpa.py
Normal file
@ -0,0 +1,41 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
from realog 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'
|
||||
])
|
||||
|
||||
|
||||
|
||||
|
||||
45
lutin/z_system/lutinSystem_Linux_boost.py
Normal file
45
lutin/z_system/lutinSystem_Linux_boost.py
Normal file
@ -0,0 +1,45 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
from realog import debug
|
||||
from lutin import system
|
||||
from lutin import tools
|
||||
from lutin import env
|
||||
import os
|
||||
|
||||
class System(system.System):
|
||||
def __init__(self, target):
|
||||
system.System.__init__(self)
|
||||
# create some HELP:
|
||||
self.set_help("BOOST : Boost interface (need when we have not all c++ feature\n Can be install with the package:\n - libboost-all-dev")
|
||||
# check if the library exist:
|
||||
if not os.path.isfile("/usr/include/boost/chrono.hpp"):
|
||||
# we did not find the library reqiested (just return) (automaticly set at false)
|
||||
return;
|
||||
self.set_valid(True)
|
||||
if env.get_isolate_system() == False:
|
||||
# todo : create a searcher of the presence of the library:
|
||||
self.add_flag("link-lib", [
|
||||
"boost_system",
|
||||
"boost_thread",
|
||||
"boost_chrono"
|
||||
])
|
||||
else:
|
||||
self.add_header_file([
|
||||
"/usr/include/boost/*"
|
||||
],
|
||||
destination_path="boost",
|
||||
recursive=True)
|
||||
self.add_depend([
|
||||
'cxx'
|
||||
])
|
||||
|
||||
|
||||
|
||||
182
lutin/z_system/lutinSystem_Linux_c.py
Normal file
182
lutin/z_system/lutinSystem_Linux_c.py
Normal file
@ -0,0 +1,182 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
from realog 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
|
||||
self.add_flag("c-remove", "-nostdinc")
|
||||
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="",
|
||||
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)
|
||||
# remove dependency of libc to lib std c++ when compile with g++
|
||||
#self.add_header_file([
|
||||
# "stdarg.h",
|
||||
# ],
|
||||
# destination_path="",
|
||||
# recursive=True)
|
||||
self.add_flag("link", "-B/usr/lib")
|
||||
|
||||
50
lutin/z_system/lutinSystem_Linux_cxx.py
Normal file
50
lutin/z_system/lutinSystem_Linux_cxx.py
Normal file
@ -0,0 +1,50 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
from realog import debug
|
||||
from lutin import system
|
||||
from lutin import tools
|
||||
from lutin import multiprocess
|
||||
from lutin import env
|
||||
import os
|
||||
|
||||
class System(system.System):
|
||||
def __init__(self, target):
|
||||
system.System.__init__(self)
|
||||
# create some HELP:
|
||||
self.set_help("CXX: Generic C++ library")
|
||||
self.set_valid(True)
|
||||
# no check needed ==> just add this:
|
||||
self.add_depend([
|
||||
'c',
|
||||
'm',
|
||||
'pthread'
|
||||
])
|
||||
self.add_flag("c++", "-D__STDCPP_GNU__")
|
||||
if env.get_isolate_system() == False:
|
||||
self.add_flag("c++-remove", "-nostdlib")
|
||||
self.add_flag("need-libstdc++", True)
|
||||
else:
|
||||
self.add_flag("link-lib", "stdc++")
|
||||
compilator_gcc = "g++"
|
||||
if target.config["compilator-version"] != "":
|
||||
compilator_gcc = compilator_gcc + "-" + target.config["compilator-version"]
|
||||
|
||||
#get g++ compilation version :
|
||||
version_cpp = multiprocess.run_command_direct(compilator_gcc + " -dumpversion");
|
||||
if version_cpp == False:
|
||||
debug.error("Can not get the g++ version ...")
|
||||
|
||||
self.add_header_file([
|
||||
"/usr/include/c++/" + version_cpp + "/*"
|
||||
],
|
||||
recursive=True)
|
||||
|
||||
|
||||
36
lutin/z_system/lutinSystem_Linux_egl.py
Normal file
36
lutin/z_system/lutinSystem_Linux_egl.py
Normal file
@ -0,0 +1,36 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
from realog 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([
|
||||
'khr',
|
||||
])
|
||||
self.add_flag('link-lib', 'EGL')
|
||||
if env.get_isolate_system() == True:
|
||||
self.add_header_file([
|
||||
"/usr/include/EGL/*"
|
||||
],
|
||||
destination_path="EGL",
|
||||
recursive=True)
|
||||
|
||||
|
||||
|
||||
36
lutin/z_system/lutinSystem_Linux_gles2.py
Normal file
36
lutin/z_system/lutinSystem_Linux_gles2.py
Normal file
@ -0,0 +1,36 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
from realog 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([
|
||||
'opengl',
|
||||
])
|
||||
self.add_flag('link-lib', 'GLESv2')
|
||||
if env.get_isolate_system() == True:
|
||||
self.add_header_file([
|
||||
"/usr/include/GLES2/*"
|
||||
],
|
||||
destination_path="GLES2",
|
||||
recursive=True)
|
||||
|
||||
|
||||
|
||||
39
lutin/z_system/lutinSystem_Linux_jack.py
Normal file
39
lutin/z_system/lutinSystem_Linux_jack.py
Normal file
@ -0,0 +1,39 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
from realog import debug
|
||||
from lutin import system
|
||||
from lutin import tools
|
||||
from lutin import env
|
||||
import os
|
||||
|
||||
class System(system.System):
|
||||
def __init__(self, target):
|
||||
system.System.__init__(self)
|
||||
# create some HELP:
|
||||
self.set_help("JACK : Jack Low-Latency Audio Server\n Can be install with the package:\n - libjack-jackd2-dev (new)\n - libjack-dev (old)")
|
||||
# check if the library exist:
|
||||
if not os.path.isfile("/usr/include/jack/jack.h"):
|
||||
# we did not find the library reqiested (just return) (automaticly set at false)
|
||||
return;
|
||||
self.set_valid(True)
|
||||
self.add_depend([
|
||||
'uuid',
|
||||
'c'
|
||||
])
|
||||
self.add_flag("link-lib", "jack")
|
||||
if env.get_isolate_system() == True:
|
||||
self.add_header_file([
|
||||
"/usr/include/jack/*",
|
||||
],
|
||||
destination_path="jack",
|
||||
recursive=True)
|
||||
|
||||
|
||||
36
lutin/z_system/lutinSystem_Linux_khr.py
Normal file
36
lutin/z_system/lutinSystem_Linux_khr.py
Normal file
@ -0,0 +1,36 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
from realog 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-lib', 'wayland-egl')
|
||||
if env.get_isolate_system() == True:
|
||||
self.add_header_file([
|
||||
"/usr/include/KHR/*"
|
||||
],
|
||||
destination_path="KHR",
|
||||
recursive=True)
|
||||
|
||||
|
||||
|
||||
37
lutin/z_system/lutinSystem_Linux_m.py
Normal file
37
lutin/z_system/lutinSystem_Linux_m.py
Normal file
@ -0,0 +1,37 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
from realog import debug
|
||||
from lutin import system
|
||||
from lutin import tools
|
||||
from lutin import env
|
||||
import os
|
||||
|
||||
class System(system.System):
|
||||
def __init__(self, target):
|
||||
system.System.__init__(self)
|
||||
# create some HELP:
|
||||
self.set_help("M : m library \n base of std libs (availlagle in GNU C lib and bionic")
|
||||
# No check ==> on the basic std libs:
|
||||
self.set_valid(True)
|
||||
# todo : create a searcher of the presence of the library:
|
||||
self.add_flag("link-lib", "m")
|
||||
self.add_depend([
|
||||
'c'
|
||||
])
|
||||
if env.get_isolate_system() == True:
|
||||
self.add_header_file([
|
||||
"/usr/include/math.h"
|
||||
],
|
||||
clip_path="/usr/include",
|
||||
recursive=False)
|
||||
|
||||
|
||||
|
||||
46
lutin/z_system/lutinSystem_Linux_mysql.py
Normal file
46
lutin/z_system/lutinSystem_Linux_mysql.py
Normal file
@ -0,0 +1,46 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
from realog 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("mysql: My sql interface (microsoft) or mariadB interface.")
|
||||
# check if the library exist:
|
||||
if not os.path.isfile("/usr/include/mysql/mysql.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", "mysqlclient")
|
||||
self.add_flag("link-lib", "ssl")
|
||||
self.add_depend([
|
||||
'pthread',
|
||||
'z',
|
||||
'm',
|
||||
#'ssl',
|
||||
'crypto'
|
||||
])
|
||||
if env.get_isolate_system() == True:
|
||||
self.add_header_file([
|
||||
"/usr/include/mysql/"
|
||||
],
|
||||
clip_path="/usr/include/mysql/")
|
||||
else:
|
||||
self.add_path("/usr/include/mysql/");
|
||||
|
||||
|
||||
|
||||
36
lutin/z_system/lutinSystem_Linux_opengl.py
Normal file
36
lutin/z_system/lutinSystem_Linux_opengl.py
Normal file
@ -0,0 +1,36 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
from realog 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-lib', 'GL')
|
||||
if env.get_isolate_system() == True:
|
||||
self.add_header_file([
|
||||
"/usr/include/GL/*"
|
||||
],
|
||||
destination_path="GL",
|
||||
recursive=True)
|
||||
|
||||
|
||||
|
||||
32
lutin/z_system/lutinSystem_Linux_oss.py
Normal file
32
lutin/z_system/lutinSystem_Linux_oss.py
Normal file
@ -0,0 +1,32 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
from realog 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("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.set_valid(True)
|
||||
# todo : create a searcher of the presence of the library:
|
||||
self.add_flag("link-lib", "oss")
|
||||
"""
|
||||
|
||||
|
||||
39
lutin/z_system/lutinSystem_Linux_pthread.py
Normal file
39
lutin/z_system/lutinSystem_Linux_pthread.py
Normal file
@ -0,0 +1,39 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
from realog 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/")
|
||||
|
||||
|
||||
81
lutin/z_system/lutinSystem_Linux_pulse.py
Normal file
81
lutin/z_system/lutinSystem_Linux_pulse.py
Normal file
@ -0,0 +1,81 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
from realog 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() (\"" # " #corect edn error parsing
|
||||
version = None
|
||||
for line in lines:
|
||||
if line[:len(patern)] == patern:
|
||||
#Find the version line
|
||||
offset = len(patern)
|
||||
version = ""
|
||||
while offset < len(line) \
|
||||
and line[offset] != '.':
|
||||
version += line[offset]
|
||||
offset += 1
|
||||
offset += 1
|
||||
version2 = ""
|
||||
while offset < len(line) \
|
||||
and line[offset] != '.':
|
||||
version2 += line[offset]
|
||||
offset += 1
|
||||
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", [
|
||||
"-l/lib/pulseaudio/libpulsecommon-" + version + ".0.so"
|
||||
])
|
||||
"""
|
||||
self.add_flag("link-lib", [
|
||||
"pulsecommon-" + version + ".0",
|
||||
"pulse-mainloop-glib",
|
||||
"pulse-simple",
|
||||
"pulse"
|
||||
])
|
||||
self.add_flag("link", "-L/usr/lib/pulseaudio")
|
||||
self.add_flag("link", "-Wl,-R/usr/lib/pulseaudio")
|
||||
self.add_header_file([
|
||||
"/usr/include/pulse/*",
|
||||
],
|
||||
destination_path="pulse",
|
||||
recursive=True)
|
||||
|
||||
|
||||
38
lutin/z_system/lutinSystem_Linux_rpc.py
Normal file
38
lutin/z_system/lutinSystem_Linux_rpc.py
Normal file
@ -0,0 +1,38 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
from realog 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)
|
||||
|
||||
|
||||
|
||||
|
||||
39
lutin/z_system/lutinSystem_Linux_uuid.py
Normal file
39
lutin/z_system/lutinSystem_Linux_uuid.py
Normal file
@ -0,0 +1,39 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
from realog 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)
|
||||
|
||||
|
||||
42
lutin/z_system/lutinSystem_Linux_va.py
Normal file
42
lutin/z_system/lutinSystem_Linux_va.py
Normal file
@ -0,0 +1,42 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
##
|
||||
## @author Edouard DUPIN
|
||||
##
|
||||
## @copyright 2012, Edouard DUPIN, all right reserved
|
||||
##
|
||||
## @license MPL v2.0 (see license file)
|
||||
##
|
||||
|
||||
from realog 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)
|
||||
|
||||
|
||||
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
x
Reference in New Issue
Block a user