Open-Harbor/osrm-backend
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 3 Wiki Activity

Merge pull request #3119 from Project-OSRM/masonize

Browse Source 
Masonize
This commit is contained in:
Dane Springmeyer 2016-10-28 13:39:37 -07:00 committed by GitHub
commit 9435254661
711 changed files with 30157 additions and 67 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
.gitignore vendored
View File

@ -1,3 +1,8 @@
# mason #
#########
/.mason
/mason_packages
# pre compiled dependencies #
#############################
osrm-deps

17
.travis.yml
View File

@ -56,6 +56,14 @@ matrix:
env: CCOMPILER='clang' CXXCOMPILER='clang++' BUILD_TYPE='Debug' JOBS=1 CUCUMBER_TIMEOUT=60000
# Release Builds
- os: linux
compiler: "mason-release"
addons:
apt:
sources: ['ubuntu-toolchain-r-test']
packages: ['libstdc++-5-dev', 'ccache']
env: BUILD_TYPE='Release' ENABLE_MASON=ON
- os: linux
compiler: "gcc-6-release"
addons: &gcc6
@ -131,7 +139,7 @@ install:
fi
- mkdir build && pushd build
- export CC=${CCOMPILER} CXX=${CXXCOMPILER}
- cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DBUILD_SHARED_LIBS=${BUILD_SHARED_LIBS:-OFF} -DENABLE_COVERAGE=${ENABLE_COVERAGE:-OFF} -DENABLE_SANITIZER=${ENABLE_SANITIZER:-OFF} -DBUILD_TOOLS=ON -DBUILD_COMPONENTS=${BUILD_COMPONENTS:-OFF} -DENABLE_CCACHE=ON
- cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DENABLE_MASON=${ENABLE_MASON:-OFF} -DBUILD_SHARED_LIBS=${BUILD_SHARED_LIBS:-OFF} -DENABLE_COVERAGE=${ENABLE_COVERAGE:-OFF} -DENABLE_SANITIZER=${ENABLE_SANITIZER:-OFF} -DBUILD_TOOLS=ON -DBUILD_COMPONENTS=${BUILD_COMPONENTS:-OFF} -DENABLE_CCACHE=ON
- echo "travis_fold:start:MAKE"
- make osrm-extract --jobs=3
- make --jobs=${JOBS}
@ -145,6 +153,13 @@ install:
sudo ldconfig
fi
- popd
- |
if [[ ${ENABLE_MASON:-OFF} == 'ON' ]]; then
# for mason builds we need to point the example
# at the clang++ installed by the CMakeLists.txt automatically
export CXX=$(./third_party/mason/mason prefix clang++ 3.8.1)/bin/clang++
export CC=$(./third_party/mason/mason prefix clang++ 3.8.1)/bin/clang
fi
- mkdir example/build && pushd example/build
- cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE}
- make

254
CMakeLists.txt
View File

@ -7,6 +7,41 @@ Please create a directory and run cmake from there, passing the path to this sou
This process created the file `CMakeCache.txt' and the directory `CMakeFiles'. Please delete them.")
endif()
option(ENABLE_MASON "Use mason for dependencies" OFF)
option(ENABLE_CCACHE "Speed up incremental rebuilds via ccache" ON)
option(BUILD_TOOLS "Build OSRM tools" OFF)
option(BUILD_COMPONENTS "Build osrm-components" OFF)
option(ENABLE_ASSERTIONS "Use assertions in release mode" OFF)
option(ENABLE_COVERAGE "Build with coverage instrumentalisation" OFF)
option(ENABLE_SANITIZER "Use memory sanitizer for Debug build" OFF)
option(ENABLE_LTO "Use LTO if available" ON)
option(ENABLE_FUZZING "Fuzz testing using LLVM's libFuzzer" OFF)
option(ENABLE_GOLD_LINKER "Use GNU gold linker if available" ON)
if(ENABLE_MASON)
# versions in use
set(MASON_CLANG_VERSION "3.8.1")
set(MASON_BOOST_VERSION "1.61.0")
set(MASON_STXXL_VERSION "1.4.1")
set(MASON_EXPAT_VERSION "2.1.1")
set(MASON_LUA_VERSION "5.2.4")
set(MASON_LUABIND_VERSION "e414c57bcb687bb3091b7c55bbff6947f052e46b")
set(MASON_BZIP2_VERSION "1.0.6")
set(MASON_TBB_VERSION "43_20150316")
set(MASON_CCACHE_VERSION "3.3.1")
message(STATUS "Enabling mason")
set(MASON_COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/third_party/mason/mason)
include(${CMAKE_CURRENT_SOURCE_DIR}/third_party/mason/mason.cmake)
if(NOT CMAKE_CXX_COMPILER)
mason_use(clang++ VERSION ${MASON_CLANG_VERSION})
message(STATUS "Setting compiler to clang++ ${MASON_CLANG_VERSION} (via mason) ${MASON_PACKAGE_clang++_PREFIX}/bin/clang++")
set(CMAKE_CXX_COMPILER "${MASON_PACKAGE_clang++_PREFIX}/bin/clang++")
set(CMAKE_C_COMPILER "${MASON_PACKAGE_clang++_PREFIX}/bin/clang")
endif()
endif()
project(OSRM C CXX)
set(OSRM_VERSION_MAJOR 5)
set(OSRM_VERSION_MINOR 4)
@ -46,16 +81,6 @@ if(WIN32 AND MSVC_VERSION LESS 1900)
message(FATAL_ERROR "Building with Microsoft compiler needs Latest Visual Studio 2015 (Community or better)")
endif()
option(ENABLE_CCACHE "Speed up incremental rebuilds via ccache" ON)
option(BUILD_TOOLS "Build OSRM tools" OFF)
option(BUILD_COMPONENTS "Build osrm-components" OFF)
option(ENABLE_ASSERTIONS "Use assertions in release mode" OFF)
option(ENABLE_COVERAGE "Build with coverage instrumentalisation" OFF)
option(ENABLE_SANITIZER "Use memory sanitizer for Debug build" OFF)
option(ENABLE_LTO "Use LTO if available" ON)
option(ENABLE_FUZZING "Fuzz testing using LLVM's libFuzzer" OFF)
option(ENABLE_GOLD_LINKER "Use GNU gold linker if available" ON)
include_directories(BEFORE ${CMAKE_CURRENT_BINARY_DIR}/include/)
include_directories(BEFORE ${CMAKE_CURRENT_SOURCE_DIR}/include/)
include_directories(SYSTEM ${CMAKE_CURRENT_SOURCE_DIR}/third_party/)
@ -193,6 +218,11 @@ if(CMAKE_BUILD_TYPE MATCHES Release OR CMAKE_BUILD_TYPE MATCHES MinRelSize OR CM
endif()
endif()
if (ENABLE_MASON AND (LTO_WORKS OR ENABLE_GOLD_LINKER))
message(WARNING "ENABLE_MASON and ENABLE_LTO/ENABLE_GOLD_LINKER may not work on all linux systems currently")
message(WARNING "For more details see: https://github.com/Project-OSRM/osrm-backend/issues/3202")
endif()
set(MAYBE_COVERAGE_LIBRARIES "")
if (ENABLE_COVERAGE)
if (NOT CMAKE_BUILD_TYPE MATCHES "Debug")
@ -283,43 +313,164 @@ if(UNIX AND NOT APPLE)
set(MAYBE_RT_LIBRARY -lrt)
endif()
list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/third_party/libosmium/cmake")
set(OSMIUM_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/libosmium/include")
find_package(Osmium REQUIRED COMPONENTS io)
add_dependency_includes(${OSMIUM_INCLUDE_DIR})
# Disallow deprecated protozero APIs
add_definitions(-DPROTOZERO_STRICT_API)
find_package(Boost 1.49.0 REQUIRED COMPONENTS ${BOOST_COMPONENTS})
find_package(Threads REQUIRED)
# if mason is enabled no find_package calls are made
# to ensure that we are only compiling and linking against
# fully portable mason packages
if(ENABLE_MASON)
message(STATUS "Installing dependencies via mason")
set(Boost_USE_STATIC_LIBS ON)
mason_use(boost VERSION ${MASON_BOOST_VERSION} HEADER_ONLY)
add_dependency_includes(${MASON_PACKAGE_boost_INCLUDE_DIRS})
mason_use(boost_libfilesystem VERSION ${MASON_BOOST_VERSION})
set(Boost_FILESYSTEM_LIBRARY ${MASON_PACKAGE_boost_libfilesystem_STATIC_LIBS})
mason_use(boost_libiostreams VERSION ${MASON_BOOST_VERSION})
set(Boost_IOSTREAMS_LIBRARY ${MASON_PACKAGE_boost_libiostreams_STATIC_LIBS})
mason_use(boost_libprogram_options VERSION ${MASON_BOOST_VERSION})
set(Boost_PROGRAM_OPTIONS_LIBRARY ${MASON_PACKAGE_boost_libprogram_options_STATIC_LIBS})
mason_use(boost_libregex VERSION ${MASON_BOOST_VERSION})
set(Boost_REGEX_LIBRARY ${MASON_PACKAGE_boost_libregex_STATIC_LIBS})
mason_use(boost_libtest VERSION ${MASON_BOOST_VERSION})
set(Boost_UNIT_TEST_FRAMEWORK_LIBRARY ${MASON_PACKAGE_boost_libtest_STATIC_LIBS})
mason_use(boost_libdate_time VERSION ${MASON_BOOST_VERSION})
set(Boost_DATE_TIME_LIBRARY ${MASON_PACKAGE_boost_libdate_time_STATIC_LIBS})
mason_use(boost_libthread VERSION ${MASON_BOOST_VERSION})
set(Boost_THREAD_LIBRARY ${MASON_PACKAGE_boost_libthread_STATIC_LIBS})
mason_use(boost_libsystem VERSION ${MASON_BOOST_VERSION})
set(Boost_SYSTEM_LIBRARY ${MASON_PACKAGE_boost_libsystem_STATIC_LIBS})
mason_use(stxxl VERSION ${MASON_STXXL_VERSION})
add_dependency_includes(${MASON_PACKAGE_stxxl_INCLUDE_DIRS})
set(STXXL_LIBRARY ${MASON_PACKAGE_stxxl_STATIC_LIBS})
mason_use(expat VERSION ${MASON_EXPAT_VERSION})
add_dependency_includes(${MASON_PACKAGE_expat_INCLUDE_DIRS})
set(EXPAT_LIBRARIES ${MASON_PACKAGE_expat_STATIC_LIBS})
mason_use(lua VERSION ${MASON_LUA_VERSION})
add_dependency_includes(${MASON_PACKAGE_lua_INCLUDE_DIRS})
set(USED_LUA_LIBRARIES ${MASON_PACKAGE_lua_STATIC_LIBS})
mason_use(luabind_lua524 VERSION ${MASON_LUABIND_VERSION})
add_dependency_includes(${MASON_PACKAGE_luabind_lua524_INCLUDE_DIRS})
set(LUABIND_LIBRARY ${MASON_PACKAGE_luabind_lua524_STATIC_LIBS})
mason_use(bzip2 VERSION ${MASON_BZIP2_VERSION})
add_dependency_includes(${MASON_PACKAGE_bzip2_INCLUDE_DIRS})
set(BZIP2_LIBRARIES ${MASON_PACKAGE_bzip2_STATIC_LIBS})
mason_use(tbb VERSION ${MASON_TBB_VERSION})
add_dependency_includes(${MASON_PACKAGE_tbb_INCLUDE_DIRS})
set(TBB_LIBRARIES ${MASON_PACKAGE_tbb_LDFLAGS})
if(NOT MASON_PACKAGE_tbb_LIBRARY_DIRS)
message(FATAL_ERROR "MASON_PACKAGE_tbb_LIBRARY_DIRS is empty, rpath will not work")
endif()
foreach(libpath ${MASON_PACKAGE_tbb_LIBRARY_DIRS})
if(UNIX AND NOT APPLE)
set(LINKER_FLAGS "-Wl,-rpath,${libpath}")
elseif(APPLE)
set(LINKER_FLAGS "-Wl,-rpath, -Wl,${libpath}")
endif()
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${LINKER_FLAGS}")
set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${LINKER_FLAGS}")
set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${LINKER_FLAGS}")
file(GLOB TBBGlob ${libpath}/*.*)
install(FILES ${TBBGlob} DESTINATION lib)
endforeach()
if(BUILD_COMPONENTS)
message(FATAL_ERROR "BUILD_COMPONENTS is not supported with ENABLE_MASON")
endif()
# current mason packages target -D_GLIBCXX_USE_CXX11_ABI=0
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_GLIBCXX_USE_CXX11_ABI=0")
if(ENABLE_CCACHE)
mason_use(ccache VERSION ${MASON_CCACHE_VERSION})
message(STATUS "Setting ccache to ccache ${MASON_CCACHE_VERSION} (via mason) ${MASON_PACKAGE_ccache_PREFIX}/bin/ccache")
message(STATUS "Using ccache to speed up incremental builds")
set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ${MASON_PACKAGE_ccache_PREFIX}/bin/ccache)
set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK ${MASON_PACKAGE_ccache_PREFIX}/bin/ccache)
set(ENV{CCACHE_CPP2} "true")
endif()
else()
find_package(Boost 1.49.0 REQUIRED COMPONENTS ${BOOST_COMPONENTS})
add_dependency_includes(${Boost_INCLUDE_DIRS})
find_package(TBB REQUIRED)
add_dependency_includes(${TBB_INCLUDE_DIR})
if(WIN32 AND CMAKE_BUILD_TYPE MATCHES Debug)
set(TBB_LIBRARIES ${TBB_DEBUG_LIBRARIES})
endif()
find_package(Luabind REQUIRED)
add_dependency_includes(${LUABIND_INCLUDE_DIR})
set(USED_LUA_LIBRARIES ${LUA_LIBRARY})
add_dependency_includes(${LUA_INCLUDE_DIR})
find_package(EXPAT REQUIRED)
add_dependency_includes(${EXPAT_INCLUDE_DIRS})
find_package(STXXL REQUIRED)
add_dependency_includes(${STXXL_INCLUDE_DIR})
find_package(BZip2 REQUIRED)
add_dependency_includes(${BZIP2_INCLUDE_DIR})
if(BUILD_COMPONENTS)
find_package(GDAL)
endif()
# add a target to generate API documentation with Doxygen
find_package(Doxygen)
if(DOXYGEN_FOUND)
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile.in ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile @ONLY)
add_custom_target(doc
${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
COMMENT "Generating API documentation with Doxygen" VERBATIM
)
endif()
# prefix compilation with ccache by default if available and on clang or gcc
if(ENABLE_CCACHE AND (${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang" OR ${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU"))
find_program(CCACHE_FOUND ccache)
if(CCACHE_FOUND)
message(STATUS "Using ccache to speed up incremental builds")
set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ccache)
set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK ccache)
set(ENV{CCACHE_CPP2} "true")
endif()
endif()
endif()
# even with mason builds we want to link to system zlib
# to ensure that osrm binaries play well with other binaries like nodejs
find_package(ZLIB REQUIRED)
add_dependency_includes(${ZLIB_INCLUDE_DIRS})
include_directories(SYSTEM ${CMAKE_CURRENT_SOURCE_DIR}/third_party/libosmium/include)
if(NOT WIN32 AND NOT Boost_USE_STATIC_LIBS)
add_dependency_defines(-DBOOST_TEST_DYN_LINK)
endif()
if(NOT WIN32 AND NOT Boost_USE_STATIC_LIBS)
add_dependency_defines(-DBOOST_TEST_DYN_LINK)
endif()
add_dependency_defines(-DBOOST_SPIRIT_USE_PHOENIX_V3)
add_dependency_defines(-DBOOST_RESULT_OF_USE_DECLTYPE)
add_dependency_defines(-DBOOST_FILESYSTEM_NO_DEPRECATED)
add_dependency_includes(${Boost_INCLUDE_DIRS})
find_package(Threads REQUIRED)
find_package(TBB REQUIRED)
add_dependency_includes(${TBB_INCLUDE_DIR})
if(WIN32 AND CMAKE_BUILD_TYPE MATCHES Debug)
set(TBB_LIBRARIES ${TBB_DEBUG_LIBRARIES})
endif()
find_package(Luabind REQUIRED)
add_dependency_includes(${LUABIND_INCLUDE_DIR})
set(USED_LUA_LIBRARIES ${LUA_LIBRARY})
add_dependency_includes(${LUA_INCLUDE_DIR})
find_package(EXPAT REQUIRED)
add_dependency_includes(${EXPAT_INCLUDE_DIRS})
find_package(STXXL REQUIRED)
add_dependency_includes(${STXXL_INCLUDE_DIR})
set(OpenMP_FIND_QUIETLY ON)
find_package(OpenMP)
@ -328,12 +479,6 @@ if(OPENMP_FOUND)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
endif()
find_package(BZip2 REQUIRED)
add_dependency_includes(${BZIP2_INCLUDE_DIR})
find_package(ZLIB REQUIRED)
add_dependency_includes(${ZLIB_INCLUDE_DIRS})
add_definitions(${OSRM_DEFINES})
include_directories(SYSTEM ${OSRM_INCLUDE_PATHS})
@ -404,7 +549,6 @@ target_link_libraries(osrm_extract ${EXTRACTOR_LIBRARIES})
target_link_libraries(osrm_store ${STORAGE_LIBRARIES})
if(BUILD_COMPONENTS)
find_package(GDAL)
if(GDAL_FOUND)
add_executable(osrm-components src/tools/components.cpp $<TARGET_OBJECTS:UTIL>)
target_link_libraries(osrm-components ${TBB_LIBRARIES})
@ -492,28 +636,6 @@ JOIN("-I${OSRM_INCLUDE_PATHS}" " -I" OSRM_INCLUDE_PATHS_STRING)
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/pkgconfig.in libosrm.pc @ONLY)
install(FILES ${PROJECT_BINARY_DIR}/libosrm.pc DESTINATION lib/pkgconfig)
# add a target to generate API documentation with Doxygen
find_package(Doxygen)
if(DOXYGEN_FOUND)
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile.in ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile @ONLY)
add_custom_target(doc
${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
COMMENT "Generating API documentation with Doxygen" VERBATIM
)
endif()
# prefix compilation with ccache by default if available and on clang or gcc
if(ENABLE_CCACHE AND (${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang" OR ${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU"))
find_program(CCACHE_FOUND ccache)
if(CCACHE_FOUND)
message(STATUS "Using ccache to speed up incremental builds")
set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ccache)
set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK ccache)
set(ENV{CCACHE_CPP2} "true")
endif()
endif()
# uninstall target
configure_file(
"${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake_uninstall.cmake.in"

6
scripts/update_dependencies.sh
View File

@ -15,11 +15,16 @@ OSMIUM_TAG=v2.9.0
VARIANT_REPO=https://github.com/mapbox/variant.git
VARIANT_TAG=v1.1.0
MASON_REPO=https://github.com/mapbox/mason.git
MASON_TAG=v0.1.0
VARIANT_LATEST=$(curl https://api.github.com/repos/mapbox/variant/releases/latest | jq ".tag_name")
OSMIUM_LATEST=$(curl https://api.github.com/repos/osmcode/libosmium/releases/latest | jq ".tag_name")
MASON_LATEST=$(curl https://api.github.com/repos/mapbox/mason/releases/latest | jq ".tag_name")
echo "Latest osmium release is $OSMIUM_LATEST, pulling in \"$OSMIUM_TAG\""
echo "Latest variant release is $VARIANT_LATEST, pulling in \"$VARIANT_TAG\""
echo "Latest mason release is $MASON_LATEST, pulling in \"$MASON_TAG\""
read -p "Looks good? (Y/n) " ok
@ -27,4 +32,5 @@ if [[ $ok =~ [yY] ]]
then
git subtree pull -P third_party/libosmium/ $OSMIUM_REPO $OSMIUM_TAG --squash
git subtree pull -P third_party/variant/ $VARIANT_REPO $VARIANT_TAG --squash
git subtree pull -P third_party/mason/ $MASON_REPO $MASON_TAG --squash
fi

1
third_party/mason/.gitignore vendored Normal file
View File

@ -0,0 +1 @@
mason_packages

23
third_party/mason/.travis.yml vendored Normal file
View File

@ -0,0 +1,23 @@
language: generic
matrix:
include:
- os: osx
osx_image: xcode8
compiler: clang
- os: linux
sudo: false
install:
- |
if [[ ${MASON_PLATFORM:-unset} == 'unset' ]] || [[ ${MASON_PLATFORM} == 'osx' ]] || [[ ${MASON_PLATFORM} == 'linux' ]]; then
echo "Installing clang for OSX/Linux via 'install' target"
source utils/toolchain.sh
which ${CC}
${CC} -v
which ${CXX}
${CXX} -v
fi
script:
- ./test/all.sh

3
third_party/mason/CHANGELOG.md vendored Normal file
View File

@ -0,0 +1,3 @@
## 0.1.0
- First versioned release

379
third_party/mason/README.md vendored Normal file
View File

@ -0,0 +1,379 @@
# Mason
Mason can compile C/C++ code, publish packages to S3, and install those packages via binaries.
Mason does all its work locally inside `./mason_packages` and therefore does not require privileges for, or conflict with, system-wide packages.
Mason works on both OS X and Linux.
[![Build Status](https://travis-ci.org/mapbox/mason.svg?branch=master)](https://travis-ci.org/mapbox/mason)
### Goals
Mason is a package manager designed for developers who package standalone applications and who need complete control over dependency versions.
Because Mason is developed by Mapbox the default S3 bucket and set of available packages are driven by Mapbox developers. For other developers: 1) fork Mason and ideally rename it to something like `mason-{yourorg}`, 2) configure it against your own s3 bucket, and 3) go ahead an publish your own packages to an S3 bucket of your creation.
### Comparisons
Mason is like [npm](https://github.com/npm/npm) because it installs packages in the current working directory (`./mason_packages`) rather than globally.
Mason is like [homebrew](http://brew.sh/) because it requires no use of `sudo` to install packages.
Mason is like linux package managers like `apt-get` or `yum` because it works on linux.
Mason is unlike all of the above package managers because:
- Mason runs on both Linux and OS X and creates a single set of binaries that work on >= OS X 10.8 and >= Ubuntu Precise (rather than building binaries per version).
- Mason strongly prefers static libraries over shared libraries
- Mason has zero understanding of dependency trees: it leaves complete control to the developer for how packages relate.
- Mason does not depend on any specific runtime language (like python, node.js or ruby). It is a just a few bash scripts.
- Mason depends on [travis.ci](https://travis-ci.org) for creating and publishing binaries.
## Installation
#### Symlink
You need to install Mason to your user directory into `~/.mason`.
```bash
git clone -b master --single-branch https://github.com/mapbox/mason.git ~/.mason
sudo ln -s ~/.mason/mason /usr/local/bin/mason
```
The second line is optional.
#### Submodule
Mason can be added a submodule to your repository instead of creating a global symlink. This is helpful for other contributors to get set up quickly. Make sure to include the final part of the following command `.mason/` so your submodule path has the leading `.` instead of just being `mason/`.
```bash
git submodule add git@github.com:mapbox/mason.git .mason/
```
This will append a few lines to your `.gitmodules` file. Make sure to change the `url` parameter to `https` instead of `git@github` ssh protocol.
```
[submodule ".mason"]
path = .mason
url = https://github.com/mapbox/mason.git
```
Update your `Makefile` to point to the mason scripts and provide an installation script for the necessary dependencies. The following installs two Mason packages with the `make mason_packages` command.
```Make
MASON ?= .mason/mason
$(MASON):
git submodule update --init
mason_packages: $(MASON)
$(MASON) install geometry.hpp 0.7.0
$(MASON) install variant 1.1.0
```
## Usage
Most commands are structured like this:
```bash
mason <command> <library> <version>
```
The `command` can be one of the following
* `install`: Installs the specified library/version
* `remove`: Removes the specified library/version
* `build`: Forces a build from source (= skip pre-built binary detection)
* `publish`: Uploads the built binaries to the S3 bucket
* `prefix`: Prints the absolute path to the library installation directory
* `version`: Prints the actual version of the library (only useful when version is `system`)
* `cflags`: Prints C/C++ compiler flags
* `ldflags`: Prints linker flags
* `link`: Creates symlinks for packages in `mason_packages/.link`
* `trigger`: Trigger a build and publish operation on Travis CI
### `install`
```bash
$ mason install libuv 0.11.29
* Downloading binary package osx-10.10/libuv/0.11.29.tar.gz...
######################################################################## 100.0%
* Installed binary package at /Users/user/mason_packages/osx-10.10/libuv/0.11.29
```
Installs [libuv](https://github.com/joyent/libuv) into the current folder in the `mason_packages` directory. Libraries are versioned by platform and version number, so you can install several different versions of the same library along each other. Similarly, you can also install libraries for different platforms alongside each other, for example library binaries for OS X and iOS.
The `install` command first checks if the specified library/version is already present for this platform, and if so, exits. This means you can run it multiple times (e.g. as part of a configuration script) without doing unnecessary work.
Next, Mason checks whether there are pre-built binaries available in the S3 bucket for the current platform. If that is the case, they are downloaded and unzipped and the installation is complete.
If no pre-built binaries are available, Mason is going to build the library according to the script in the `mason_packages/.build` folder, and install into the platform- and library-specific directory.
### `remove`
```bash
$ mason remove libuv 0.11.29
* Removing existing package...
/Users/user/mason_packages/osx-10.10/libuv/0.11.29/include/uv-darwin.h
[...]
/Users/user/mason_packages/osx-10.10/libuv/0.11.29
```
Removes the specified library/version from the package directory.
### `build`
This command works like the `install` command, except that it *doesn't* check for existing library installations, and that it *doesn't* check for pre-built binaries. I.e. it first removes the current installation and *always* builds the library from source. This is useful when you are working on a build script and want to fresh builds.
### `publish`
Creates a gzipped tarball of the specified platform/library/version and uploads it to the `mason-binaries` S3 bucket. If you want to use this feature, you need write access to the bucket and need to specify the environment variables `AWS_ACCESS_KEY_ID` and `AWS_SECRET_ACCESS_KEY`.
### `prefix`
```bash
~ $ mason prefix libuv 0.11.29
/Users/user/mason_packages/osx-10.10/libuv/0.11.29
```
This prints the absolute path to the installation directory of the the library/version. Likely, this folder has the typical `include` and `lib` folders.
### `cflags`
```bash
~ $ mason cflags libuv 0.11.29
-I/Users/user/mason_packages/osx-10.10/libuv/0.11.29/include
```
Prints the C/C++ compiler flags that are required to compile source code with this library. Likely, this is just the include path, but may also contain other flags.
### `ldflags`
```bash
~ $ mason ldflags libuv 0.11.29
-L/Users/user/mason_packages/osx-10.10/libuv/0.11.29/lib -luv -lpthread -ldl
```
Prints the linker flags that are required to link against this library.
### `link`
```bash
~ $ mason link libuv 0.11.29
```
This command only works if the package has already been installed. When run it symlinks the versioned `lib`, `include`, `share`, and `bin` folders of the package into a shared structure that is unversioned. For example if `mason prefix libuv 0.11.29` was `./mason_packages/osx-10.10/libuv/0.11.29` then the library would become available at `./mason_packages/.link/lib/libuv.a`
### `trigger`
In order to ensure that all prebuilt binaries are consistent and reproducible, we perform the final build and publish operation on Travis CI.
First set the `TRAVIS_TOKEN` environment variable. You can do this either by installing the `travis` gem and running `travis token` or by using `curl` to hit the Travis api directly. See details on this below.
Once you are set up with your `TRAVIS_TOKEN` then use the `trigger` command to kick off a build:
```bash
./mason trigger <package name> <package version>
```
Run this command from the root of a local mason repository checkout. It makes a request to the Travis API to build and publish the specified version of the package, using the Travis configuration in `./scripts/${MASON_NAME}/${MASON_VERSION}/.travis.yml`.
1) Using curl and travis api to generate TRAVIS_TOKEN
First generate a github personal access token that has `repo` scope by going to https://github.com/settings/tokens. More details at https://help.github.com/articles/creating-an-access-token-for-command-line-use/.
Then set that in your environment and run:
```sh
GITHUB_TOKEN=<github token>
curl -s -i https://api.travis-ci.org/auth/github \
-H "User-Agent: Travis/1.0" \
-H "Content-Type: application/json" \
-H "Accept: application/vnd.travis-ci.2+json" \
-H "Host: api.travis-ci.org" \
-d "{\"github_token\": \"${GITHUB_TOKEN}\"}"
```
2) Use the travis command
For details see https://docs.travis-ci.com/user/triggering-builds and https://github.com/travis-ci/travis.rb#readme
## Writing build scripts
Each version of each package has its own directory in scripts/${package}/${version}, e.g. [`scripts/libuv/0.11.29`](https://github.com/mapbox/mason/tree/master/scripts/libuv/0.11.29). The directory must contain a file called `script.sh`, which is structured like this:
```bash
#!/usr/bin/env bash
MASON_NAME=libuv
MASON_VERSION=0.11.29
MASON_LIB_FILE=lib/libuv.a
MASON_PKGCONFIG_FILE=lib/pkgconfig/libuv.pc
```
Declare these variables first. `MASON_NAME` and `MASON_VERSION` are mandatory. If the install script build a static library, specify the relative path in the installation directory in `MASON_LIB_FILE`. This is used to check whether an installation actually exists before proceeding to download/build the library anew. You can optionally specify `MASON_PKGCONFIG_FILE` as the relative path to the pig-config file if the library has one. If the library doesn't have one, you need to override the functions `mason_cflags` and `mason_ldflags` (see below).
Then, we're loading the build system with
```bash
. ${MASON_DIR}/mason.sh
```
Next, we're defining a function that obtains the source code and unzips it:
```bash
function mason_load_source {
mason_download \
https://github.com/joyent/libuv/archive/v0.11.29.tar.gz \
5bf49a8652f680557cbaf335a160187b2da3bf7f
mason_extract_tar_gz
export MASON_BUILD_PATH=${MASON_ROOT}/.build/libuv-${MASON_VERSION}
}
```
In that function, you should use `mason_download` as a shortcut to download the tarball. The second argument to is a hash generated with `git hash-object` and used to verify that the source code downloaded matches the expected file. The function also caches downloaded tarballs in the `mason_packages/.cache` folder.
`mason_extract_tar_gz` unpacks the archive into the `mason_packages/.build` folder. If the tarball is BZip2 compressed, you can also use `mason_extract_tar_bz2` instead.
Lastly, the `MASON_BUILD_PATH` variable contains the path to the unpacked folder inside the `.build` directory.
Then, you can optionally specify a function that is run before compiling, e.g. a script that generates configuration files:
```bash
function mason_prepare_compile {
./autogen.sh
}
```
The heart of the script is the `mason_compile` function because it performs the actual build of the source code. There are a few variables available that you need to use to make sure that the package will work correctly.
```bash
function mason_compile {
./configure \
--prefix=${MASON_PREFIX} \
${MASON_HOST_ARG} \
--enable-static \
--disable-shared \
--disable-dependency-tracking
make install -j${MASON_CONCURRENCY}
}
```
In particular, you have to set the build system's installation prefix to `MASON_PREFIX`. For cross-platform builds, you have to specify the `MASON_HOST_ARG`, which is empty for regular builds and is set to the correct host platform for cross-compiles (e.g. iOS builds use `--host=arm-apple-darwin`).
If the build system supports building concurrently, you can tell it do do so by providing the number of parallel tasks from `MASON_CONCURRENCY`.
Next, the `mason_clean` function tells Mason how to clean up the build folder. This is required for multi-architecture builds. E.g. iOS builds perform a Simulator (Intel architecture) build first, then an iOS (ARM architecture) build. The results are `lipo`ed into one universal archive file.
```bash
function mason_clean {
make clean
}
```
Finally, we're going to run the everything:
```bash
mason_run "$@"
```
### Variables
Name | Description
---|---
`MASON_DIR` | The directory where Mason itself is installed. Defaults to the current directory.
`MASON_ROOT` | Absolute path the `mason_packages` directory. Example: `/Users/user/mason_packages`.
`MASON_PLATFORM` | Platform of the current invocation. Currently one of `osx`, `ios` or `linux`.
`MASON_PLATFORM_VERSION` | Version of the platform. It must include the architecture if the produced binaries are architecture-specific (e.g. on Linux). Example: `10.10`
`MASON_NAME` | Name specified in the `script.sh` file. Example: `libuv`
`MASON_VERSION` | Version specified in the `script.sh` file. Example: `0.11.29`
`MASON_SLUG` | Combination of the name and version. Example: `libuv-0.11.29`
`MASON_PREFIX` | Absolute installation path. Example: `/Users/user/mason_packages/osx-10.10/libuv/0.11.29`
`MASON_BUILD_PATH` | Absolute path to the build root. Example: `/Users/user/mason_packages/.build/libuv-0.11.29`
`MASON_BUCKET` | S3 bucket that is used for storing pre-built binary packages. Example: `mason-binaries`
`MASON_BINARIES` | Relative path to the gzipped tarball in the `.binaries` directory. Example: `osx-10.10/libuv/0.11.29.tar.gz`
`MASON_BINARIES_PATH` | Absolute path to the gzipped tarball. Example: `/Users/user/mason_packages/.binaries/osx-10.10/libuv/0.11.29.tar.gz`
`MASON_CONCURRENCY` | Number of CPU cores. Example: `8`
`MASON_HOST_ARG` | Cross-compilation arguments. Example: `--host=x86_64-apple-darwin`
`MASON_LIB_FILE` | Relative path to the library file in the install directory. Example: `lib/libuv.a`
`MASON_PKGCONFIG_FILE` | Relative path to the pkg-config file in the install directory. Example: `lib/pkgconfig/libuv.pc`
`MASON_XCODE_ROOT` | OS X specific; Path to the Xcode Developer directory. Example: `/Applications/Xcode.app/Contents/Developer`
### Customization
In addition to the override functions described above, you can also override the `mason_cflags` and `mason_ldflags` functions. By default, they're using `pkg-config` to determine these flags and print them to standard output. If a library doesn't include a `.pc` file, or has some other mechanism for determining the build flags, you can run them instead:
```bash
function mason_ldflags {
${MASON_PREFIX}/bin/curl-config --static-libs`
}
```
### System packages
Some packages ship with operating systems, or can be easily installed with operating-specific package managers. For example, `libpng` is available on most systems and the version you're using doesn't really matter since it is mature and hasn't added any significant new APIs in recent years. To create a system package for it, use this `script.sh` file:
```bash
#!/usr/bin/env bash
MASON_NAME=libpng
MASON_VERSION=system
MASON_SYSTEM_PACKAGE=true
. ${MASON_DIR}/mason.sh
if [ ! $(pkg-config libpng --exists; echo $?) = 0 ]; then
mason_error "Cannot find libpng with pkg-config"
exit 1
fi
function mason_system_version {
mkdir -p "${MASON_PREFIX}"
cd "${MASON_PREFIX}"
if [ ! -f version ]; then
echo "#include <png.h>
#include <stdio.h>
#include <assert.h>
int main() {
assert(PNG_LIBPNG_VER == png_access_version_number());
printf(\"%s\", PNG_LIBPNG_VER_STRING);
return 0;
}
" > version.c && ${CC:-cc} version.c $(mason_cflags) $(mason_ldflags) -o version
fi
./version
}
function mason_compile {
:
}
function mason_cflags {
pkg-config libpng --cflags
}
function mason_ldflags {
pkg-config libpng --libs
}
mason_run "$@"
```
System packages are marked with `MASON_SYSTEM_PACKAGE=true`. We're also first using `pkg-config` to check whether the library is present at all. The `mason_system_version` function creates a small executable which outputs the actual version. It is the only thing that is cached in the installation directory.
We have to override the `mason_cflags` and `mason_ldflags` commands since the regular commands return flags for static libraries, but in the case of system packages, we want to dynamically link against the package.
## Troubleshooting
Downloaded source tarballs are cached in `mason_packages/.cache`. If for some reason the initial download failed, but it still left a file in that directory, make sure you delete the partial download there.

73
third_party/mason/cloudformation/travis.template vendored Normal file
View File

@ -0,0 +1,73 @@
{
"AWSTemplateFormatVersion": "2010-09-09",
"Description": "mason bucket resources",
"Resources": {
"BuildUser": {
"Type": "AWS::IAM::User",
"Properties": {
"Policies": [
{
"PolicyName": "list",
"PolicyDocument": {
"Statement": [
{
"Action": [
"s3:ListBucket"
],
"Effect": "Allow",
"Resource": [
"arn:aws:s3:::mason-binaries"
]
}
]
}
},
{
"PolicyName": "build",
"PolicyDocument": {
"Statement": [
{
"Action": [
"s3:DeleteObject",
"s3:GetObject",
"s3:GetObjectAcl",
"s3:PutObject",
"s3:PutObjectAcl"
],
"Effect": "Allow",
"Resource": [
"arn:aws:s3:::mason-binaries/*"
]
}
]
}
}
]
}
},
"BuildUserKey": {
"Type": "AWS::IAM::AccessKey",
"Properties": {
"UserName": {
"Ref": "BuildUser"
}
}
}
},
"Outputs": {
"AccessKeyId": {
"Value": {
"Ref": "BuildUserKey"
}
},
"SecretAccessKey": {
"Value": {
"Fn::GetAtt": [
"BuildUserKey",
"SecretAccessKey"
]
}
}
}
}

7
third_party/mason/contributing.md vendored Normal file
View File

@ -0,0 +1,7 @@
# Release process
- Increment version at the top of `mason`
- Increment version in test/unit.sh
- Update changelog
- Ensure tests are passing
- Tag a release: `git tag v0.1.0 -a -m "v0.1.0" && git push --tags`

85
third_party/mason/mason vendored Executable file
View File

@ -0,0 +1,85 @@
#!/usr/bin/env bash
MASON_COMMAND=$1 ; shift
MASON_NAME=$1 ; shift
MASON_VERSION=$1 ; shift
set -e
set -o pipefail
MASON_RELEASED_VERSION="0.1.0"
if [ "${MASON_COMMAND}" = "--version" ]; then
echo ${MASON_RELEASED_VERSION}
exit 0
fi
function usage {
echo "Usage: $0 <command> <lib> <version>"
}
if [ -z "${MASON_COMMAND}" ]; then
usage
exit 1
fi
ROOTDIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" > /dev/null && pwd )"
MASON_DIR=${MASON_DIR:-$ROOTDIR}
if [ "${MASON_COMMAND}" = "env" ]; then
. ${MASON_DIR}/mason.sh > /dev/null
eval echo \$${MASON_NAME}
exit
fi
if [ -z "${MASON_NAME}" ]; then
usage
echo "Missing <lib>"
exit 1
elif [ -z "${MASON_VERSION}" ]; then
usage
echo "Missing <version>"
exit 1
fi
if [ "${MASON_COMMAND}" = "trigger" ]; then
if [ -z "${TRAVIS_TOKEN}" ]; then
echo "TRAVIS_TOKEN is not set."
exit 1
fi
config=$(ruby <<RUBY
require 'yaml'
require 'json'
config = YAML.load_file("scripts/${MASON_NAME}/${MASON_VERSION}/.travis.yml")
config["env"] ||= {}
config["env"]["global"] ||= []
config["env"]["global"] << "MASON_NAME=${MASON_NAME}" << "MASON_VERSION=${MASON_VERSION}"
puts JSON.pretty_generate(config)
RUBY
)
body="{
\"request\": {
\"message\": \"Building ${MASON_NAME} ${MASON_VERSION}\",
\"branch\": \"$(git rev-parse --abbrev-ref HEAD)\",
\"config\": ${config}
}
}"
curl -s -X POST https://api.travis-ci.org/repo/mapbox%2Fmason/requests \
-H "Content-Type: application/json" \
-H "Accept: application/json" \
-H "Travis-API-Version: 3" \
-H "Authorization: token ${TRAVIS_TOKEN}" \
-d "$body"
echo "Now go to https://travis-ci.org/mapbox/mason/builds to view build status"
exit
fi
. ${MASON_DIR}/mason.sh
export MASON_DIR
bash "${MASON_DIR}/scripts/${MASON_NAME}/${MASON_VERSION}/script.sh" "${MASON_COMMAND}" "$@"

231
third_party/mason/mason.cmake vendored Normal file
View File

@ -0,0 +1,231 @@
string(RANDOM LENGTH 16 MASON_INVOCATION)
# Directory where Mason packages are located; typically ends with mason_packages
if (NOT MASON_PACKAGE_DIR)
set(MASON_PACKAGE_DIR "${CMAKE_SOURCE_DIR}/mason_packages")
endif()
# URL prefix of where packages are located.
if (NOT MASON_REPOSITORY)
set(MASON_REPOSITORY "https://mason-binaries.s3.amazonaws.com")
endif()
# Path to Mason executable
if (NOT MASON_COMMAND)
set(MASON_COMMAND "${CMAKE_SOURCE_DIR}/.mason/mason")
endif()
# Determine platform
# we call uname -s manually here since
# CMAKE_HOST_SYSTEM_NAME will not be defined before the project() call
execute_process(
COMMAND uname -s
OUTPUT_VARIABLE UNAME_S
OUTPUT_STRIP_TRAILING_WHITESPACE)
if(NOT MASON_PLATFORM)
if (UNAME_S STREQUAL "Darwin")
set(MASON_PLATFORM "macos")
else()
set(MASON_PLATFORM "linux")
endif()
endif()
# Determine platform version string
if(MASON_PLATFORM STREQUAL "ios")
set(MASON_PLATFORM_VERSION "8.0") # Deployment target version
elseif(MASON_PLATFORM STREQUAL "android")
if (ANDROID_ABI STREQUAL "armeabi")
set(MASON_PLATFORM_VERSION "arm-v5-9")
elseif(ANDROID_ABI STREQUAL "arm64-v8a")
set(MASON_PLATFORM_VERSION "arm-v8-21")
elseif(ANDROID_ABI STREQUAL "x86")
set(MASON_PLATFORM_VERSION "x86-9")
elseif(ANDROID_ABI STREQUAL "x86_64")
set(MASON_PLATFORM_VERSION "x86-64-21")
elseif(ANDROID_ABI STREQUAL "mips")
set(MASON_PLATFORM_VERSION "mips-9")
elseif(ANDROID_ABI STREQUAL "mips64")
set(MASON_PLATFORM_VERSION "mips64-21")
else()
set(MASON_PLATFORM_VERSION "arm-v7-9")
endif()
else()
execute_process(
COMMAND uname -m
OUTPUT_VARIABLE MASON_PLATFORM_VERSION
OUTPUT_STRIP_TRAILING_WHITESPACE)
endif()
if(MASON_PLATFORM STREQUAL "macos")
set(MASON_PLATFORM "osx")
endif()
set(ENV{MASON_PLATFORM} "${MASON_PLATFORM}")
set(ENV{MASON_PLATFORM_VERSION} "${MASON_PLATFORM_VERSION}")
include(CMakeParseArguments)
function(mason_use _PACKAGE)
if(NOT _PACKAGE)
message(FATAL_ERROR "[Mason] No package name given")
endif()
cmake_parse_arguments("" "HEADER_ONLY" "VERSION" "" ${ARGN})
if(_UNPARSED_ARGUMENTS)
message(FATAL_ERROR "[Mason] mason_use() called with unrecognized arguments: ${_UNPARSED_ARGUMENTS}")
endif()
if(NOT _VERSION)
message(FATAL_ERROR "[Mason] Specifying a version is required")
endif()
if(MASON_PACKAGE_${_PACKAGE}_INVOCATION STREQUAL "${MASON_INVOCATION}")
# Check that the previous invocation of mason_use didn't select another version of this package
if(NOT MASON_PACKAGE_${_PACKAGE}_VERSION STREQUAL ${_VERSION})
message(FATAL_ERROR "[Mason] Already using ${_PACKAGE} ${MASON_PACKAGE_${_PACKAGE}_VERSION}. Cannot select version ${_VERSION}.")
endif()
else()
if(_HEADER_ONLY)
set(_PLATFORM_ID "headers")
else()
set(_PLATFORM_ID "${MASON_PLATFORM}-${MASON_PLATFORM_VERSION}")
endif()
set(_SLUG "${_PLATFORM_ID}/${_PACKAGE}/${_VERSION}")
set(_INSTALL_PATH "${MASON_PACKAGE_DIR}/${_SLUG}")
file(RELATIVE_PATH _INSTALL_PATH_RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}" "${_INSTALL_PATH}")
if(NOT EXISTS "${_INSTALL_PATH}")
set(_CACHE_PATH "${MASON_PACKAGE_DIR}/.binaries/${_SLUG}.tar.gz")
if (NOT EXISTS "${_CACHE_PATH}")
# Download the package
set(_URL "${MASON_REPOSITORY}/${_SLUG}.tar.gz")
message(STATUS "[Mason] Downloading package ${_URL}...")
set(_FAILED)
set(_ERROR)
# Note: some CMake versions are compiled without SSL support
get_filename_component(_CACHE_DIR "${_CACHE_PATH}" DIRECTORY)
file(MAKE_DIRECTORY "${_CACHE_DIR}")
execute_process(
COMMAND curl --retry 3 -s -f -S -L "${_URL}" -o "${_CACHE_PATH}.tmp"
RESULT_VARIABLE _FAILED
ERROR_VARIABLE _ERROR)
if(_FAILED)
message(FATAL_ERROR "[Mason] Failed to download ${_URL}: ${_ERROR}")
else()
# We downloaded to a temporary file to prevent half-finished downloads
file(RENAME "${_CACHE_PATH}.tmp" "${_CACHE_PATH}")
endif()
endif()
# Unpack the package
message(STATUS "[Mason] Unpacking package to ${_INSTALL_PATH_RELATIVE}...")
file(MAKE_DIRECTORY "${_INSTALL_PATH}")
execute_process(
COMMAND ${CMAKE_COMMAND} -E tar xzf "${_CACHE_PATH}"
WORKING_DIRECTORY "${_INSTALL_PATH}")
endif()
# Create a config file if it doesn't exist in the package
# TODO: remove this once all packages have a mason.ini file
if(NOT EXISTS "${_INSTALL_PATH}/mason.ini")
# Change pkg-config files
file(GLOB_RECURSE _PKGCONFIG_FILES "${_INSTALL_PATH}/*.pc")
foreach(_PKGCONFIG_FILE IN ITEMS ${_PKGCONFIG_FILES})
file(READ "${_PKGCONFIG_FILE}" _PKGCONFIG_FILE_CONTENT)
string(REGEX REPLACE "(^|\n)prefix=[^\n]*" "\\1prefix=${_INSTALL_PATH}" _PKGCONFIG_FILE_CONTENT "${_PKGCONFIG_FILE_CONTENT}")
file(WRITE "${_PKGCONFIG_FILE}" "${_PKGCONFIG_FILE_CONTENT}")
endforeach()
if(NOT EXISTS "${MASON_COMMAND}")
message(FATAL_ERROR "[Mason] Could not find Mason command at ${MASON_COMMAND}")
endif()
set(_FAILED)
set(_ERROR)
execute_process(
COMMAND ${MASON_COMMAND} config ${_PACKAGE} ${_VERSION}
WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
OUTPUT_FILE "${_INSTALL_PATH}/mason.ini"
RESULT_VARIABLE _FAILED
ERROR_VARIABLE _ERROR)
if(_FAILED)
message(FATAL_ERROR "[Mason] Could not get configuration for package ${_PACKAGE} ${_VERSION}: ${_ERROR}")
endif()
endif()
set(MASON_PACKAGE_${_PACKAGE}_PREFIX "${_INSTALL_PATH}" CACHE STRING "${_PACKAGE} ${_INSTALL_PATH}" FORCE)
mark_as_advanced(MASON_PACKAGE_${_PACKAGE}_PREFIX)
# Load the configuration from the ini file
file(STRINGS "${_INSTALL_PATH}/mason.ini" _CONFIG_FILE)
foreach(_LINE IN LISTS _CONFIG_FILE)
string(REGEX MATCH "^([a-z_]+) *= *" _KEY "${_LINE}")
if (_KEY)
string(LENGTH "${_KEY}" _KEY_LENGTH)
string(SUBSTRING "${_LINE}" ${_KEY_LENGTH} -1 _VALUE)
string(REGEX REPLACE ";.*$" "" _VALUE "${_VALUE}") # Trim trailing commas
string(REPLACE "{prefix}" "${_INSTALL_PATH}" _VALUE "${_VALUE}")
string(STRIP "${_VALUE}" _VALUE)
string(REPLACE "=" "" _KEY "${_KEY}")
string(STRIP "${_KEY}" _KEY)
string(TOUPPER "${_KEY}" _KEY)
if(_KEY STREQUAL "INCLUDE_DIRS")
separate_arguments(_VALUE)
endif()
set(MASON_PACKAGE_${_PACKAGE}_${_KEY} "${_VALUE}" CACHE STRING "${_PACKAGE} ${_KEY}" FORCE)
mark_as_advanced(MASON_PACKAGE_${_PACKAGE}_${_KEY})
endif()
endforeach()
# Compare version in the package to catch errors early on
if(NOT _VERSION STREQUAL MASON_PACKAGE_${_PACKAGE}_VERSION)
message(FATAL_ERROR "[Mason] Package at ${_INSTALL_PATH_RELATIVE} has version '${MASON_PACKAGE_${_PACKAGE}_VERSION}', but required '${_VERSION}'")
endif()
if(NOT _PACKAGE STREQUAL MASON_PACKAGE_${_PACKAGE}_NAME)
message(FATAL_ERROR "[Mason] Package at ${_INSTALL_PATH_RELATIVE} has name '${MASON_PACKAGE_${_PACKAGE}_NAME}', but required '${_NAME}'")
endif()
if(NOT _HEADER_ONLY)
if(NOT MASON_PLATFORM STREQUAL MASON_PACKAGE_${_PACKAGE}_PLATFORM)
message(FATAL_ERROR "[Mason] Package at ${_INSTALL_PATH_RELATIVE} has platform '${MASON_PACKAGE_${_PACKAGE}_PLATFORM}', but required '${MASON_PLATFORM}'")
endif()
if(NOT MASON_PLATFORM_VERSION STREQUAL MASON_PACKAGE_${_PACKAGE}_PLATFORM_VERSION)
message(FATAL_ERROR "[Mason] Package at ${_INSTALL_PATH_RELATIVE} has platform version '${MASON_PACKAGE_${_PACKAGE}_PLATFORM_VERSION}', but required '${MASON_PLATFORM_VERSION}'")
endif()
endif()
# Concatenate the static libs and libraries
set(_LIBRARIES)
list(APPEND _LIBRARIES ${MASON_PACKAGE_${_PACKAGE}_STATIC_LIBS} ${MASON_PACKAGE_${_PACKAGE}_LDFLAGS})
set(MASON_PACKAGE_${_PACKAGE}_LIBRARIES "${_LIBRARIES}" CACHE STRING "${_PACKAGE} _LIBRARIES" FORCE)
mark_as_advanced(MASON_PACKAGE_${_PACKAGE}_LIBRARIES)
if(NOT _HEADER_ONLY)
string(REGEX MATCHALL "(^| +)-L *([^ ]+)" MASON_PACKAGE_${_PACKAGE}_LIBRARY_DIRS "${MASON_PACKAGE_${_PACKAGE}_LDFLAGS}")
string(REGEX REPLACE "(^| +)-L *" "\\1" MASON_PACKAGE_${_PACKAGE}_LIBRARY_DIRS "${MASON_PACKAGE_${_PACKAGE}_LIBRARY_DIRS}")
set(MASON_PACKAGE_${_PACKAGE}_LIBRARY_DIRS "${MASON_PACKAGE_${_PACKAGE}_LIBRARY_DIRS}" CACHE STRING "${_PACKAGE} ${MASON_PACKAGE_${_PACKAGE}_LIBRARY_DIRS}" FORCE)
mark_as_advanced(MASON_PACKAGE_${_PACKAGE}_LIBRARY_DIRS)
endif()
# Store invocation ID to prevent different versions of the same package in one invocation
set(MASON_PACKAGE_${_PACKAGE}_INVOCATION "${MASON_INVOCATION}" CACHE INTERNAL "${_PACKAGE} invocation ID" FORCE)
endif()
endfunction()
macro(target_add_mason_package _TARGET _VISIBILITY _PACKAGE)
if (NOT MASON_PACKAGE_${_PACKAGE}_INVOCATION)
message(FATAL_ERROR "[Mason] Package ${_PACKAGE} has not been initialized yet")
endif()
target_include_directories(${_TARGET} ${_VISIBILITY} "${MASON_PACKAGE_${_PACKAGE}_INCLUDE_DIRS}")
target_compile_definitions(${_TARGET} ${_VISIBILITY} "${MASON_PACKAGE_${_PACKAGE}_DEFINITIONS}")
target_compile_options(${_TARGET} ${_VISIBILITY} "${MASON_PACKAGE_${_PACKAGE}_OPTIONS}")
target_link_libraries(${_TARGET} ${_VISIBILITY} "${MASON_PACKAGE_${_PACKAGE}_LIBRARIES}")
endmacro()

739
third_party/mason/mason.sh vendored Normal file
View File

@ -0,0 +1,739 @@
set -e
set -o pipefail
# set -x
export MASON_ROOT=${MASON_ROOT:-`pwd`/mason_packages}
MASON_BUCKET=${MASON_BUCKET:-mason-binaries}
MASON_IGNORE_OSX_SDK=${MASON_IGNORE_OSX_SDK:-false}
MASON_UNAME=`uname -s`
if [ ${MASON_UNAME} = 'Darwin' ]; then
MASON_PLATFORM=${MASON_PLATFORM:-osx}
MASON_XCODE_ROOT=`"xcode-select" -p`
elif [ ${MASON_UNAME} = 'Linux' ]; then
MASON_PLATFORM=${MASON_PLATFORM:-linux}
fi
# In non-interactive environments like Travis CI, we can't use -s because it'll fill up the log
# way too fast
case $- in
*i*) MASON_CURL_ARGS= ;; # interactive
*) MASON_CURL_ARGS=-s ;; # non-interative
esac
case ${MASON_UNAME} in
'Darwin') MASON_CONCURRENCY=`sysctl -n hw.ncpu` ;;
'Linux') MASON_CONCURRENCY=$(lscpu -p | egrep -v '^#' | wc -l) ;;
*) MASON_CONCURRENCY=1 ;;
esac
function mason_step { >&2 echo -e "\033[1m\033[36m* $1\033[0m"; }
function mason_substep { >&2 echo -e "\033[1m\033[36m* $1\033[0m"; }
function mason_success { >&2 echo -e "\033[1m\033[32m* $1\033[0m"; }
function mason_error { >&2 echo -e "\033[1m\033[31m$1\033[0m"; }
case ${MASON_ROOT} in
*\ * ) mason_error "Directory '${MASON_ROOT} contains spaces."; exit ;;
esac
if [ ${MASON_PLATFORM} = 'osx' ]; then
export MASON_HOST_ARG="--host=x86_64-apple-darwin"
export MASON_PLATFORM_VERSION=`uname -m`
if [[ ${MASON_IGNORE_OSX_SDK} == false ]]; then
MASON_SDK_VERSION=`xcrun --sdk macosx --show-sdk-version`
MASON_SDK_ROOT=${MASON_XCODE_ROOT}/Platforms/MacOSX.platform/Developer
MASON_SDK_PATH="${MASON_SDK_ROOT}/SDKs/MacOSX${MASON_SDK_VERSION}.sdk"
if [[ ${MASON_SYSTEM_PACKAGE} && ${MASON_SDK_VERSION%%.*} -ge 10 && ${MASON_SDK_VERSION##*.} -ge 11 ]]; then
export MASON_DYNLIB_SUFFIX="tbd"
else
export MASON_DYNLIB_SUFFIX="dylib"
fi
MIN_SDK_VERSION_FLAG="-mmacosx-version-min=10.8"
SYSROOT_FLAGS="-isysroot ${MASON_SDK_PATH} -arch x86_64 ${MIN_SDK_VERSION_FLAG}"
export CFLAGS="${SYSROOT_FLAGS}"
export CXXFLAGS="${CFLAGS} -fvisibility-inlines-hidden -stdlib=libc++ -std=c++11"
# NOTE: OSX needs '-stdlib=libc++ -std=c++11' in both CXXFLAGS and LDFLAGS
# to correctly target c++11 for build systems that don't know about it yet (like libgeos 3.4.2)
# But because LDFLAGS is also for C libs we can only put these flags into LDFLAGS per package
export LDFLAGS="-Wl,-search_paths_first ${SYSROOT_FLAGS}"
export CXX="/usr/bin/clang++"
export CC="/usr/bin/clang"
fi
elif [ ${MASON_PLATFORM} = 'ios' ]; then
export MASON_HOST_ARG="--host=arm-apple-darwin"
export MASON_PLATFORM_VERSION="8.0" # Deployment target version
MASON_SDK_VERSION=`xcrun --sdk iphoneos --show-sdk-version`
MASON_SDK_ROOT=${MASON_XCODE_ROOT}/Platforms/iPhoneOS.platform/Developer
MASON_SDK_PATH="${MASON_SDK_ROOT}/SDKs/iPhoneOS${MASON_SDK_VERSION}.sdk"
MIN_SDK_VERSION_FLAG="-miphoneos-version-min=${MASON_PLATFORM_VERSION}"
export MASON_IOS_CFLAGS="${MIN_SDK_VERSION_FLAG} -isysroot ${MASON_SDK_PATH}"
if [[ ${MASON_SDK_VERSION%%.*} -ge 9 ]]; then
export MASON_IOS_CFLAGS="${MASON_IOS_CFLAGS} -fembed-bitcode"
export MASON_DYNLIB_SUFFIX="tbd"
else
export MASON_DYNLIB_SUFFIX="dylib"
fi
if [ `xcrun --sdk iphonesimulator --show-sdk-version` != ${MASON_SDK_VERSION} ]; then
mason_error "iPhone Simulator SDK version doesn't match iPhone SDK version"
exit 1
fi
MASON_SDK_ROOT=${MASON_XCODE_ROOT}/Platforms/iPhoneSimulator.platform/Developer
MASON_SDK_PATH="${MASON_SDK_ROOT}/SDKs/iPhoneSimulator${MASON_SDK_VERSION}.sdk"
export MASON_ISIM_CFLAGS="${MIN_SDK_VERSION_FLAG} -isysroot ${MASON_SDK_PATH}"
elif [ ${MASON_PLATFORM} = 'linux' ]; then
export MASON_DYNLIB_SUFFIX="so"
# Assume current system is the target platform
if [ -z ${MASON_PLATFORM_VERSION} ] ; then
export MASON_PLATFORM_VERSION=`uname -m`
fi
export CFLAGS="-fPIC"
export CXXFLAGS="${CFLAGS} -std=c++11"
if [ `uname -m` != ${MASON_PLATFORM_VERSION} ] ; then
# Install the cross compiler
MASON_XC_PACKAGE_NAME=gcc
MASON_XC_PACKAGE_VERSION=${MASON_XC_GCC_VERSION:-5.3.0}-${MASON_PLATFORM_VERSION}
MASON_XC_PACKAGE=${MASON_XC_PACKAGE_NAME}-${MASON_XC_PACKAGE_VERSION}
MASON_XC_ROOT=$(MASON_PLATFORM= MASON_PLATFORM_VERSION= ${MASON_DIR}/mason prefix ${MASON_XC_PACKAGE_NAME} ${MASON_XC_PACKAGE_VERSION})
if [[ ! ${MASON_XC_ROOT} =~ ".build" ]] && [ ! -d ${MASON_XC_ROOT} ] ; then
$(MASON_PLATFORM= MASON_PLATFORM_VERSION= ${MASON_DIR}/mason install ${MASON_XC_PACKAGE_NAME} ${MASON_XC_PACKAGE_VERSION})
MASON_XC_ROOT=$(MASON_PLATFORM= MASON_PLATFORM_VERSION= ${MASON_DIR}/mason prefix ${MASON_XC_PACKAGE_NAME} ${MASON_XC_PACKAGE_VERSION})
fi
# Load toolchain specific variables
if [[ ! ${MASON_XC_ROOT} =~ ".build" ]] && [ -f ${MASON_XC_ROOT}/toolchain.sh ] ; then
source ${MASON_XC_ROOT}/toolchain.sh
fi
fi
elif [ ${MASON_PLATFORM} = 'android' ]; then
case "${MASON_PLATFORM_VERSION}" in
arm-v5-9) export MASON_ANDROID_ABI=arm-v5 ;;
arm-v7-9) export MASON_ANDROID_ABI=arm-v7 ;;
arm-v8-21) export MASON_ANDROID_ABI=arm-v8 ;;
x86-9) export MASON_ANDROID_ABI=x86 ;;
x86-64-21) export MASON_ANDROID_ABI=x86-64 ;;
mips-9) export MASON_ANDROID_ABI=mips ;;
mips64-21) export MASON_ANDROID_ABI=mips64 ;;
*) export MASON_ANDROID_ABI=${MASON_ANDROID_ABI:-arm-v7}
esac
CFLAGS="-fpic -ffunction-sections -funwind-tables -fstack-protector-strong -no-canonical-prefixes -fno-integrated-as -fomit-frame-pointer -fstrict-aliasing -Wno-invalid-command-line-argument -Wno-unused-command-line-argument"
LDFLAGS="-no-canonical-prefixes -Wl,--warn-shared-textrel -Wl,--fatal-warnings -Wl,-z,now -Wl,-z,relro"
export CPPFLAGS="-D__ANDROID__"
if [ ${MASON_ANDROID_ABI} = 'arm-v8' ]; then
MASON_ANDROID_TOOLCHAIN="aarch64-linux-android"
MASON_ANDROID_CROSS_COMPILER="aarch64-linux-android-4.9"
export MASON_HOST_ARG="--host=${MASON_ANDROID_TOOLCHAIN}"
export CFLAGS="-target aarch64-none-linux-android -D_LITTLE_ENDIAN ${CFLAGS}"
# Using bfd for aarch64: https://code.google.com/p/android/issues/detail?id=204151
export LDFLAGS="-target aarch64-none-linux-android -fuse-ld=bfd ${LDFLAGS}"
export JNIDIR="arm64-v8a"
MASON_ANDROID_ARCH="arm64"
MASON_ANDROID_PLATFORM="21"
elif [ ${MASON_ANDROID_ABI} = 'arm-v7' ]; then
MASON_ANDROID_TOOLCHAIN="arm-linux-androideabi"
MASON_ANDROID_CROSS_COMPILER="arm-linux-androideabi-4.9"
export MASON_HOST_ARG="--host=${MASON_ANDROID_TOOLCHAIN}"
export CFLAGS="-target armv7-none-linux-androideabi -march=armv7-a -mfpu=vfpv3-d16 -mfloat-abi=softfp -D_LITTLE_ENDIAN ${CFLAGS}"
export LDFLAGS="-target armv7-none-linux-androideabi -march=armv7-a -Wl,--fix-cortex-a8 -fuse-ld=gold ${LDFLAGS}"
export JNIDIR="armeabi-v7a"
MASON_ANDROID_ARCH="arm"
MASON_ANDROID_PLATFORM="9"
elif [ ${MASON_ANDROID_ABI} = 'arm-v5' ]; then
MASON_ANDROID_TOOLCHAIN="arm-linux-androideabi"
MASON_ANDROID_CROSS_COMPILER="arm-linux-androideabi-4.9"
export MASON_HOST_ARG="--host=${MASON_ANDROID_TOOLCHAIN}"
export CFLAGS="-target armv5te-none-linux-androideabi -march=armv5te -mtune=xscale -msoft-float -D_LITTLE_ENDIAN ${CFLAGS}"
export LDFLAGS="-target armv5te-none-linux-androideabi -march=armv5te -fuse-ld=gold ${LDFLAGS}"
export JNIDIR="armeabi"
MASON_ANDROID_ARCH="arm"
MASON_ANDROID_PLATFORM="9"
elif [ ${MASON_ANDROID_ABI} = 'x86' ]; then
MASON_ANDROID_TOOLCHAIN="i686-linux-android"
MASON_ANDROID_CROSS_COMPILER="x86-4.9"
export MASON_HOST_ARG="--host=${MASON_ANDROID_TOOLCHAIN}"
export CFLAGS="-target i686-none-linux-android -march=i686 -msse3 -mfpmath=sse ${CFLAGS}"
export LDFLAGS="-target i686-none-linux-android -march=i686 -fuse-ld=gold ${LDFLAGS}"
export JNIDIR="x86"
MASON_ANDROID_ARCH="x86"
MASON_ANDROID_PLATFORM="9"
elif [ ${MASON_ANDROID_ABI} = 'x86-64' ]; then
MASON_ANDROID_TOOLCHAIN="x86_64-linux-android"
MASON_ANDROID_CROSS_COMPILER="x86_64-4.9"
export MASON_HOST_ARG="--host=${MASON_ANDROID_TOOLCHAIN}"
export JNIDIR="x86_64"
export CFLAGS="-target x86_64-none-linux-android -march=x86-64 -msse4.2 -mpopcnt -m64 -mtune=intel ${CFLAGS}"
export LDFLAGS="-target x86_64-none-linux-android -march=x86-64 -fuse-ld=gold ${LDFLAGS}"
MASON_ANDROID_ARCH="x86_64"
MASON_ANDROID_PLATFORM="21"
elif [ ${MASON_ANDROID_ABI} = 'mips' ]; then
MASON_ANDROID_TOOLCHAIN="mipsel-linux-android"
MASON_ANDROID_CROSS_COMPILER="mipsel-linux-android-4.9"
export MASON_HOST_ARG="--host=${MASON_ANDROID_TOOLCHAIN}"
export CFLAGS="-target mipsel-none-linux-android ${CFLAGS}"
export LDFLAGS="-target mipsel-none-linux-android ${LDFLAGS}"
export JNIDIR="mips"
MASON_ANDROID_ARCH="mips"
MASON_ANDROID_PLATFORM="9"
elif [ ${MASON_ANDROID_ABI} = 'mips-64' ]; then
MASON_ANDROID_TOOLCHAIN="mips64el-linux-android"
MASON_ANDROID_CROSS_COMPILER="mips64el-linux-android-4.9"
export MASON_HOST_ARG="--host=${MASON_ANDROID_TOOLCHAIN}"
export CFLAGS="-target mips64el-none-linux-android ${CFLAGS}"
export LDFLAGS="-target mips64el-none-linux-android ${LDFLAGS}"
export JNIDIR="mips64"
MASON_ANDROID_ARCH="mips64"
MASON_ANDROID_PLATFORM="21"
fi
export MASON_DYNLIB_SUFFIX="so"
export MASON_PLATFORM_VERSION="${MASON_ANDROID_ABI}-${MASON_ANDROID_PLATFORM}"
MASON_API_LEVEL=${MASON_API_LEVEL:-android-$MASON_ANDROID_PLATFORM}
# Installs the native SDK
export MASON_NDK_PACKAGE_VERSION=${MASON_ANDROID_ARCH}-${MASON_ANDROID_PLATFORM}-r12b
MASON_SDK_ROOT=$(MASON_PLATFORM= MASON_PLATFORM_VERSION= ${MASON_DIR}/mason prefix android-ndk ${MASON_NDK_PACKAGE_VERSION})
if [ ! -d ${MASON_SDK_ROOT} ] ; then
MASON_PLATFORM= MASON_PLATFORM_VERSION= ${MASON_DIR}/mason install android-ndk ${MASON_NDK_PACKAGE_VERSION}
fi
MASON_SDK_PATH="${MASON_SDK_ROOT}/sysroot"
export PATH=${MASON_SDK_ROOT}/bin:${PATH}
export CFLAGS="--sysroot=${MASON_SDK_PATH} ${CFLAGS}"
export CXXFLAGS="--sysroot=${MASON_SDK_PATH} ${CFLAGS}"
export LDFLAGS="--sysroot=${MASON_SDK_PATH} ${LDFLAGS}"
export CXX="${MASON_ANDROID_TOOLCHAIN}-clang++"
export CC="${MASON_ANDROID_TOOLCHAIN}-clang"
export LD="${MASON_ANDROID_TOOLCHAIN}-ld"
export AR="${MASON_ANDROID_TOOLCHAIN}-ar"
export RANLIB="${MASON_ANDROID_TOOLCHAIN}-ranlib"
export STRIP="${MASON_ANDROID_TOOLCHAIN}-strip"
fi
# Variable defaults
MASON_HOST_ARG=${MASON_HOST_ARG:-}
MASON_PLATFORM_VERSION=${MASON_PLATFORM_VERSION:-0}
MASON_NAME=${MASON_NAME:-nopackage}
MASON_VERSION=${MASON_VERSION:-noversion}
MASON_HEADER_ONLY=${MASON_HEADER_ONLY:-false}
MASON_SLUG=${MASON_NAME}-${MASON_VERSION}
if [[ ${MASON_HEADER_ONLY} == true ]]; then
MASON_PLATFORM_ID=headers
else
MASON_PLATFORM_ID=${MASON_PLATFORM}-${MASON_PLATFORM_VERSION}
fi
MASON_PREFIX=${MASON_ROOT}/${MASON_PLATFORM_ID}/${MASON_NAME}/${MASON_VERSION}
MASON_BINARIES=${MASON_PLATFORM_ID}/${MASON_NAME}/${MASON_VERSION}.tar.gz
MASON_BINARIES_PATH=${MASON_ROOT}/.binaries/${MASON_BINARIES}
function mason_check_existing {
# skip installing if it already exists
if [ ${MASON_HEADER_ONLY:-false} = true ] ; then
if [ -d "${MASON_PREFIX}" ] ; then
mason_success "Already installed at ${MASON_PREFIX}"
exit 0
fi
elif [ ${MASON_SYSTEM_PACKAGE:-false} = true ]; then
if [ -f "${MASON_PREFIX}/version" ] ; then
mason_success "Using system-provided ${MASON_NAME} $(set -e;mason_system_version)"
exit 0
fi
else
if [ -f "${MASON_PREFIX}/${MASON_LIB_FILE}" ] ; then
mason_success "Already installed at ${MASON_PREFIX}"
exit 0
fi
fi
}
function mason_check_installed {
# skip installing if it already exists
if [ ${MASON_HEADER_ONLY:-false} = true ] ; then
if [ -d "${MASON_PREFIX}" ] ; then
return 0
fi
elif [ ${MASON_SYSTEM_PACKAGE:-false} = true ]; then
if [ -f "${MASON_PREFIX}/version" ] ; then
return 0
fi
elif [ -f "${MASON_PREFIX}/${MASON_LIB_FILE}" ] ; then
return 0
fi
mason_error "Package ${MASON_NAME} ${MASON_VERSION} isn't installed"
return 1
}
function mason_clear_existing {
if [ -d "${MASON_PREFIX}" ]; then
mason_step "Removing existing package... ${MASON_PREFIX}"
rm -rf "${MASON_PREFIX}"
fi
}
function mason_download {
mkdir -p "${MASON_ROOT}/.cache"
cd "${MASON_ROOT}/.cache"
if [ ! -f ${MASON_SLUG} ] ; then
mason_step "Downloading $1..."
CURL_RESULT=0
curl --retry 3 ${MASON_CURL_ARGS} -f -S -L "$1" -o ${MASON_SLUG} || CURL_RESULT=$?
if [[ ${CURL_RESULT} != 0 ]]; then
mason_error "Failed to download ${1} (returncode: $CURL_RESULT)"
exit $RESULT
fi
fi
MASON_HASH=`git hash-object ${MASON_SLUG}`
if [ "$2" != "${MASON_HASH}" ] ; then
mason_error "Hash ${MASON_HASH} of file ${MASON_ROOT}/.cache/${MASON_SLUG} doesn't match $2"
exit 1
fi
}
function mason_setup_build_dir {
rm -rf "${MASON_ROOT}/.build/${MASON_SLUG}"
mkdir -p "${MASON_ROOT}/.build/"
cd "${MASON_ROOT}/.build/"
}
function mason_extract_tar_gz {
mason_setup_build_dir
tar xzf ../.cache/${MASON_SLUG} $@
}
function mason_extract_tar_bz2 {
mason_setup_build_dir
tar xjf ../.cache/${MASON_SLUG} $@
}
function mason_extract_tar_xz {
mason_setup_build_dir
tar xJf ../.cache/${MASON_SLUG} $@
}
function mason_prepare_compile {
:
}
function mason_compile {
mason_error "COMPILE FUNCTION MISSING"
exit 1
}
function mason_clean {
:
}
function bash_lndir() {
oldifs=$IFS
IFS='
'
src=$(cd "$1" ; pwd)
dst=$(cd "$2" ; pwd)
find "$src" -type d |
while read dir; do
mkdir -p "$dst${dir#$src}"
done
find "$src" -type f -o -type l |
while read src_f; do
dst_f="$dst${src_f#$src}"
if [[ ! -f $dst_f ]]; then
ln -s "$src_f" "$dst_f"
fi
done
IFS=$oldifs
}
function run_lndir() {
# TODO: cp is fast, but inconsistent across osx
#/bin/cp -R -n ${MASON_PREFIX}/* ${TARGET_SUBDIR}
mason_step "Linking ${MASON_PREFIX}"
mason_step "Links will be inside ${TARGET_SUBDIR}"
if hash lndir 2>/dev/null; then
mason_substep "Using $(which lndir) for symlinking"
lndir -silent ${MASON_PREFIX}/ ${TARGET_SUBDIR} 2>/dev/null
else
mason_substep "Using bash fallback for symlinking (install lndir for faster symlinking)"
bash_lndir ${MASON_PREFIX}/ ${TARGET_SUBDIR}
fi
mason_step "Done linking ${MASON_PREFIX}"
}
function mason_link {
if [ ! -d "${MASON_PREFIX}" ] ; then
mason_error "${MASON_PREFIX} not found, please install first"
exit 0
fi
TARGET_SUBDIR="${MASON_ROOT}/.link/"
mkdir -p ${TARGET_SUBDIR}
run_lndir
}
function mason_build {
mason_load_source
mason_step "Building for Platform '${MASON_PLATFORM}/${MASON_PLATFORM_VERSION}'..."
cd "${MASON_BUILD_PATH}"
mason_prepare_compile
if [ ${MASON_PLATFORM} = 'ios' ]; then
SIMULATOR_TARGETS="i386 x86_64"
DEVICE_TARGETS="armv7 arm64"
LIB_FOLDERS=
for ARCH in ${SIMULATOR_TARGETS} ; do
mason_substep "Building for iOS Simulator ${ARCH}..."
export CFLAGS="${MASON_ISIM_CFLAGS} -arch ${ARCH}"
cd "${MASON_BUILD_PATH}"
mason_compile
cd "${MASON_PREFIX}"
mv lib lib-isim-${ARCH}
for i in lib-isim-${ARCH}/*.a ; do lipo -info $i ; done
LIB_FOLDERS="${LIB_FOLDERS} lib-isim-${ARCH}"
done
for ARCH in ${DEVICE_TARGETS} ; do
mason_substep "Building for iOS ${ARCH}..."
export CFLAGS="${MASON_IOS_CFLAGS} -arch ${ARCH}"
cd "${MASON_BUILD_PATH}"
mason_compile
cd "${MASON_PREFIX}"
mv lib lib-ios-${ARCH}
for i in lib-ios-${ARCH}/*.a ; do lipo -info $i ; done
LIB_FOLDERS="${LIB_FOLDERS} lib-ios-${ARCH}"
done
# Create universal binary
mason_substep "Creating Universal Binary..."
cd "${MASON_PREFIX}"
mkdir -p lib
for LIB in $(find ${LIB_FOLDERS} -name "*.a" | xargs basename | sort | uniq) ; do
lipo -create $(find ${LIB_FOLDERS} -name "${LIB}") -output lib/${LIB}
lipo -info lib/${LIB}
done
cd "${MASON_PREFIX}"
rm -rf ${LIB_FOLDERS}
elif [ ${MASON_PLATFORM} = 'android' ]; then
cd "${MASON_BUILD_PATH}"
mason_compile
else
cd "${MASON_BUILD_PATH}"
mason_compile
fi
mason_success "Installed at ${MASON_PREFIX}"
#rm -rf ${MASON_ROOT}/.build
}
function mason_config_custom {
# Override this function in your script to add more configuration variables
:
}
function mason_config {
local MASON_CONFIG_CFLAGS MASON_CONFIG_LDFLAGS MASON_CONFIG_STATIC_LIBS MASON_CONFIG_PREFIX LN
local MASON_CONFIG_INCLUDE_DIRS MASON_CONFIG_DEFINITIONS MASON_CONFIG_OPTIONS
MASON_CONFIG_CFLAGS=$(set -e;mason_cflags)
MASON_CONFIG_LDFLAGS=$(set -e;mason_ldflags)
MASON_CONFIG_STATIC_LIBS=$(set -e;mason_static_libs)
MASON_CONFIG_PREFIX="{prefix}"
# Split up the cflags into include dirs, definitions and options.
LN=$'\n'
MASON_CONFIG_CFLAGS="${MASON_CONFIG_CFLAGS// -/${LN}-}"
MASON_CONFIG_INCLUDE_DIRS=$(echo -n "${MASON_CONFIG_CFLAGS}" | sed -nE 's/^-(I|isystem) *([^ ]+)/\2/p' | uniq)
MASON_CONFIG_DEFINITIONS=$(echo -n "${MASON_CONFIG_CFLAGS}" | sed -nE 's/^-(D) *([^ ]+)/\2/p')
MASON_CONFIG_OPTIONS=$(echo -n "${MASON_CONFIG_CFLAGS}" | sed -nE '/^-(D|I|isystem) *([^ ]+)/!p')
echo "name=${MASON_NAME}"
echo "version=${MASON_VERSION}"
if ${MASON_HEADER_ONLY}; then
echo "header_only=${MASON_HEADER_ONLY}"
else
echo "platform=${MASON_PLATFORM}"
echo "platform_version=${MASON_PLATFORM_VERSION}"
fi
for name in include_dirs definitions options ldflags static_libs ; do
eval value=\$MASON_CONFIG_$(echo ${name} | tr '[:lower:]' '[:upper:]')
if [ ! -z "${value}" ]; then
echo ${name}=${value//${MASON_PREFIX}/${MASON_CONFIG_PREFIX}}
fi
done
mason_config_custom
}
function mason_write_config {
local INI_FILE
INI_FILE="${MASON_PREFIX}/mason.ini"
echo "`mason_config`" > "${INI_FILE}"
mason_substep "Wrote configuration file ${INI_FILE}:"
cat ${INI_FILE}
}
function mason_try_binary {
MASON_BINARIES_DIR=`dirname "${MASON_BINARIES}"`
mkdir -p "${MASON_ROOT}/.binaries/${MASON_BINARIES_DIR}"
# try downloading from S3
if [ ! -f "${MASON_BINARIES_PATH}" ] ; then
mason_step "Downloading binary package ${MASON_BINARIES}..."
curl --retry 3 ${MASON_CURL_ARGS} -f -L \
https://${MASON_BUCKET}.s3.amazonaws.com/${MASON_BINARIES} \
-o "${MASON_BINARIES_PATH}.tmp" && \
mv "${MASON_BINARIES_PATH}.tmp" "${MASON_BINARIES_PATH}" || \
mason_step "Binary not available yet for https://${MASON_BUCKET}.s3.amazonaws.com/${MASON_BINARIES}"
else
mason_step "Updating binary package ${MASON_BINARIES}..."
curl --retry 3 ${MASON_CURL_ARGS} -f -L -z "${MASON_BINARIES_PATH}" \
https://${MASON_BUCKET}.s3.amazonaws.com/${MASON_BINARIES} \
-o "${MASON_BINARIES_PATH}.tmp"
if [ $? -eq 0 ] ; then
if [ -f "${MASON_BINARIES_PATH}.tmp" ]; then
mv "${MASON_BINARIES_PATH}.tmp" "${MASON_BINARIES_PATH}"
else
mason_step "Binary package is still up to date"
fi
else
mason_step "Binary not available yet for ${MASON_BINARIES}"
fi
fi
# unzip the file if it exists
if [ -f "${MASON_BINARIES_PATH}" ] ; then
mkdir -p "${MASON_PREFIX}"
cd "${MASON_PREFIX}"
# Try to force the ownership of the unpacked files
# to the current user using fakeroot if available
`which fakeroot` tar xzf "${MASON_BINARIES_PATH}"
if [ ! -z ${MASON_PKGCONFIG_FILE:-} ] ; then
if [ -f "${MASON_PREFIX}/${MASON_PKGCONFIG_FILE}" ] ; then
# Change the prefix
MASON_ESCAPED_PREFIX=$(echo "${MASON_PREFIX}" | sed -e 's/[\/&]/\\&/g')
sed -i.bak "s/prefix=.*/prefix=${MASON_ESCAPED_PREFIX}/" \
"${MASON_PREFIX}/${MASON_PKGCONFIG_FILE}"
fi
fi
mason_success "Installed binary package at ${MASON_PREFIX}"
exit 0
fi
}
function mason_pkgconfig {
echo pkg-config \
${MASON_PREFIX}/${MASON_PKGCONFIG_FILE}
}
function mason_cflags {
local FLAGS
FLAGS=$(set -e;`mason_pkgconfig` --static --cflags)
# Replace double-prefix in case we use a sysroot.
echo ${FLAGS//${MASON_SYSROOT}${MASON_PREFIX}/${MASON_PREFIX}}
}
function mason_ldflags {
local FLAGS
FLAGS=$(set -e;`mason_pkgconfig` --static --libs)
# Replace double-prefix in case we use a sysroot.
echo ${FLAGS//${MASON_SYSROOT}${MASON_PREFIX}/${MASON_PREFIX}}
}
function mason_static_libs {
if [ -z "${MASON_LIB_FILE}" ]; then
mason_substep "Linking ${MASON_NAME} ${MASON_VERSION} dynamically"
elif [ -f "${MASON_PREFIX}/${MASON_LIB_FILE}" ]; then
echo "${MASON_PREFIX}/${MASON_LIB_FILE}"
else
mason_error "No static library file '${MASON_PREFIX}/${MASON_LIB_FILE}'"
exit 1
fi
}
function mason_prefix {
echo ${MASON_PREFIX}
}
function mason_version {
if [ ${MASON_SYSTEM_PACKAGE:-false} = true ]; then
mason_system_version
else
echo ${MASON_VERSION}
fi
}
function mason_list_existing_package {
local PREFIX RESULT
PREFIX=$1
RESULT=$(aws s3api head-object --bucket mason-binaries --key $PREFIX/$MASON_NAME/$MASON_VERSION.tar.gz 2>/dev/null)
if [ ! -z "${RESULT}" ]; then
printf "%-30s %6.1fM %s\n" \
"${PREFIX}" \
"$(bc -l <<< "$(echo ${RESULT} | jq -r .ContentLength) / 1000000")" \
"$(echo ${RESULT} | jq -r .LastModified)"
else
printf "%-30s %s\n" "${PREFIX}" "<missing>"
fi
}
function mason_list_existing {
if [ ${MASON_SYSTEM_PACKAGE:-false} = true ]; then
mason_error "System packages don't have published packages."
exit 1
elif [ ${MASON_HEADER_ONLY:-false} = true ]; then
mason_list_existing_package headers
else
for PREFIX in $(jq -r .CommonPrefixes[].Prefix[0:-1] <<< "$(aws s3api list-objects --bucket=mason-binaries --delimiter=/)") ; do
if [ ${PREFIX} != "headers" -a ${PREFIX} != "prebuilt" ] ; then
mason_list_existing_package ${PREFIX}
fi
done
fi
}
function mason_publish {
local CONTENT_TYPE DATE MD5 SIGNATURE
if [ ! ${MASON_HEADER_ONLY:-false} = true ] && [ ! -z ${MASON_LIB_FILE:-} ] && [ ! -f "${MASON_PREFIX}/${MASON_LIB_FILE}" ]; then
mason_error "Required library file ${MASON_PREFIX}/${MASON_LIB_FILE} doesn't exist."
exit 1
fi
if [ -z "${AWS_ACCESS_KEY_ID}" ]; then
mason_error "AWS_ACCESS_KEY_ID is not set."
exit 1
fi
if [ -z "${AWS_SECRET_ACCESS_KEY}" ]; then
mason_error "AWS_SECRET_ACCESS_KEY is not set."
exit 1
fi
mkdir -p `dirname ${MASON_BINARIES_PATH}`
cd "${MASON_PREFIX}"
rm -rf "${MASON_BINARIES_PATH}"
tar czf "${MASON_BINARIES_PATH}" .
(cd "${MASON_ROOT}/.binaries" && ls -lh "${MASON_BINARIES}")
mason_step "Uploading binary package..."
CONTENT_TYPE="application/octet-stream"
DATE="$(LC_ALL=C date -u +"%a, %d %b %Y %X %z")"
MD5="$(openssl md5 -binary < "${MASON_BINARIES_PATH}" | base64)"
SIGNATURE="$(printf "PUT\n$MD5\n$CONTENT_TYPE\n$DATE\nx-amz-acl:public-read\n/${MASON_BUCKET}/${MASON_BINARIES}" | openssl sha1 -binary -hmac "$AWS_SECRET_ACCESS_KEY" | base64)"
curl -S -T "${MASON_BINARIES_PATH}" https://${MASON_BUCKET}.s3.amazonaws.com/${MASON_BINARIES} \
-H "Date: $DATE" \
-H "Authorization: AWS $AWS_ACCESS_KEY_ID:$SIGNATURE" \
-H "Content-Type: $CONTENT_TYPE" \
-H "Content-MD5: $MD5" \
-H "x-amz-acl: public-read"
echo https://${MASON_BUCKET}.s3.amazonaws.com/${MASON_BINARIES}
curl -f -I https://${MASON_BUCKET}.s3.amazonaws.com/${MASON_BINARIES}
}
function mason_run {
if [ "$1" == "install" ]; then
if [ ${MASON_SYSTEM_PACKAGE:-false} = true ]; then
mason_check_existing
mason_clear_existing
mason_build
mason_write_config
mason_success "Installed system-provided ${MASON_NAME} $(set -e;mason_system_version)"
else
mason_check_existing
mason_clear_existing
mason_try_binary
mason_build
mason_write_config
fi
elif [ "$1" == "link" ]; then
mason_link
elif [ "$1" == "remove" ]; then
mason_clear_existing
elif [ "$1" == "publish" ]; then
mason_publish
elif [ "$1" == "build" ]; then
mason_clear_existing
mason_build
mason_write_config
elif [ "$1" == "cflags" ]; then
mason_check_installed
mason_cflags
elif [ "$1" == "ldflags" ]; then
mason_check_installed
mason_ldflags
elif [ "$1" == "config" ]; then
mason_check_installed
mason_config
elif [ "$1" == "static_libs" ]; then
mason_check_installed
mason_static_libs
elif [ "$1" == "version" ]; then
mason_check_installed
mason_version
elif [ "$1" == "prefix" ]; then
mason_prefix
elif [ "$1" == "existing" ]; then
mason_list_existing
elif [ $1 ]; then
mason_error "Unknown command '$1'"
exit 1
else
mason_error "Usage: $0 <command> <lib> <version>"
exit 1
fi
}

23
third_party/mason/scripts/7z/9.20.1/.travis.yml vendored Normal file
View File

@ -0,0 +1,23 @@
language: cpp
sudo: false
matrix:
include:
- os: osx
compiler: clang
- os: linux
compiler: clang
env:
global:
- secure: "clCFM3prHnDocZ8lXlimPxAogvFirD1Zx8cMcFJ/XpkTA/0pCgnhpArM4y/NzLHR57pNZTSCr3p6XZI1c1iTG4Zm8x0sK2A4aTFRahypXNy/e+LzAbtd1y1+dEEDwlJvNNGxizQX4frhOgSNQFDFnWLtmF3stlft5YWyc2kI+FI="
- secure: "jKJErCng8Sk8YJ0IN2FX3lhv7G1LeudMfFBAXViZaXn8w/gWPs+SlfXQmIJ5SruU7U2GQKnAhzbjwXjVAgAh8OAblzny0DDm5Lh5WmwkgAP8JH1LpsBwCYx2S/v8qyR4DX1RVhHS8mQu298180ZDVgGccw+hd8xrE/S5TEQcNfQ="
before_install:
script:
- ./mason build ${MASON_NAME} ${MASON_VERSION}
after_success:
- ./mason publish ${MASON_NAME} ${MASON_VERSION}

45
third_party/mason/scripts/7z/9.20.1/script.sh vendored Executable file
View File

@ -0,0 +1,45 @@
#!/usr/bin/env bash
MASON_NAME=7z
MASON_VERSION=9.20.1
MASON_LIB_FILE=bin/7z
. ${MASON_DIR}/mason.sh
function mason_load_source {
mason_download \
https://downloads.sourceforge.net/project/p7zip/p7zip/9.20.1/p7zip_9.20.1_src_all.tar.bz2 \
30b1ff90105134947c67427bfc5c570857051f50
mason_extract_tar_bz2
export MASON_BUILD_PATH=${MASON_ROOT}/.build/p7zip_${MASON_VERSION}
}
function mason_prepare_compile {
if [ $(uname -s) = 'Darwin' ]; then
cp makefile.macosx_64bits makefile.machine
elif [ $(uname -s) = 'Linux' ]; then
cp makefile.linux_clang_amd64 makefile.linux
fi
}
function mason_compile {
make all3 -j${MASON_CONCURRENCY}
mkdir -p "${MASON_PREFIX}"
cp -rv bin "${MASON_PREFIX}"
}
function mason_cflags {
:
}
function mason_ldflags {
:
}
function mason_clean {
make clean
}
mason_run "$@"

61
third_party/mason/scripts/Qt/system/script.sh vendored Executable file
View File

@ -0,0 +1,61 @@
#!/usr/bin/env bash
MASON_NAME=Qt
MASON_VERSION=system
MASON_SYSTEM_PACKAGE=true
. ${MASON_DIR}/mason.sh
QT_LIBS=(${2:-QtCore})
if hash qmake 2>/dev/null; then
QMAKE_CMD=qmake
#Some systems such as Fedora23 uses qmake-qt5
elif hash qmake-qt5 2>/dev/null; then
QMAKE_CMD=qmake-qt5
elif hash qmake-qt4 2>/dev/null; then
QMAKE_CMD=qmake-qt4
else
mason_error "Can't find qmake executable"
exit 1
fi
# Qt5 libs are called Qt5*, so we have to use the correct name to pkg-config
QT_VERSION_MAJOR=$($QMAKE_CMD -query QT_VERSION | cut -d. -f1)
if [ ${QT_VERSION_MAJOR} -gt 4 ] ; then
QT_LIBS=(${QT_LIBS[@]/#Qt/Qt${QT_VERSION_MAJOR}})
fi
for LIB in ${QT_LIBS[@]} ; do
if ! `pkg-config ${LIB} --exists` ; then
mason_error "Can't find ${LIB}"
exit 1
fi
done
function mason_system_version {
if [ ${QT_VERSION_MAJOR} -gt 4 ] ; then
pkg-config Qt${QT_VERSION_MAJOR}Core --modversion
else
pkg-config QtCore --modversion
fi
}
function mason_build {
:
}
# pkg-config on OS X returns "-framework\ QtCore", which results in invalid arguments.
function cleanup_args {
python -c "import sys, re; print re.sub(r'(-framework)\\\\', r'\\1', ' '.join(sys.argv[1:]))" "$@"
}
function mason_cflags {
echo ${MASON_CFLAGS} $(cleanup_args `pkg-config ${QT_LIBS[@]} --cflags`)
}
function mason_ldflags {
echo ${MASON_LDFLAGS} $(cleanup_args `pkg-config ${QT_LIBS[@]} --libs`)
}
mason_run "$@"

15
third_party/mason/scripts/afl/2.19b/.travis.yml vendored Normal file
View File

@ -0,0 +1,15 @@
language: cpp
sudo: false
env:
global:
- secure: "clCFM3prHnDocZ8lXlimPxAogvFirD1Zx8cMcFJ/XpkTA/0pCgnhpArM4y/NzLHR57pNZTSCr3p6XZI1c1iTG4Zm8x0sK2A4aTFRahypXNy/e+LzAbtd1y1+dEEDwlJvNNGxizQX4frhOgSNQFDFnWLtmF3stlft5YWyc2kI+FI="
- secure: "jKJErCng8Sk8YJ0IN2FX3lhv7G1LeudMfFBAXViZaXn8w/gWPs+SlfXQmIJ5SruU7U2GQKnAhzbjwXjVAgAh8OAblzny0DDm5Lh5WmwkgAP8JH1LpsBwCYx2S/v8qyR4DX1RVhHS8mQu298180ZDVgGccw+hd8xrE/S5TEQcNfQ="
before_install:
script:
- ./mason build ${MASON_NAME} ${MASON_VERSION}
after_success:
- ./mason publish ${MASON_NAME} ${MASON_VERSION}

45
third_party/mason/scripts/afl/2.19b/script.sh vendored Normal file
View File

@ -0,0 +1,45 @@
#!/usr/bin/env bash
MASON_NAME=afl
MASON_VERSION=2.19b
MASON_LIB_FILE=bin/afl-fuzz
. ${MASON_DIR}/mason.sh
function mason_load_source {
mason_download \
http://lcamtuf.coredump.cx/afl/releases/afl-2.19b.tgz \
6627c7b7c873e26fb7fbb6fd574c93676442d8b2
mason_extract_tar_gz
export MASON_BUILD_PATH=${MASON_ROOT}/.build/${MASON_NAME}-${MASON_VERSION}
}
function mason_prepare_compile {
${MASON_DIR}/mason install clang 3.8.0
MASON_CLANG=$(${MASON_DIR}/mason prefix clang 3.8.0)
}
function mason_compile {
export PATH=${MASON_CLANG}/bin:$PATH CXX=clang++ CC=clang
make -j${MASON_CONCURRENCY}
cd llvm_mode
make -j${MASON_CONCURRENCY}
cd ..
PREFIX=${MASON_PREFIX} make install
}
function mason_cflags {
:
}
function mason_ldflags {
:
}
function mason_static_libs {
:
}
mason_run "$@"

19
third_party/mason/scripts/android-ndk/arm-9-r10e/.travis.yml vendored Normal file
View File

@ -0,0 +1,19 @@
language: cpp
sudo: false
os:
- linux
- osx
env:
global:
- secure: "clCFM3prHnDocZ8lXlimPxAogvFirD1Zx8cMcFJ/XpkTA/0pCgnhpArM4y/NzLHR57pNZTSCr3p6XZI1c1iTG4Zm8x0sK2A4aTFRahypXNy/e+LzAbtd1y1+dEEDwlJvNNGxizQX4frhOgSNQFDFnWLtmF3stlft5YWyc2kI+FI="
- secure: "jKJErCng8Sk8YJ0IN2FX3lhv7G1LeudMfFBAXViZaXn8w/gWPs+SlfXQmIJ5SruU7U2GQKnAhzbjwXjVAgAh8OAblzny0DDm5Lh5WmwkgAP8JH1LpsBwCYx2S/v8qyR4DX1RVhHS8mQu298180ZDVgGccw+hd8xrE/S5TEQcNfQ="
before_install:
script:
- ./mason build ${MASON_NAME} ${MASON_VERSION}
after_success:
- ./mason publish ${MASON_NAME} ${MASON_VERSION}

45
third_party/mason/scripts/android-ndk/arm-9-r10e/script.sh vendored Executable file
View File

@ -0,0 +1,45 @@
#!/usr/bin/env bash
MASON_NAME=android-ndk
MASON_VERSION=arm-9-r10e
MASON_LIB_FILE=
. ${MASON_DIR}/mason.sh
function mason_load_source {
if [ ${MASON_PLATFORM} = 'osx' ]; then
mason_download \
http://dl.google.com/android/ndk/android-ndk-r10e-darwin-x86_64.bin \
dea2dd3939eea3289cab075804abb153014b78d3
elif [ ${MASON_PLATFORM} = 'linux' ]; then
mason_download \
http://dl.google.com/android/ndk/android-ndk-r10e-linux-x86_64.bin \
285606ba6882d27d99ed469fc5533cc3c93967f5
fi
mason_setup_build_dir
chmod +x ../.cache/${MASON_SLUG}
../.cache/${MASON_SLUG} > /dev/null
export MASON_BUILD_PATH=${MASON_ROOT}/.build/android-ndk-r10e
}
function mason_compile {
rm -rf ${MASON_PREFIX}
mkdir -p ${MASON_PREFIX}
${MASON_BUILD_PATH}/build/tools/make-standalone-toolchain.sh \
--toolchain="arm-linux-androideabi-4.9" \
--llvm-version="3.6" \
--package-dir="${MASON_BUILD_PATH}/package-dir/" \
--install-dir="${MASON_PREFIX}" \
--stl="libcxx" \
--arch="arm" \
--platform="android-9"
}
function mason_clean {
make clean
}
mason_run "$@"

19
third_party/mason/scripts/android-ndk/arm-9-r11c/.travis.yml vendored Normal file
View File

@ -0,0 +1,19 @@
language: cpp
sudo: false
os:
- linux
- osx
env:
global:
- secure: "clCFM3prHnDocZ8lXlimPxAogvFirD1Zx8cMcFJ/XpkTA/0pCgnhpArM4y/NzLHR57pNZTSCr3p6XZI1c1iTG4Zm8x0sK2A4aTFRahypXNy/e+LzAbtd1y1+dEEDwlJvNNGxizQX4frhOgSNQFDFnWLtmF3stlft5YWyc2kI+FI="
- secure: "jKJErCng8Sk8YJ0IN2FX3lhv7G1LeudMfFBAXViZaXn8w/gWPs+SlfXQmIJ5SruU7U2GQKnAhzbjwXjVAgAh8OAblzny0DDm5Lh5WmwkgAP8JH1LpsBwCYx2S/v8qyR4DX1RVhHS8mQu298180ZDVgGccw+hd8xrE/S5TEQcNfQ="
before_install:
script:
- ./mason build ${MASON_NAME} ${MASON_VERSION}
after_success:
- ./mason publish ${MASON_NAME} ${MASON_VERSION}

45
third_party/mason/scripts/android-ndk/arm-9-r11c/script.sh vendored Executable file
View File

@ -0,0 +1,45 @@
#!/usr/bin/env bash
MASON_NAME=android-ndk
MASON_VERSION=arm-9-r11c
MASON_LIB_FILE=
. ${MASON_DIR}/mason.sh
function mason_load_source {
if [ ${MASON_PLATFORM} = 'osx' ]; then
mason_download \
http://dl.google.com/android/repository/android-ndk-r11c-darwin-x86_64.zip \
0c6fa2017dd5237f6270887c85feedc4aafb3aef
elif [ ${MASON_PLATFORM} = 'linux' ]; then
mason_download \
http://dl.google.com/android/repository/android-ndk-r11c-linux-x86_64.zip \
0c646e2fceb3ef853e1832f4aa3a0dc4c16d2229
fi
mason_setup_build_dir
rm -rf ./android-ndk-r11c
unzip -q ../.cache/${MASON_SLUG} $@
export MASON_BUILD_PATH=${MASON_ROOT}/.build/android-ndk-r11c
}
function mason_compile {
rm -rf ${MASON_PREFIX}
mkdir -p ${MASON_PREFIX}
${MASON_BUILD_PATH}/build/tools/make-standalone-toolchain.sh \
--toolchain="arm-linux-androideabi-clang" \
--use-llvm \
--package-dir="${MASON_BUILD_PATH}/package-dir/" \
--install-dir="${MASON_PREFIX}" \
--stl="libcxx" \
--arch="arm" \
--platform="android-9"
}
function mason_clean {
make clean
}
mason_run "$@"

19
third_party/mason/scripts/android-ndk/arm-9-r12b/.travis.yml vendored Normal file
View File

@ -0,0 +1,19 @@
language: cpp
sudo: false
os:
- linux
- osx
env:
global:
- secure: "clCFM3prHnDocZ8lXlimPxAogvFirD1Zx8cMcFJ/XpkTA/0pCgnhpArM4y/NzLHR57pNZTSCr3p6XZI1c1iTG4Zm8x0sK2A4aTFRahypXNy/e+LzAbtd1y1+dEEDwlJvNNGxizQX4frhOgSNQFDFnWLtmF3stlft5YWyc2kI+FI="
- secure: "jKJErCng8Sk8YJ0IN2FX3lhv7G1LeudMfFBAXViZaXn8w/gWPs+SlfXQmIJ5SruU7U2GQKnAhzbjwXjVAgAh8OAblzny0DDm5Lh5WmwkgAP8JH1LpsBwCYx2S/v8qyR4DX1RVhHS8mQu298180ZDVgGccw+hd8xrE/S5TEQcNfQ="
before_install:
script:
- ./mason build ${MASON_NAME} ${MASON_VERSION}
after_success:
- ./mason publish ${MASON_NAME} ${MASON_VERSION}

47
third_party/mason/scripts/android-ndk/arm-9-r12b/script.sh vendored Executable file
View File

@ -0,0 +1,47 @@
#!/usr/bin/env bash
MASON_NAME=android-ndk
MASON_VERSION=arm-9-r12b
MASON_LIB_FILE=
. ${MASON_DIR}/mason.sh
function mason_load_source {
if [ ${MASON_PLATFORM} = 'osx' ]; then
mason_download \
http://dl.google.com/android/repository/android-ndk-r12b-darwin-x86_64.zip \
1a3bbdde35a240086b022cdf13ddcf40c27caa6e
elif [ ${MASON_PLATFORM} = 'linux' ]; then
mason_download \
http://dl.google.com/android/repository/android-ndk-r12b-linux-x86_64.zip \
c6286e131c233c25537a306eae0a29d50b352b91
fi
mason_setup_build_dir
rm -rf ./android-ndk-r12b
unzip -q ../.cache/${MASON_SLUG} $@
export MASON_BUILD_PATH=${MASON_ROOT}/.build/android-ndk-r12b
}
function mason_compile {
rm -rf ${MASON_PREFIX}
mkdir -p ${MASON_PREFIX}
${MASON_BUILD_PATH}/build/tools/make_standalone_toolchain.py \
--force \
--arch arm \
--api 9 \
--stl libc++ \
--install-dir "${MASON_PREFIX}"
# NDK r12 ships with .so files which are preferred when linking, but cause
# errors on devices when it's not present.
find "${MASON_PREFIX}" -name "libstdc++.so" -delete
}
function mason_clean {
make clean
}
mason_run "$@"

19
third_party/mason/scripts/android-ndk/arm64-21-r10e-gcc/.travis.yml vendored Normal file
View File

@ -0,0 +1,19 @@
language: cpp
sudo: false
os:
- linux
- osx
env:
global:
- secure: "clCFM3prHnDocZ8lXlimPxAogvFirD1Zx8cMcFJ/XpkTA/0pCgnhpArM4y/NzLHR57pNZTSCr3p6XZI1c1iTG4Zm8x0sK2A4aTFRahypXNy/e+LzAbtd1y1+dEEDwlJvNNGxizQX4frhOgSNQFDFnWLtmF3stlft5YWyc2kI+FI="
- secure: "jKJErCng8Sk8YJ0IN2FX3lhv7G1LeudMfFBAXViZaXn8w/gWPs+SlfXQmIJ5SruU7U2GQKnAhzbjwXjVAgAh8OAblzny0DDm5Lh5WmwkgAP8JH1LpsBwCYx2S/v8qyR4DX1RVhHS8mQu298180ZDVgGccw+hd8xrE/S5TEQcNfQ="
before_install:
script:
- ./mason build ${MASON_NAME} ${MASON_VERSION}
after_success:
- ./mason publish ${MASON_NAME} ${MASON_VERSION}

43
third_party/mason/scripts/android-ndk/arm64-21-r10e-gcc/script.sh vendored Executable file
View File

@ -0,0 +1,43 @@
#!/usr/bin/env bash
MASON_NAME=android-ndk
MASON_VERSION=arm64-21-r10e-gcc
MASON_LIB_FILE=
. ${MASON_DIR}/mason.sh
function mason_load_source {
if [ ${MASON_PLATFORM} = 'osx' ]; then
mason_download \
http://dl.google.com/android/ndk/android-ndk-r10e-darwin-x86_64.bin \
dea2dd3939eea3289cab075804abb153014b78d3
elif [ ${MASON_PLATFORM} = 'linux' ]; then
mason_download \
http://dl.google.com/android/ndk/android-ndk-r10e-linux-x86_64.bin \
285606ba6882d27d99ed469fc5533cc3c93967f5
fi
mason_setup_build_dir
chmod +x ../.cache/${MASON_SLUG}
../.cache/${MASON_SLUG} > /dev/null
export MASON_BUILD_PATH=${MASON_ROOT}/.build/android-ndk-r10e
}
function mason_compile {
rm -rf ${MASON_PREFIX}
mkdir -p ${MASON_PREFIX}
${MASON_BUILD_PATH}/build/tools/make-standalone-toolchain.sh \
--toolchain="aarch64-linux-android-4.9" \
--package-dir="${MASON_BUILD_PATH}/package-dir/" \
--install-dir="${MASON_PREFIX}" \
--arch="arm64" \
--platform="android-21"
}
function mason_clean {
make clean
}
mason_run "$@"

19
third_party/mason/scripts/android-ndk/arm64-21-r10e/.travis.yml vendored Normal file
View File

@ -0,0 +1,19 @@
language: cpp
sudo: false
os:
- linux
- osx
env:
global:
- secure: "clCFM3prHnDocZ8lXlimPxAogvFirD1Zx8cMcFJ/XpkTA/0pCgnhpArM4y/NzLHR57pNZTSCr3p6XZI1c1iTG4Zm8x0sK2A4aTFRahypXNy/e+LzAbtd1y1+dEEDwlJvNNGxizQX4frhOgSNQFDFnWLtmF3stlft5YWyc2kI+FI="
- secure: "jKJErCng8Sk8YJ0IN2FX3lhv7G1LeudMfFBAXViZaXn8w/gWPs+SlfXQmIJ5SruU7U2GQKnAhzbjwXjVAgAh8OAblzny0DDm5Lh5WmwkgAP8JH1LpsBwCYx2S/v8qyR4DX1RVhHS8mQu298180ZDVgGccw+hd8xrE/S5TEQcNfQ="
before_install:
script:
- ./mason build ${MASON_NAME} ${MASON_VERSION}
after_success:
- ./mason publish ${MASON_NAME} ${MASON_VERSION}

45
third_party/mason/scripts/android-ndk/arm64-21-r10e/script.sh vendored Executable file
View File

@ -0,0 +1,45 @@
#!/usr/bin/env bash
MASON_NAME=android-ndk
MASON_VERSION=arm64-21-r10e
MASON_LIB_FILE=
. ${MASON_DIR}/mason.sh
function mason_load_source {
if [ ${MASON_PLATFORM} = 'osx' ]; then
mason_download \
http://dl.google.com/android/ndk/android-ndk-r10e-darwin-x86_64.bin \
dea2dd3939eea3289cab075804abb153014b78d3
elif [ ${MASON_PLATFORM} = 'linux' ]; then
mason_download \
http://dl.google.com/android/ndk/android-ndk-r10e-linux-x86_64.bin \
285606ba6882d27d99ed469fc5533cc3c93967f5
fi
mason_setup_build_dir
chmod +x ../.cache/${MASON_SLUG}
../.cache/${MASON_SLUG} > /dev/null
export MASON_BUILD_PATH=${MASON_ROOT}/.build/android-ndk-r10e
}
function mason_compile {
rm -rf ${MASON_PREFIX}
mkdir -p ${MASON_PREFIX}
${MASON_BUILD_PATH}/build/tools/make-standalone-toolchain.sh \
--toolchain="aarch64-linux-android-4.9" \
--llvm-version="3.6" \
--package-dir="${MASON_BUILD_PATH}/package-dir/" \
--install-dir="${MASON_PREFIX}" \
--stl="libcxx" \
--arch="arm64" \
--platform="android-21"
}
function mason_clean {
make clean
}
mason_run "$@"

19
third_party/mason/scripts/android-ndk/arm64-21-r11c/.travis.yml vendored Normal file
View File

@ -0,0 +1,19 @@
language: cpp
sudo: false
os:
- linux
- osx
env:
global:
- secure: "clCFM3prHnDocZ8lXlimPxAogvFirD1Zx8cMcFJ/XpkTA/0pCgnhpArM4y/NzLHR57pNZTSCr3p6XZI1c1iTG4Zm8x0sK2A4aTFRahypXNy/e+LzAbtd1y1+dEEDwlJvNNGxizQX4frhOgSNQFDFnWLtmF3stlft5YWyc2kI+FI="
- secure: "jKJErCng8Sk8YJ0IN2FX3lhv7G1LeudMfFBAXViZaXn8w/gWPs+SlfXQmIJ5SruU7U2GQKnAhzbjwXjVAgAh8OAblzny0DDm5Lh5WmwkgAP8JH1LpsBwCYx2S/v8qyR4DX1RVhHS8mQu298180ZDVgGccw+hd8xrE/S5TEQcNfQ="
before_install:
script:
- ./mason build ${MASON_NAME} ${MASON_VERSION}
after_success:
- ./mason publish ${MASON_NAME} ${MASON_VERSION}

45
third_party/mason/scripts/android-ndk/arm64-21-r11c/script.sh vendored Executable file
View File

@ -0,0 +1,45 @@
#!/usr/bin/env bash
MASON_NAME=android-ndk
MASON_VERSION=arm64-21-r11c
MASON_LIB_FILE=
. ${MASON_DIR}/mason.sh
function mason_load_source {
if [ ${MASON_PLATFORM} = 'osx' ]; then
mason_download \
http://dl.google.com/android/repository/android-ndk-r11c-darwin-x86_64.zip \
0c6fa2017dd5237f6270887c85feedc4aafb3aef
elif [ ${MASON_PLATFORM} = 'linux' ]; then
mason_download \
http://dl.google.com/android/repository/android-ndk-r11c-linux-x86_64.zip \
0c646e2fceb3ef853e1832f4aa3a0dc4c16d2229
fi
mason_setup_build_dir
rm -rf ./android-ndk-r11c
unzip -q ../.cache/${MASON_SLUG} $@
export MASON_BUILD_PATH=${MASON_ROOT}/.build/android-ndk-r11c
}
function mason_compile {
rm -rf ${MASON_PREFIX}
mkdir -p ${MASON_PREFIX}
${MASON_BUILD_PATH}/build/tools/make-standalone-toolchain.sh \
--toolchain="aarch64-linux-android-clang" \
--use-llvm \
--package-dir="${MASON_BUILD_PATH}/package-dir/" \
--install-dir="${MASON_PREFIX}" \
--stl="libcxx" \
--arch="arm64" \
--platform="android-21"
}
function mason_clean {
make clean
}
mason_run "$@"

19
third_party/mason/scripts/android-ndk/arm64-21-r12b/.travis.yml vendored Normal file
View File

@ -0,0 +1,19 @@
language: cpp
sudo: false
os:
- linux
- osx
env:
global:
- secure: "clCFM3prHnDocZ8lXlimPxAogvFirD1Zx8cMcFJ/XpkTA/0pCgnhpArM4y/NzLHR57pNZTSCr3p6XZI1c1iTG4Zm8x0sK2A4aTFRahypXNy/e+LzAbtd1y1+dEEDwlJvNNGxizQX4frhOgSNQFDFnWLtmF3stlft5YWyc2kI+FI="
- secure: "jKJErCng8Sk8YJ0IN2FX3lhv7G1LeudMfFBAXViZaXn8w/gWPs+SlfXQmIJ5SruU7U2GQKnAhzbjwXjVAgAh8OAblzny0DDm5Lh5WmwkgAP8JH1LpsBwCYx2S/v8qyR4DX1RVhHS8mQu298180ZDVgGccw+hd8xrE/S5TEQcNfQ="
before_install:
script:
- ./mason build ${MASON_NAME} ${MASON_VERSION}
after_success:
- ./mason publish ${MASON_NAME} ${MASON_VERSION}

47
third_party/mason/scripts/android-ndk/arm64-21-r12b/script.sh vendored Executable file
View File

@ -0,0 +1,47 @@
#!/usr/bin/env bash
MASON_NAME=android-ndk
MASON_VERSION=arm64-21-r12b
MASON_LIB_FILE=
. ${MASON_DIR}/mason.sh
function mason_load_source {
if [ ${MASON_PLATFORM} = 'osx' ]; then
mason_download \
http://dl.google.com/android/repository/android-ndk-r12b-darwin-x86_64.zip \
1a3bbdde35a240086b022cdf13ddcf40c27caa6e
elif [ ${MASON_PLATFORM} = 'linux' ]; then
mason_download \
http://dl.google.com/android/repository/android-ndk-r12b-linux-x86_64.zip \
c6286e131c233c25537a306eae0a29d50b352b91
fi
mason_setup_build_dir
rm -rf ./android-ndk-r12b
unzip -q ../.cache/${MASON_SLUG} $@
export MASON_BUILD_PATH=${MASON_ROOT}/.build/android-ndk-r12b
}
function mason_compile {
rm -rf ${MASON_PREFIX}
mkdir -p ${MASON_PREFIX}
${MASON_BUILD_PATH}/build/tools/make_standalone_toolchain.py \
--force \
--arch arm64 \
--api 21 \
--stl libc++ \
--install-dir "${MASON_PREFIX}"
# NDK r12 ships with .so files which are preferred when linking, but cause
# errors on devices when it's not present.
find "${MASON_PREFIX}" -name "libstdc++.so" -delete
}
function mason_clean {
make clean
}
mason_run "$@"

19
third_party/mason/scripts/android-ndk/mips-9-r10e/.travis.yml vendored Normal file
View File

@ -0,0 +1,19 @@
language: cpp
sudo: false
os:
- linux
- osx
env:
global:
- secure: "clCFM3prHnDocZ8lXlimPxAogvFirD1Zx8cMcFJ/XpkTA/0pCgnhpArM4y/NzLHR57pNZTSCr3p6XZI1c1iTG4Zm8x0sK2A4aTFRahypXNy/e+LzAbtd1y1+dEEDwlJvNNGxizQX4frhOgSNQFDFnWLtmF3stlft5YWyc2kI+FI="
- secure: "jKJErCng8Sk8YJ0IN2FX3lhv7G1LeudMfFBAXViZaXn8w/gWPs+SlfXQmIJ5SruU7U2GQKnAhzbjwXjVAgAh8OAblzny0DDm5Lh5WmwkgAP8JH1LpsBwCYx2S/v8qyR4DX1RVhHS8mQu298180ZDVgGccw+hd8xrE/S5TEQcNfQ="
before_install:
script:
- ./mason build ${MASON_NAME} ${MASON_VERSION}
after_success:
- ./mason publish ${MASON_NAME} ${MASON_VERSION}

45
third_party/mason/scripts/android-ndk/mips-9-r10e/script.sh vendored Executable file
View File

@ -0,0 +1,45 @@
#!/usr/bin/env bash
MASON_NAME=android-ndk
MASON_VERSION=mips-9-r10e
MASON_LIB_FILE=
. ${MASON_DIR}/mason.sh
function mason_load_source {
if [ ${MASON_PLATFORM} = 'osx' ]; then
mason_download \
http://dl.google.com/android/ndk/android-ndk-r10e-darwin-x86_64.bin \
dea2dd3939eea3289cab075804abb153014b78d3
elif [ ${MASON_PLATFORM} = 'linux' ]; then
mason_download \
http://dl.google.com/android/ndk/android-ndk-r10e-linux-x86_64.bin \
285606ba6882d27d99ed469fc5533cc3c93967f5
fi
mason_setup_build_dir
chmod +x ../.cache/${MASON_SLUG}
../.cache/${MASON_SLUG} > /dev/null
export MASON_BUILD_PATH=${MASON_ROOT}/.build/android-ndk-r10e
}
function mason_compile {
rm -rf ${MASON_PREFIX}
mkdir -p ${MASON_PREFIX}
${MASON_BUILD_PATH}/build/tools/make-standalone-toolchain.sh \
--toolchain="mipsel-linux-android-4.9" \
--llvm-version="3.6" \
--package-dir="${MASON_BUILD_PATH}/package-dir/" \
--install-dir="${MASON_PREFIX}" \
--stl="libcxx" \
--arch="mips" \
--platform="android-9"
}
function mason_clean {
make clean
}
mason_run "$@"

19
third_party/mason/scripts/android-ndk/mips-9-r11c/.travis.yml vendored Normal file
View File

@ -0,0 +1,19 @@
language: cpp
sudo: false
os:
- linux
- osx
env:
global:
- secure: "clCFM3prHnDocZ8lXlimPxAogvFirD1Zx8cMcFJ/XpkTA/0pCgnhpArM4y/NzLHR57pNZTSCr3p6XZI1c1iTG4Zm8x0sK2A4aTFRahypXNy/e+LzAbtd1y1+dEEDwlJvNNGxizQX4frhOgSNQFDFnWLtmF3stlft5YWyc2kI+FI="
- secure: "jKJErCng8Sk8YJ0IN2FX3lhv7G1LeudMfFBAXViZaXn8w/gWPs+SlfXQmIJ5SruU7U2GQKnAhzbjwXjVAgAh8OAblzny0DDm5Lh5WmwkgAP8JH1LpsBwCYx2S/v8qyR4DX1RVhHS8mQu298180ZDVgGccw+hd8xrE/S5TEQcNfQ="
before_install:
script:
- ./mason build ${MASON_NAME} ${MASON_VERSION}
after_success:
- ./mason publish ${MASON_NAME} ${MASON_VERSION}

45
third_party/mason/scripts/android-ndk/mips-9-r11c/script.sh vendored Executable file
View File

@ -0,0 +1,45 @@
#!/usr/bin/env bash
MASON_NAME=android-ndk
MASON_VERSION=mips-9-r11c
MASON_LIB_FILE=
. ${MASON_DIR}/mason.sh
function mason_load_source {
if [ ${MASON_PLATFORM} = 'osx' ]; then
mason_download \
http://dl.google.com/android/repository/android-ndk-r11c-darwin-x86_64.zip \
0c6fa2017dd5237f6270887c85feedc4aafb3aef
elif [ ${MASON_PLATFORM} = 'linux' ]; then
mason_download \
http://dl.google.com/android/repository/android-ndk-r11c-linux-x86_64.zip \
0c646e2fceb3ef853e1832f4aa3a0dc4c16d2229
fi
mason_setup_build_dir
rm -rf ./android-ndk-r11c
unzip -q ../.cache/${MASON_SLUG} $@
export MASON_BUILD_PATH=${MASON_ROOT}/.build/android-ndk-r11c
}
function mason_compile {
rm -rf ${MASON_PREFIX}
mkdir -p ${MASON_PREFIX}
${MASON_BUILD_PATH}/build/tools/make-standalone-toolchain.sh \
--toolchain="mipsel-linux-android-clang" \
--use-llvm \
--package-dir="${MASON_BUILD_PATH}/package-dir/" \
--install-dir="${MASON_PREFIX}" \
--stl="libcxx" \
--arch="mips" \
--platform="android-9"
}
function mason_clean {
make clean
}
mason_run "$@"

19
third_party/mason/scripts/android-ndk/mips-9-r12b/.travis.yml vendored Normal file
View File

@ -0,0 +1,19 @@
language: cpp
sudo: false
os:
- linux
- osx
env:
global:
- secure: "clCFM3prHnDocZ8lXlimPxAogvFirD1Zx8cMcFJ/XpkTA/0pCgnhpArM4y/NzLHR57pNZTSCr3p6XZI1c1iTG4Zm8x0sK2A4aTFRahypXNy/e+LzAbtd1y1+dEEDwlJvNNGxizQX4frhOgSNQFDFnWLtmF3stlft5YWyc2kI+FI="
- secure: "jKJErCng8Sk8YJ0IN2FX3lhv7G1LeudMfFBAXViZaXn8w/gWPs+SlfXQmIJ5SruU7U2GQKnAhzbjwXjVAgAh8OAblzny0DDm5Lh5WmwkgAP8JH1LpsBwCYx2S/v8qyR4DX1RVhHS8mQu298180ZDVgGccw+hd8xrE/S5TEQcNfQ="
before_install:
script:
- ./mason build ${MASON_NAME} ${MASON_VERSION}
after_success:
- ./mason publish ${MASON_NAME} ${MASON_VERSION}

47
third_party/mason/scripts/android-ndk/mips-9-r12b/script.sh vendored Executable file
View File

@ -0,0 +1,47 @@
#!/usr/bin/env bash
MASON_NAME=android-ndk
MASON_VERSION=mips-9-r12b
MASON_LIB_FILE=
. ${MASON_DIR}/mason.sh
function mason_load_source {
if [ ${MASON_PLATFORM} = 'osx' ]; then
mason_download \
http://dl.google.com/android/repository/android-ndk-r12b-darwin-x86_64.zip \
1a3bbdde35a240086b022cdf13ddcf40c27caa6e
elif [ ${MASON_PLATFORM} = 'linux' ]; then
mason_download \
http://dl.google.com/android/repository/android-ndk-r12b-linux-x86_64.zip \
c6286e131c233c25537a306eae0a29d50b352b91
fi
mason_setup_build_dir
rm -rf ./android-ndk-r12b
unzip -q ../.cache/${MASON_SLUG} $@
export MASON_BUILD_PATH=${MASON_ROOT}/.build/android-ndk-r12b
}
function mason_compile {
rm -rf ${MASON_PREFIX}
mkdir -p ${MASON_PREFIX}
${MASON_BUILD_PATH}/build/tools/make_standalone_toolchain.py \
--force \
--arch mips \
--api 9 \
--stl libc++ \
--install-dir "${MASON_PREFIX}"
# NDK r12 ships with .so files which are preferred when linking, but cause
# errors on devices when it's not present.
find "${MASON_PREFIX}" -name "libstdc++.so" -delete
}
function mason_clean {
make clean
}
mason_run "$@"

19
third_party/mason/scripts/android-ndk/mips64-21-r10e/.travis.yml vendored Normal file
View File

@ -0,0 +1,19 @@
language: cpp
sudo: false
os:
- linux
- osx
env:
global:
- secure: "clCFM3prHnDocZ8lXlimPxAogvFirD1Zx8cMcFJ/XpkTA/0pCgnhpArM4y/NzLHR57pNZTSCr3p6XZI1c1iTG4Zm8x0sK2A4aTFRahypXNy/e+LzAbtd1y1+dEEDwlJvNNGxizQX4frhOgSNQFDFnWLtmF3stlft5YWyc2kI+FI="
- secure: "jKJErCng8Sk8YJ0IN2FX3lhv7G1LeudMfFBAXViZaXn8w/gWPs+SlfXQmIJ5SruU7U2GQKnAhzbjwXjVAgAh8OAblzny0DDm5Lh5WmwkgAP8JH1LpsBwCYx2S/v8qyR4DX1RVhHS8mQu298180ZDVgGccw+hd8xrE/S5TEQcNfQ="
before_install:
script:
- ./mason build ${MASON_NAME} ${MASON_VERSION}
after_success:
- ./mason publish ${MASON_NAME} ${MASON_VERSION}

45
third_party/mason/scripts/android-ndk/mips64-21-r10e/script.sh vendored Executable file
View File

@ -0,0 +1,45 @@
#!/usr/bin/env bash
MASON_NAME=android-ndk
MASON_VERSION=mips64-21-r10e
MASON_LIB_FILE=
. ${MASON_DIR}/mason.sh
function mason_load_source {
if [ ${MASON_PLATFORM} = 'osx' ]; then
mason_download \
http://dl.google.com/android/ndk/android-ndk-r10e-darwin-x86_64.bin \
dea2dd3939eea3289cab075804abb153014b78d3
elif [ ${MASON_PLATFORM} = 'linux' ]; then
mason_download \
http://dl.google.com/android/ndk/android-ndk-r10e-linux-x86_64.bin \
285606ba6882d27d99ed469fc5533cc3c93967f5
fi
mason_setup_build_dir
chmod +x ../.cache/${MASON_SLUG}
../.cache/${MASON_SLUG} > /dev/null
export MASON_BUILD_PATH=${MASON_ROOT}/.build/android-ndk-r10e
}
function mason_compile {
rm -rf ${MASON_PREFIX}
mkdir -p ${MASON_PREFIX}
${MASON_BUILD_PATH}/build/tools/make-standalone-toolchain.sh \
--toolchain="mips64el-linux-android-4.9" \
--llvm-version="3.6" \
--package-dir="${MASON_BUILD_PATH}/package-dir/" \
--install-dir="${MASON_PREFIX}" \
--stl="libcxx" \
--arch="mips64" \
--platform="android-21"
}
function mason_clean {
make clean
}
mason_run "$@"

19
third_party/mason/scripts/android-ndk/mips64-21-r11c/.travis.yml vendored Normal file
View File

@ -0,0 +1,19 @@
language: cpp
sudo: false
os:
- linux
- osx
env:
global:
- secure: "clCFM3prHnDocZ8lXlimPxAogvFirD1Zx8cMcFJ/XpkTA/0pCgnhpArM4y/NzLHR57pNZTSCr3p6XZI1c1iTG4Zm8x0sK2A4aTFRahypXNy/e+LzAbtd1y1+dEEDwlJvNNGxizQX4frhOgSNQFDFnWLtmF3stlft5YWyc2kI+FI="
- secure: "jKJErCng8Sk8YJ0IN2FX3lhv7G1LeudMfFBAXViZaXn8w/gWPs+SlfXQmIJ5SruU7U2GQKnAhzbjwXjVAgAh8OAblzny0DDm5Lh5WmwkgAP8JH1LpsBwCYx2S/v8qyR4DX1RVhHS8mQu298180ZDVgGccw+hd8xrE/S5TEQcNfQ="
before_install:
script:
- ./mason build ${MASON_NAME} ${MASON_VERSION}
after_success:
- ./mason publish ${MASON_NAME} ${MASON_VERSION}

45
third_party/mason/scripts/android-ndk/mips64-21-r11c/script.sh vendored Executable file
View File

@ -0,0 +1,45 @@
#!/usr/bin/env bash
MASON_NAME=android-ndk
MASON_VERSION=mips64-21-r11c
MASON_LIB_FILE=
. ${MASON_DIR}/mason.sh
function mason_load_source {
if [ ${MASON_PLATFORM} = 'osx' ]; then
mason_download \
http://dl.google.com/android/repository/android-ndk-r11c-darwin-x86_64.zip \
0c6fa2017dd5237f6270887c85feedc4aafb3aef
elif [ ${MASON_PLATFORM} = 'linux' ]; then
mason_download \
http://dl.google.com/android/repository/android-ndk-r11c-linux-x86_64.zip \
0c646e2fceb3ef853e1832f4aa3a0dc4c16d2229
fi
mason_setup_build_dir
rm -rf ./android-ndk-r11c
unzip -q ../.cache/${MASON_SLUG} $@
export MASON_BUILD_PATH=${MASON_ROOT}/.build/android-ndk-r11c
}
function mason_compile {
rm -rf ${MASON_PREFIX}
mkdir -p ${MASON_PREFIX}
${MASON_BUILD_PATH}/build/tools/make-standalone-toolchain.sh \
--toolchain="mips64el-linux-android-clang" \
--use-llvm \
--package-dir="${MASON_BUILD_PATH}/package-dir/" \
--install-dir="${MASON_PREFIX}" \
--stl="libcxx" \
--arch="mips64" \
--platform="android-21"
}
function mason_clean {
make clean
}
mason_run "$@"

19
third_party/mason/scripts/android-ndk/mips64-21-r12b/.travis.yml vendored Normal file
View File

@ -0,0 +1,19 @@
language: cpp
sudo: false
os:
- linux
- osx
env:
global:
- secure: "clCFM3prHnDocZ8lXlimPxAogvFirD1Zx8cMcFJ/XpkTA/0pCgnhpArM4y/NzLHR57pNZTSCr3p6XZI1c1iTG4Zm8x0sK2A4aTFRahypXNy/e+LzAbtd1y1+dEEDwlJvNNGxizQX4frhOgSNQFDFnWLtmF3stlft5YWyc2kI+FI="
- secure: "jKJErCng8Sk8YJ0IN2FX3lhv7G1LeudMfFBAXViZaXn8w/gWPs+SlfXQmIJ5SruU7U2GQKnAhzbjwXjVAgAh8OAblzny0DDm5Lh5WmwkgAP8JH1LpsBwCYx2S/v8qyR4DX1RVhHS8mQu298180ZDVgGccw+hd8xrE/S5TEQcNfQ="
before_install:
script:
- ./mason build ${MASON_NAME} ${MASON_VERSION}
after_success:
- ./mason publish ${MASON_NAME} ${MASON_VERSION}

47
third_party/mason/scripts/android-ndk/mips64-21-r12b/script.sh vendored Executable file
View File

@ -0,0 +1,47 @@
#!/usr/bin/env bash
MASON_NAME=android-ndk
MASON_VERSION=mips64-21-r12b
MASON_LIB_FILE=
. ${MASON_DIR}/mason.sh
function mason_load_source {
if [ ${MASON_PLATFORM} = 'osx' ]; then
mason_download \
http://dl.google.com/android/repository/android-ndk-r12b-darwin-x86_64.zip \
1a3bbdde35a240086b022cdf13ddcf40c27caa6e
elif [ ${MASON_PLATFORM} = 'linux' ]; then
mason_download \
http://dl.google.com/android/repository/android-ndk-r12b-linux-x86_64.zip \
c6286e131c233c25537a306eae0a29d50b352b91
fi
mason_setup_build_dir
rm -rf ./android-ndk-r12b
unzip -q ../.cache/${MASON_SLUG} $@
export MASON_BUILD_PATH=${MASON_ROOT}/.build/android-ndk-r12b
}
function mason_compile {
rm -rf ${MASON_PREFIX}
mkdir -p ${MASON_PREFIX}
${MASON_BUILD_PATH}/build/tools/make_standalone_toolchain.py \
--force \
--arch mips64 \
--api 21 \
--stl libc++ \
--install-dir "${MASON_PREFIX}"
# NDK r12 ships with .so files which are preferred when linking, but cause
# errors on devices when it's not present.
find "${MASON_PREFIX}" -name "libstdc++.so" -delete
}
function mason_clean {
make clean
}
mason_run "$@"

19
third_party/mason/scripts/android-ndk/x86-9-r10e/.travis.yml vendored Normal file
View File

@ -0,0 +1,19 @@
language: cpp
sudo: false
os:
- linux
- osx
env:
global:
- secure: "clCFM3prHnDocZ8lXlimPxAogvFirD1Zx8cMcFJ/XpkTA/0pCgnhpArM4y/NzLHR57pNZTSCr3p6XZI1c1iTG4Zm8x0sK2A4aTFRahypXNy/e+LzAbtd1y1+dEEDwlJvNNGxizQX4frhOgSNQFDFnWLtmF3stlft5YWyc2kI+FI="
- secure: "jKJErCng8Sk8YJ0IN2FX3lhv7G1LeudMfFBAXViZaXn8w/gWPs+SlfXQmIJ5SruU7U2GQKnAhzbjwXjVAgAh8OAblzny0DDm5Lh5WmwkgAP8JH1LpsBwCYx2S/v8qyR4DX1RVhHS8mQu298180ZDVgGccw+hd8xrE/S5TEQcNfQ="
before_install:
script:
- ./mason build ${MASON_NAME} ${MASON_VERSION}
after_success:
- ./mason publish ${MASON_NAME} ${MASON_VERSION}

49
third_party/mason/scripts/android-ndk/x86-9-r10e/script.sh vendored Executable file
View File

@ -0,0 +1,49 @@
#!/usr/bin/env bash
MASON_NAME=android-ndk
MASON_VERSION=x86-9-r10e
MASON_LIB_FILE=
. ${MASON_DIR}/mason.sh
function mason_load_source {
if [ ${MASON_PLATFORM} = 'osx' ]; then
mason_download \
http://dl.google.com/android/ndk/android-ndk-r10e-darwin-x86_64.bin \
dea2dd3939eea3289cab075804abb153014b78d3
elif [ ${MASON_PLATFORM} = 'linux' ]; then
mason_download \
http://dl.google.com/android/ndk/android-ndk-r10e-linux-x86_64.bin \
285606ba6882d27d99ed469fc5533cc3c93967f5
fi
mason_setup_build_dir
chmod +x ../.cache/${MASON_SLUG}
../.cache/${MASON_SLUG} > /dev/null
export MASON_BUILD_PATH=${MASON_ROOT}/.build/android-ndk-r10e
}
function mason_compile {
rm -rf ${MASON_PREFIX}
mkdir -p ${MASON_PREFIX}
${MASON_BUILD_PATH}/build/tools/make-standalone-toolchain.sh \
--toolchain="x86-4.9" \
--llvm-version="3.6" \
--package-dir="${MASON_BUILD_PATH}/package-dir/" \
--install-dir="${MASON_PREFIX}" \
--stl="libcxx" \
--arch="x86" \
--platform="android-9"
mkdir -p ${MASON_PREFIX}/prebuilt/android-x86/gdbserver
cp -Rv ${MASON_BUILD_PATH}/prebuilt/android-x86/gdbserver/* \
${MASON_PREFIX}/prebuilt/android-x86/gdbserver/
}
function mason_clean {
make clean
}
mason_run "$@"

19
third_party/mason/scripts/android-ndk/x86-9-r11c/.travis.yml vendored Normal file
View File

@ -0,0 +1,19 @@
language: cpp
sudo: false
os:
- linux
- osx
env:
global:
- secure: "clCFM3prHnDocZ8lXlimPxAogvFirD1Zx8cMcFJ/XpkTA/0pCgnhpArM4y/NzLHR57pNZTSCr3p6XZI1c1iTG4Zm8x0sK2A4aTFRahypXNy/e+LzAbtd1y1+dEEDwlJvNNGxizQX4frhOgSNQFDFnWLtmF3stlft5YWyc2kI+FI="
- secure: "jKJErCng8Sk8YJ0IN2FX3lhv7G1LeudMfFBAXViZaXn8w/gWPs+SlfXQmIJ5SruU7U2GQKnAhzbjwXjVAgAh8OAblzny0DDm5Lh5WmwkgAP8JH1LpsBwCYx2S/v8qyR4DX1RVhHS8mQu298180ZDVgGccw+hd8xrE/S5TEQcNfQ="
before_install:
script:
- ./mason build ${MASON_NAME} ${MASON_VERSION}
after_success:
- ./mason publish ${MASON_NAME} ${MASON_VERSION}

45
third_party/mason/scripts/android-ndk/x86-9-r11c/script.sh vendored Executable file
View File

@ -0,0 +1,45 @@
#!/usr/bin/env bash
MASON_NAME=android-ndk
MASON_VERSION=x86-9-r11c
MASON_LIB_FILE=
. ${MASON_DIR}/mason.sh
function mason_load_source {
if [ ${MASON_PLATFORM} = 'osx' ]; then
mason_download \
http://dl.google.com/android/repository/android-ndk-r11c-darwin-x86_64.zip \
0c6fa2017dd5237f6270887c85feedc4aafb3aef
elif [ ${MASON_PLATFORM} = 'linux' ]; then
mason_download \
http://dl.google.com/android/repository/android-ndk-r11c-linux-x86_64.zip \
0c646e2fceb3ef853e1832f4aa3a0dc4c16d2229
fi
mason_setup_build_dir
rm -rf ./android-ndk-r11c
unzip -q ../.cache/${MASON_SLUG} $@
export MASON_BUILD_PATH=${MASON_ROOT}/.build/android-ndk-r11c
}
function mason_compile {
rm -rf ${MASON_PREFIX}
mkdir -p ${MASON_PREFIX}
${MASON_BUILD_PATH}/build/tools/make-standalone-toolchain.sh \
--toolchain="x86-clang" \
--use-llvm \
--package-dir="${MASON_BUILD_PATH}/package-dir/" \
--install-dir="${MASON_PREFIX}" \
--stl="libcxx" \
--arch="x86" \
--platform="android-9"
}
function mason_clean {
make clean
}
mason_run "$@"

19
third_party/mason/scripts/android-ndk/x86-9-r12b/.travis.yml vendored Normal file
View File

@ -0,0 +1,19 @@
language: cpp
sudo: false
os:
- linux
- osx
env:
global:
- secure: "clCFM3prHnDocZ8lXlimPxAogvFirD1Zx8cMcFJ/XpkTA/0pCgnhpArM4y/NzLHR57pNZTSCr3p6XZI1c1iTG4Zm8x0sK2A4aTFRahypXNy/e+LzAbtd1y1+dEEDwlJvNNGxizQX4frhOgSNQFDFnWLtmF3stlft5YWyc2kI+FI="
- secure: "jKJErCng8Sk8YJ0IN2FX3lhv7G1LeudMfFBAXViZaXn8w/gWPs+SlfXQmIJ5SruU7U2GQKnAhzbjwXjVAgAh8OAblzny0DDm5Lh5WmwkgAP8JH1LpsBwCYx2S/v8qyR4DX1RVhHS8mQu298180ZDVgGccw+hd8xrE/S5TEQcNfQ="
before_install:
script:
- ./mason build ${MASON_NAME} ${MASON_VERSION}
after_success:
- ./mason publish ${MASON_NAME} ${MASON_VERSION}

47
third_party/mason/scripts/android-ndk/x86-9-r12b/script.sh vendored Executable file
View File

@ -0,0 +1,47 @@
#!/usr/bin/env bash
MASON_NAME=android-ndk
MASON_VERSION=x86-9-r12b
MASON_LIB_FILE=
. ${MASON_DIR}/mason.sh
function mason_load_source {
if [ ${MASON_PLATFORM} = 'osx' ]; then
mason_download \
http://dl.google.com/android/repository/android-ndk-r12b-darwin-x86_64.zip \
1a3bbdde35a240086b022cdf13ddcf40c27caa6e
elif [ ${MASON_PLATFORM} = 'linux' ]; then
mason_download \
http://dl.google.com/android/repository/android-ndk-r12b-linux-x86_64.zip \
c6286e131c233c25537a306eae0a29d50b352b91
fi
mason_setup_build_dir
rm -rf ./android-ndk-r12b
unzip -q ../.cache/${MASON_SLUG} $@
export MASON_BUILD_PATH=${MASON_ROOT}/.build/android-ndk-r12b
}
function mason_compile {
rm -rf ${MASON_PREFIX}
mkdir -p ${MASON_PREFIX}
${MASON_BUILD_PATH}/build/tools/make_standalone_toolchain.py \
--force \
--arch x86 \
--api 9 \
--stl libc++ \
--install-dir "${MASON_PREFIX}"
# NDK r12 ships with .so files which are preferred when linking, but cause
# errors on devices when it's not present.
find "${MASON_PREFIX}" -name "libstdc++.so" -delete
}
function mason_clean {
make clean
}
mason_run "$@"

19
third_party/mason/scripts/android-ndk/x86_64-21-r10e/.travis.yml vendored Normal file
View File

@ -0,0 +1,19 @@
language: cpp
sudo: false
os:
- linux
- osx
env:
global:
- secure: "clCFM3prHnDocZ8lXlimPxAogvFirD1Zx8cMcFJ/XpkTA/0pCgnhpArM4y/NzLHR57pNZTSCr3p6XZI1c1iTG4Zm8x0sK2A4aTFRahypXNy/e+LzAbtd1y1+dEEDwlJvNNGxizQX4frhOgSNQFDFnWLtmF3stlft5YWyc2kI+FI="
- secure: "jKJErCng8Sk8YJ0IN2FX3lhv7G1LeudMfFBAXViZaXn8w/gWPs+SlfXQmIJ5SruU7U2GQKnAhzbjwXjVAgAh8OAblzny0DDm5Lh5WmwkgAP8JH1LpsBwCYx2S/v8qyR4DX1RVhHS8mQu298180ZDVgGccw+hd8xrE/S5TEQcNfQ="
before_install:
script:
- ./mason build ${MASON_NAME} ${MASON_VERSION}
after_success:
- ./mason publish ${MASON_NAME} ${MASON_VERSION}

45
third_party/mason/scripts/android-ndk/x86_64-21-r10e/script.sh vendored Executable file
View File

@ -0,0 +1,45 @@
#!/usr/bin/env bash
MASON_NAME=android-ndk
MASON_VERSION=x86_64-21-r10e
MASON_LIB_FILE=
. ${MASON_DIR}/mason.sh
function mason_load_source {
if [ ${MASON_PLATFORM} = 'osx' ]; then
mason_download \
http://dl.google.com/android/ndk/android-ndk-r10e-darwin-x86_64.bin \
dea2dd3939eea3289cab075804abb153014b78d3
elif [ ${MASON_PLATFORM} = 'linux' ]; then
mason_download \
http://dl.google.com/android/ndk/android-ndk-r10e-linux-x86_64.bin \
285606ba6882d27d99ed469fc5533cc3c93967f5
fi
mason_setup_build_dir
chmod +x ../.cache/${MASON_SLUG}
../.cache/${MASON_SLUG} > /dev/null
export MASON_BUILD_PATH=${MASON_ROOT}/.build/android-ndk-r10e
}
function mason_compile {
rm -rf ${MASON_PREFIX}
mkdir -p ${MASON_PREFIX}
${MASON_BUILD_PATH}/build/tools/make-standalone-toolchain.sh \
--toolchain="x86_64-4.9" \
--llvm-version="3.6" \
--package-dir="${MASON_BUILD_PATH}/package-dir/" \
--install-dir="${MASON_PREFIX}" \
--stl="libcxx" \
--arch="x86_64" \
--platform="android-21"
}
function mason_clean {
make clean
}
mason_run "$@"

19
third_party/mason/scripts/android-ndk/x86_64-21-r11c/.travis.yml vendored Normal file
View File

@ -0,0 +1,19 @@
language: cpp
sudo: false
os:
- linux
- osx
env:
global:
- secure: "clCFM3prHnDocZ8lXlimPxAogvFirD1Zx8cMcFJ/XpkTA/0pCgnhpArM4y/NzLHR57pNZTSCr3p6XZI1c1iTG4Zm8x0sK2A4aTFRahypXNy/e+LzAbtd1y1+dEEDwlJvNNGxizQX4frhOgSNQFDFnWLtmF3stlft5YWyc2kI+FI="
- secure: "jKJErCng8Sk8YJ0IN2FX3lhv7G1LeudMfFBAXViZaXn8w/gWPs+SlfXQmIJ5SruU7U2GQKnAhzbjwXjVAgAh8OAblzny0DDm5Lh5WmwkgAP8JH1LpsBwCYx2S/v8qyR4DX1RVhHS8mQu298180ZDVgGccw+hd8xrE/S5TEQcNfQ="
before_install:
script:
- ./mason build ${MASON_NAME} ${MASON_VERSION}
after_success:
- ./mason publish ${MASON_NAME} ${MASON_VERSION}

45
third_party/mason/scripts/android-ndk/x86_64-21-r11c/script.sh vendored Executable file
View File

@ -0,0 +1,45 @@
#!/usr/bin/env bash
MASON_NAME=android-ndk
MASON_VERSION=x86_64-21-r11c
MASON_LIB_FILE=
. ${MASON_DIR}/mason.sh
function mason_load_source {
if [ ${MASON_PLATFORM} = 'osx' ]; then
mason_download \
http://dl.google.com/android/repository/android-ndk-r11c-darwin-x86_64.zip \
0c6fa2017dd5237f6270887c85feedc4aafb3aef
elif [ ${MASON_PLATFORM} = 'linux' ]; then
mason_download \
http://dl.google.com/android/repository/android-ndk-r11c-linux-x86_64.zip \
0c646e2fceb3ef853e1832f4aa3a0dc4c16d2229
fi
mason_setup_build_dir
rm -rf ./android-ndk-r11c
unzip -q ../.cache/${MASON_SLUG} $@
export MASON_BUILD_PATH=${MASON_ROOT}/.build/android-ndk-r11c
}
function mason_compile {
rm -rf ${MASON_PREFIX}
mkdir -p ${MASON_PREFIX}
${MASON_BUILD_PATH}/build/tools/make-standalone-toolchain.sh \
--toolchain="x86_64-clang" \
--use-llvm \
--package-dir="${MASON_BUILD_PATH}/package-dir/" \
--install-dir="${MASON_PREFIX}" \
--stl="libcxx" \
--arch="x86_64" \
--platform="android-21"
}
function mason_clean {
make clean
}
mason_run "$@"

19
third_party/mason/scripts/android-ndk/x86_64-21-r12b/.travis.yml vendored Normal file
View File

@ -0,0 +1,19 @@
language: cpp
sudo: false
os:
- linux
- osx
env:
global:
- secure: "clCFM3prHnDocZ8lXlimPxAogvFirD1Zx8cMcFJ/XpkTA/0pCgnhpArM4y/NzLHR57pNZTSCr3p6XZI1c1iTG4Zm8x0sK2A4aTFRahypXNy/e+LzAbtd1y1+dEEDwlJvNNGxizQX4frhOgSNQFDFnWLtmF3stlft5YWyc2kI+FI="
- secure: "jKJErCng8Sk8YJ0IN2FX3lhv7G1LeudMfFBAXViZaXn8w/gWPs+SlfXQmIJ5SruU7U2GQKnAhzbjwXjVAgAh8OAblzny0DDm5Lh5WmwkgAP8JH1LpsBwCYx2S/v8qyR4DX1RVhHS8mQu298180ZDVgGccw+hd8xrE/S5TEQcNfQ="
before_install:
script:
- ./mason build ${MASON_NAME} ${MASON_VERSION}
after_success:
- ./mason publish ${MASON_NAME} ${MASON_VERSION}

47
third_party/mason/scripts/android-ndk/x86_64-21-r12b/script.sh vendored Executable file
View File

@ -0,0 +1,47 @@
#!/usr/bin/env bash
MASON_NAME=android-ndk
MASON_VERSION=x86_64-21-r12b
MASON_LIB_FILE=
. ${MASON_DIR}/mason.sh
function mason_load_source {
if [ ${MASON_PLATFORM} = 'osx' ]; then
mason_download \
http://dl.google.com/android/repository/android-ndk-r12b-darwin-x86_64.zip \
1a3bbdde35a240086b022cdf13ddcf40c27caa6e
elif [ ${MASON_PLATFORM} = 'linux' ]; then
mason_download \
http://dl.google.com/android/repository/android-ndk-r12b-linux-x86_64.zip \
c6286e131c233c25537a306eae0a29d50b352b91
fi
mason_setup_build_dir
rm -rf ./android-ndk-r12b
unzip -q ../.cache/${MASON_SLUG} $@
export MASON_BUILD_PATH=${MASON_ROOT}/.build/android-ndk-r12b
}
function mason_compile {
rm -rf ${MASON_PREFIX}
mkdir -p ${MASON_PREFIX}
${MASON_BUILD_PATH}/build/tools/make_standalone_toolchain.py \
--force \
--arch x86_64 \
--api 21 \
--stl libc++ \
--install-dir "${MASON_PREFIX}"
# NDK r12 ships with .so files which are preferred when linking, but cause
# errors on devices when it's not present.
find "${MASON_PREFIX}" -name "libstdc++.so" -delete
}
function mason_clean {
make clean
}
mason_run "$@"

50
third_party/mason/scripts/benchmark/1.0.0/.travis.yml vendored Normal file
View File

@ -0,0 +1,50 @@
language: cpp
sudo: false
matrix:
exclude:
- os: linux
include:
- os: osx
osx_image: xcode7
env: MASON_PLATFORM=ios
compiler: clang
- os: osx
osx_image: xcode7
env: MASON_PLATFORM=osx
compiler: clang
- os: linux
env: MASON_PLATFORM=linux
compiler: clang
addons:
apt:
sources:
- ubuntu-toolchain-r-test
- llvm-toolchain-precise-3.7
- george-edison55-precise-backports
packages:
- clang-3.7
- cmake
- cmake-data
env:
global:
- secure: "clCFM3prHnDocZ8lXlimPxAogvFirD1Zx8cMcFJ/XpkTA/0pCgnhpArM4y/NzLHR57pNZTSCr3p6XZI1c1iTG4Zm8x0sK2A4aTFRahypXNy/e+LzAbtd1y1+dEEDwlJvNNGxizQX4frhOgSNQFDFnWLtmF3stlft5YWyc2kI+FI="
- secure: "jKJErCng8Sk8YJ0IN2FX3lhv7G1LeudMfFBAXViZaXn8w/gWPs+SlfXQmIJ5SruU7U2GQKnAhzbjwXjVAgAh8OAblzny0DDm5Lh5WmwkgAP8JH1LpsBwCYx2S/v8qyR4DX1RVhHS8mQu298180ZDVgGccw+hd8xrE/S5TEQcNfQ="
cache: apt
before_install:
- if [[ ${MASON_PLATFORM} == "osx" || ${MASON_PLATFORM} == "ios" ]]; then brew install cmake ; fi
before_script:
- if [[ ${MASON_PLATFORM} == "linux" && ${CXX} == "clang++" ]]; then export CXX="clang++-3.7" CC="clang-3.7" ; fi
script:
- ./mason build ${MASON_NAME} ${MASON_VERSION}
after_success:
- ./mason publish ${MASON_NAME} ${MASON_VERSION}

63
third_party/mason/scripts/benchmark/1.0.0/script.sh vendored Executable file
View File

@ -0,0 +1,63 @@
#!/usr/bin/env bash
MASON_NAME=benchmark
MASON_VERSION=1.0.0
MASON_LIB_FILE=lib/libbenchmark.a
. ${MASON_DIR}/mason.sh
function mason_load_source {
mason_download \
https://github.com/google/benchmark/archive/v1.0.0.tar.gz \
dcf87e5faead951fd1e9ab103cb36a7c8ebe4837
mason_extract_tar_gz
export MASON_BUILD_PATH=${MASON_ROOT}/.build/benchmark-${MASON_VERSION}
}
function mason_compile {
rm -rf build
mkdir -p build
cd build
if [ ${MASON_PLATFORM} == 'ios' ] ; then
# Make sure CMake thinks we're cross-compiling and manually set the exit codes
# because CMake can't run the test programs
echo "set (CMAKE_SYSTEM_NAME Darwin)" > toolchain.cmake
cmake \
-DCMAKE_TOOLCHAIN_FILE=toolchain.cmake \
-DRUN_HAVE_STD_REGEX=1 \
-DRUN_HAVE_POSIX_REGEX=0 \
-DRUN_HAVE_STEADY_CLOCK=0 \
-DCMAKE_CXX_FLAGS="${CFLAGS:-}" \
-DCMAKE_BUILD_TYPE=Release \
-DCMAKE_INSTALL_PREFIX="${MASON_PREFIX}" \
-DBENCHMARK_ENABLE_LTO=ON \
-DBENCHMARK_ENABLE_TESTING=OFF \
..
else
cmake \
${MASON_CMAKE_TOOLCHAIN} \
-DCMAKE_BUILD_TYPE=Release \
-DCMAKE_INSTALL_PREFIX="${MASON_PREFIX}" \
-DBENCHMARK_ENABLE_LTO=ON \
-DBENCHMARK_ENABLE_TESTING=OFF \
..
fi
make install -j${MASON_CONCURRENCY}
}
function mason_cflags {
echo -isystem ${MASON_PREFIX}/include
}
function mason_ldflags {
echo -lpthread
}
function mason_static_libs {
echo ${MASON_PREFIX}/${MASON_LIB_FILE}
}
mason_run "$@"

30
third_party/mason/scripts/binutils/2.26/.travis.yml vendored Normal file
View File

@ -0,0 +1,30 @@
language: generic
sudo: false
addons:
apt:
sources:
- ubuntu-toolchain-r-test
- llvm-toolchain-precise-3.7
packages:
- clang-3.7
matrix:
include:
- os: linux
compiler: clang
env: CXX=clang++-3.7 CC=clang-3.7
env:
global:
- secure: "clCFM3prHnDocZ8lXlimPxAogvFirD1Zx8cMcFJ/XpkTA/0pCgnhpArM4y/NzLHR57pNZTSCr3p6XZI1c1iTG4Zm8x0sK2A4aTFRahypXNy/e+LzAbtd1y1+dEEDwlJvNNGxizQX4frhOgSNQFDFnWLtmF3stlft5YWyc2kI+FI="
- secure: "jKJErCng8Sk8YJ0IN2FX3lhv7G1LeudMfFBAXViZaXn8w/gWPs+SlfXQmIJ5SruU7U2GQKnAhzbjwXjVAgAh8OAblzny0DDm5Lh5WmwkgAP8JH1LpsBwCYx2S/v8qyR4DX1RVhHS8mQu298180ZDVgGccw+hd8xrE/S5TEQcNfQ="
before_install:
script:
- ./mason build ${MASON_NAME} ${MASON_VERSION}
after_success:
- ./mason publish ${MASON_NAME} ${MASON_VERSION}

45
third_party/mason/scripts/binutils/2.26/script.sh vendored Executable file
View File

@ -0,0 +1,45 @@
#!/usr/bin/env bash
MASON_NAME=binutils
MASON_VERSION=2.26
MASON_LIB_FILE=bin/ld
. ${MASON_DIR}/mason.sh
function mason_load_source {
mason_download \
http://ftp.gnu.org/gnu/binutils/${MASON_NAME}-${MASON_VERSION}.tar.bz2 \
05b22d6ef8003e76f7d05500363a3ee8cc66a7ae
mason_extract_tar_bz2
export MASON_BUILD_PATH=${MASON_ROOT}/.build/${MASON_NAME}-${MASON_VERSION}
}
function mason_compile {
./configure \
--prefix=${MASON_PREFIX} \
${MASON_HOST_ARG} \
--enable-static \
--disable-shared \
--disable-dependency-tracking
make -j${MASON_CONCURRENCY}
make install
}
function mason_strip_ldflags {
shift # -L...
shift # -lpng16
echo "$@"
}
function mason_ldflags {
mason_strip_ldflags $(`mason_pkgconfig` --static --libs)
}
function mason_clean {
make clean
}
mason_run "$@"

19
third_party/mason/scripts/boost/1.57.0/.travis.yml vendored Normal file
View File

@ -0,0 +1,19 @@
language: cpp
sudo: false
os:
- linux
- osx
env:
global:
- secure: "clCFM3prHnDocZ8lXlimPxAogvFirD1Zx8cMcFJ/XpkTA/0pCgnhpArM4y/NzLHR57pNZTSCr3p6XZI1c1iTG4Zm8x0sK2A4aTFRahypXNy/e+LzAbtd1y1+dEEDwlJvNNGxizQX4frhOgSNQFDFnWLtmF3stlft5YWyc2kI+FI="
- secure: "jKJErCng8Sk8YJ0IN2FX3lhv7G1LeudMfFBAXViZaXn8w/gWPs+SlfXQmIJ5SruU7U2GQKnAhzbjwXjVAgAh8OAblzny0DDm5Lh5WmwkgAP8JH1LpsBwCYx2S/v8qyR4DX1RVhHS8mQu298180ZDVgGccw+hd8xrE/S5TEQcNfQ="
before_install:
script:
- ./mason build ${MASON_NAME} ${MASON_VERSION}
after_success:
- ./mason publish ${MASON_NAME} ${MASON_VERSION}

49
third_party/mason/scripts/boost/1.57.0/script.sh vendored Executable file
View File

@ -0,0 +1,49 @@
#!/usr/bin/env bash
MASON_NAME=boost
MASON_VERSION=1.57.0
MASON_HEADER_ONLY=true
. ${MASON_DIR}/mason.sh
BOOST_ROOT=${MASON_PREFIX}
function mason_load_source {
mason_download \
http://downloads.sourceforge.net/project/boost/boost/1.57.0/boost_1_57_0.tar.bz2 \
397306fa6d0858c4885fbba7d43a0164dcb7f53e
mason_extract_tar_bz2 boost_1_57_0/boost
MASON_BUILD_PATH=${MASON_ROOT}/.build/boost_1_57_0
}
function mason_prefix {
echo "${BOOST_ROOT}"
}
function mason_compile {
mkdir -p ${BOOST_ROOT}/include
mv ${MASON_ROOT}/.build/boost_1_57_0/boost ${BOOST_ROOT}/include
# work around NDK bug https://code.google.com/p/android/issues/detail?id=79483
patch ${BOOST_ROOT}/include/boost/core/demangle.hpp <<< "19a20,21
> #if !defined(__ANDROID__)
>
25a28,29
> #endif
>
"
}
function mason_cflags {
echo "-I${BOOST_ROOT}/include"
}
function mason_ldflags {
:
}
mason_run "$@"

19
third_party/mason/scripts/boost/1.58.0/.travis.yml vendored Normal file
View File

@ -0,0 +1,19 @@
language: cpp
sudo: false
os:
- linux
- osx
env:
global:
- secure: "clCFM3prHnDocZ8lXlimPxAogvFirD1Zx8cMcFJ/XpkTA/0pCgnhpArM4y/NzLHR57pNZTSCr3p6XZI1c1iTG4Zm8x0sK2A4aTFRahypXNy/e+LzAbtd1y1+dEEDwlJvNNGxizQX4frhOgSNQFDFnWLtmF3stlft5YWyc2kI+FI="
- secure: "jKJErCng8Sk8YJ0IN2FX3lhv7G1LeudMfFBAXViZaXn8w/gWPs+SlfXQmIJ5SruU7U2GQKnAhzbjwXjVAgAh8OAblzny0DDm5Lh5WmwkgAP8JH1LpsBwCYx2S/v8qyR4DX1RVhHS8mQu298180ZDVgGccw+hd8xrE/S5TEQcNfQ="
before_install:
script:
- ./mason build ${MASON_NAME} ${MASON_VERSION}
after_success:
- ./mason publish ${MASON_NAME} ${MASON_VERSION}

49
third_party/mason/scripts/boost/1.58.0/script.sh vendored Executable file
View File

@ -0,0 +1,49 @@
#!/usr/bin/env bash
MASON_NAME=boost
MASON_VERSION=1.58.0
MASON_HEADER_ONLY=true
. ${MASON_DIR}/mason.sh
BOOST_ROOT=${MASON_PREFIX}
function mason_load_source {
mason_download \
http://downloads.sourceforge.net/project/boost/boost/1.58.0/boost_1_58_0.tar.bz2 \
43e46651e762e4daf72a5d21dca86ae151e65378
mason_extract_tar_bz2 boost_1_58_0/boost
MASON_BUILD_PATH=${MASON_ROOT}/.build/boost_1_58_0
}
function mason_prefix {
echo "${BOOST_ROOT}"
}
function mason_compile {
mkdir -p ${BOOST_ROOT}/include
mv ${MASON_ROOT}/.build/boost_1_58_0/boost ${BOOST_ROOT}/include
# work around NDK bug https://code.google.com/p/android/issues/detail?id=79483
patch ${BOOST_ROOT}/include/boost/core/demangle.hpp <<< "19a20,21
> #if !defined(__ANDROID__)
>
25a28,29
> #endif
>
"
}
function mason_cflags {
echo "-I${BOOST_ROOT}/include"
}
function mason_ldflags {
:
}
mason_run "$@"

19
third_party/mason/scripts/boost/1.59.0/.travis.yml vendored Normal file
View File

@ -0,0 +1,19 @@
language: cpp
sudo: false
os:
- linux
- osx
env:
global:
- secure: "clCFM3prHnDocZ8lXlimPxAogvFirD1Zx8cMcFJ/XpkTA/0pCgnhpArM4y/NzLHR57pNZTSCr3p6XZI1c1iTG4Zm8x0sK2A4aTFRahypXNy/e+LzAbtd1y1+dEEDwlJvNNGxizQX4frhOgSNQFDFnWLtmF3stlft5YWyc2kI+FI="
- secure: "jKJErCng8Sk8YJ0IN2FX3lhv7G1LeudMfFBAXViZaXn8w/gWPs+SlfXQmIJ5SruU7U2GQKnAhzbjwXjVAgAh8OAblzny0DDm5Lh5WmwkgAP8JH1LpsBwCYx2S/v8qyR4DX1RVhHS8mQu298180ZDVgGccw+hd8xrE/S5TEQcNfQ="
before_install:
script:
- ./mason build ${MASON_NAME} ${MASON_VERSION}
after_success:
- ./mason publish ${MASON_NAME} ${MASON_VERSION}

49
third_party/mason/scripts/boost/1.59.0/script.sh vendored Executable file
View File

@ -0,0 +1,49 @@
#!/usr/bin/env bash
MASON_NAME=boost
MASON_VERSION=1.59.0
MASON_HEADER_ONLY=true
. ${MASON_DIR}/mason.sh
BOOST_ROOT=${MASON_PREFIX}
function mason_load_source {
mason_download \
http://downloads.sourceforge.net/project/boost/boost/1.59.0/boost_1_59_0.tar.bz2 \
ff2e48f4d7e3c4b393d41e07a2f5d923b990967d
mason_extract_tar_bz2 boost_1_59_0/boost
MASON_BUILD_PATH=${MASON_ROOT}/.build/boost_1_59_0
}
function mason_prefix {
echo "${BOOST_ROOT}"
}
function mason_compile {
mkdir -p ${BOOST_ROOT}/include
mv ${MASON_ROOT}/.build/boost_1_59_0/boost ${BOOST_ROOT}/include
# work around NDK bug https://code.google.com/p/android/issues/detail?id=79483
patch ${BOOST_ROOT}/include/boost/core/demangle.hpp <<< "19a20,21
> #if !defined(__ANDROID__)
>
25a28,29
> #endif
>
"
}
function mason_cflags {
echo "-I${BOOST_ROOT}/include"
}
function mason_ldflags {
:
}
mason_run "$@"

13
third_party/mason/scripts/boost/1.60.0/.travis.yml vendored Normal file
View File

@ -0,0 +1,13 @@
language: cpp
sudo: false
env:
global:
- secure: "clCFM3prHnDocZ8lXlimPxAogvFirD1Zx8cMcFJ/XpkTA/0pCgnhpArM4y/NzLHR57pNZTSCr3p6XZI1c1iTG4Zm8x0sK2A4aTFRahypXNy/e+LzAbtd1y1+dEEDwlJvNNGxizQX4frhOgSNQFDFnWLtmF3stlft5YWyc2kI+FI="
- secure: "jKJErCng8Sk8YJ0IN2FX3lhv7G1LeudMfFBAXViZaXn8w/gWPs+SlfXQmIJ5SruU7U2GQKnAhzbjwXjVAgAh8OAblzny0DDm5Lh5WmwkgAP8JH1LpsBwCYx2S/v8qyR4DX1RVhHS8mQu298180ZDVgGccw+hd8xrE/S5TEQcNfQ="
script:
- ./mason build ${MASON_NAME} ${MASON_VERSION}
after_success:
- ./mason publish ${MASON_NAME} ${MASON_VERSION}

49
third_party/mason/scripts/boost/1.60.0/script.sh vendored Executable file
View File

@ -0,0 +1,49 @@
#!/usr/bin/env bash
MASON_NAME=boost
MASON_VERSION=1.60.0
MASON_HEADER_ONLY=true
. ${MASON_DIR}/mason.sh
BOOST_ROOT=${MASON_PREFIX}
function mason_load_source {
mason_download \
http://downloads.sourceforge.net/project/boost/boost/1.60.0/boost_1_60_0.tar.bz2 \
40a65135d34c3e3a3cdbe681f06745c086e5b941
mason_extract_tar_bz2 boost_1_60_0/boost
MASON_BUILD_PATH=${MASON_ROOT}/.build/boost_1_60_0
}
function mason_prefix {
echo "${BOOST_ROOT}"
}
function mason_compile {
mkdir -p ${BOOST_ROOT}/include
mv ${MASON_ROOT}/.build/boost_1_60_0/boost ${BOOST_ROOT}/include
# work around NDK bug https://code.google.com/p/android/issues/detail?id=79483
patch ${BOOST_ROOT}/include/boost/core/demangle.hpp <<< "19a20,21
> #if !defined(__ANDROID__)
>
25a28,29
> #endif
>
"
}
function mason_cflags {
echo "-I${BOOST_ROOT}/include"
}
function mason_ldflags {
:
}
mason_run "$@"

13
third_party/mason/scripts/boost/1.61.0/.travis.yml vendored Normal file
View File

@ -0,0 +1,13 @@
language: cpp
sudo: false
env:
global:
- secure: "clCFM3prHnDocZ8lXlimPxAogvFirD1Zx8cMcFJ/XpkTA/0pCgnhpArM4y/NzLHR57pNZTSCr3p6XZI1c1iTG4Zm8x0sK2A4aTFRahypXNy/e+LzAbtd1y1+dEEDwlJvNNGxizQX4frhOgSNQFDFnWLtmF3stlft5YWyc2kI+FI="
- secure: "jKJErCng8Sk8YJ0IN2FX3lhv7G1LeudMfFBAXViZaXn8w/gWPs+SlfXQmIJ5SruU7U2GQKnAhzbjwXjVAgAh8OAblzny0DDm5Lh5WmwkgAP8JH1LpsBwCYx2S/v8qyR4DX1RVhHS8mQu298180ZDVgGccw+hd8xrE/S5TEQcNfQ="
script:
- ./mason build ${MASON_NAME} ${MASON_VERSION}
after_success:
- ./mason publish ${MASON_NAME} ${MASON_VERSION}

8
third_party/mason/scripts/boost/1.61.0/base.sh vendored Normal file
View File

@ -0,0 +1,8 @@
#!/usr/bin/env bash
export MASON_VERSION=1.61.0
export BOOST_VERSION=${MASON_VERSION//./_}
export BOOST_TOOLSET="clang"
export BOOST_TOOLSET_CXX="clang++"
export BOOST_ARCH="x86"
export BOOST_SHASUM=0a72c541e468d76a957adc14e54688dd695d566f

64
third_party/mason/scripts/boost/1.61.0/common.sh vendored Normal file
View File

@ -0,0 +1,64 @@
#!/usr/bin/env bash
function mason_load_source {
mason_download \
http://downloads.sourceforge.net/project/boost/boost/${MASON_VERSION}/boost_${BOOST_VERSION}.tar.bz2 \
${BOOST_SHASUM}
export MASON_BUILD_PATH=${MASON_ROOT}/.build/boost_${BOOST_VERSION}
mason_extract_tar_bz2
}
function gen_config() {
echo "using $1 : : $(which $2)" > user-config.jam
if [[ "${AR:-false}" != false ]] || [[ "${RANLIB:-false}" != false ]]; then
echo ' : ' >> user-config.jam
if [[ "${AR:-false}" != false ]]; then
echo "<archiver>${AR} " >> user-config.jam
fi
if [[ "${RANLIB:-false}" != false ]]; then
echo "<ranlib>${RANLIB} " >> user-config.jam
fi
fi
echo ' ;' >> user-config.jam
}
function mason_compile {
gen_config ${BOOST_TOOLSET} ${BOOST_TOOLSET_CXX}
if [[ ! -f ./b2 ]] ; then
./bootstrap.sh
fi
./b2 \
--with-${BOOST_LIBRARY} \
--prefix=${MASON_PREFIX} \
-j${MASON_CONCURRENCY} \
-d0 \
--ignore-site-config --user-config=user-config.jam \
architecture="${BOOST_ARCH}" \
toolset="${BOOST_TOOLSET}" \
link=static \
variant=release \
linkflags="${LDFLAGS:-" "}" \
cxxflags="${CXXFLAGS:-" "}" \
stage
mkdir -p $(dirname ${MASON_PREFIX}/${MASON_LIB_FILE})
mv stage/${MASON_LIB_FILE} ${MASON_PREFIX}/${MASON_LIB_FILE}
}
function mason_prefix {
echo "${MASON_PREFIX}"
}
function mason_cflags {
echo "-I${MASON_PREFIX}/include"
}
function mason_ldflags {
local LOCAL_LDFLAGS
LOCAL_LDFLAGS="-L${MASON_PREFIX}/lib"
if [[ ${BOOST_LIBRARY:-false} != false ]]; then
LOCAL_LDFLAGS="${LOCAL_LDFLAGS} -l${BOOST_LIBRARY}"
fi
echo $LOCAL_LDFLAGS
}

54
third_party/mason/scripts/boost/1.61.0/script.sh vendored Executable file
View File

@ -0,0 +1,54 @@
#!/usr/bin/env bash
HERE="$( cd "$( dirname "${BASH_SOURCE[0]}" )" > /dev/null && pwd )"
# inherit from boost base (used for all boost library packages)
source ${HERE}/base.sh
# this package is the one that is header-only
MASON_NAME=boost
MASON_HEADER_ONLY=true
unset MASON_LIB_FILE
# setup mason env
. ${MASON_DIR}/mason.sh
# source common build functions
source ${HERE}/common.sh
# override default unpacking to just unpack headers
function mason_load_source {
mason_download \
http://downloads.sourceforge.net/project/boost/boost/${MASON_VERSION}/boost_${BOOST_VERSION}.tar.bz2 \
${BOOST_SHASUM}
mason_extract_tar_bz2 boost_${BOOST_VERSION}/boost
MASON_BUILD_PATH=${MASON_ROOT}/.build/boost_${BOOST_VERSION}
}
# override default "compile" target for just the header install
function mason_compile {
mkdir -p ${MASON_PREFIX}/include
cp -r ${MASON_ROOT}/.build/boost_${BOOST_VERSION}/boost ${MASON_PREFIX}/include
# work around NDK bug https://code.google.com/p/android/issues/detail?id=79483
patch ${MASON_PREFIX}/include/boost/core/demangle.hpp <<< "19a20,21
> #if !defined(__ANDROID__)
>
25a28,29
> #endif
>
"
# work around https://github.com/Project-OSRM/node-osrm/issues/191
patch ${MASON_PREFIX}/include/boost/interprocess/detail/os_file_functions.hpp <<< "471c471
< return ::open(name, (int)mode);
---
> return ::open(name, (int)mode,S_IRUSR|S_IWUSR);
"
}
mason_run "$@"

60
third_party/mason/scripts/boost/system/script.sh vendored Executable file
View File

@ -0,0 +1,60 @@
#!/usr/bin/env bash
MASON_NAME=boost
MASON_VERSION=system
MASON_SYSTEM_PACKAGE=true
. ${MASON_DIR}/mason.sh
if [ -d '/usr/local/include/boost' ]; then
BOOST_ROOT='/usr/local'
elif [ -d '/usr/include/boost' ]; then
BOOST_ROOT='/usr'
else
mason_error "Cannot find Boost"
exit 1
fi
function mason_system_version {
# Use host compiler to produce a binary that can run on the host
HOST_CXX=`MASON_PLATFORM= mason env CXX`
HOST_CFLAGS=`MASON_PLATFORM= mason env CFLAGS`
mkdir -p "${MASON_PREFIX}"
cd "${MASON_PREFIX}"
if [ ! -f version ]; then
echo "#include <boost/version.hpp>
#include <stdio.h>
int main() {
printf(\"%d.%d.%d\", BOOST_VERSION / 100000, BOOST_VERSION / 100 % 1000, BOOST_VERSION % 100);
return 0;
}
" > version.cpp && ${HOST_CXX} ${HOST_CFLAGS} version.cpp $(mason_cflags) -o version
fi
./version
}
function mason_build {
if [ ${MASON_PLATFORM} = 'ios' ]; then
mkdir -p ${MASON_PREFIX}/include
ln -sf ${BOOST_ROOT}/include/boost ${MASON_PREFIX}/include/
else
mkdir -p ${MASON_PREFIX}/{include,lib}
ln -sf ${BOOST_ROOT}/include/boost ${MASON_PREFIX}/include/
ln -sf ${BOOST_ROOT}/lib/libboost_* ${MASON_PREFIX}/lib/
fi
}
function mason_cflags {
echo "-I${MASON_PREFIX}/include"
}
function mason_ldflags {
if [ ${MASON_PLATFORM} = 'ios' ]; then
echo ""
else
echo "-L${MASON_PREFIX}/lib"
fi
}
mason_run "$@"

24
third_party/mason/scripts/boost_liball/1.49.0/.travis.yml vendored Normal file
View File

@ -0,0 +1,24 @@
language: cpp
sudo: false
matrix:
include:
- os: osx
compiler: clang
- os: linux
compiler: clang
env:
global:
- secure: "clCFM3prHnDocZ8lXlimPxAogvFirD1Zx8cMcFJ/XpkTA/0pCgnhpArM4y/NzLHR57pNZTSCr3p6XZI1c1iTG4Zm8x0sK2A4aTFRahypXNy/e+LzAbtd1y1+dEEDwlJvNNGxizQX4frhOgSNQFDFnWLtmF3stlft5YWyc2kI+FI="
- secure: "jKJErCng8Sk8YJ0IN2FX3lhv7G1LeudMfFBAXViZaXn8w/gWPs+SlfXQmIJ5SruU7U2GQKnAhzbjwXjVAgAh8OAblzny0DDm5Lh5WmwkgAP8JH1LpsBwCYx2S/v8qyR4DX1RVhHS8mQu298180ZDVgGccw+hd8xrE/S5TEQcNfQ="
before_install:
- source ./scripts/setup_cpp11_toolchain.sh
script:
- ./mason build ${MASON_NAME} ${MASON_VERSION}
after_success:
- ./mason publish ${MASON_NAME} ${MASON_VERSION}

12
third_party/mason/scripts/boost_liball/1.49.0/patch.diff vendored Normal file
View File

@ -0,0 +1,12 @@
--- libs/python/src/converter/builtin_converters.cpp 2012-12-07 11:51:06.000000000 -0800
+++ libs/python/src/converter/builtin_converters.cpp 2014-04-01 17:24:37.000000000 -0700
@@ -32,7 +32,9 @@
void shared_ptr_deleter::operator()(void const*)
{
+ PyGILState_STATE gil = PyGILState_Ensure();
owner.reset();
+ PyGILState_Release(gil);
}
namespace

147
third_party/mason/scripts/boost_liball/1.49.0/script.sh vendored Executable file
View File

@ -0,0 +1,147 @@
#!/usr/bin/env bash
BOOST_VERSION1="1.49.0"
BOOST_VERSION2="1_49_0"
BOOST_LIBRARY="regex"
BOOST_ARCH="x86"
if [[ $(uname -s) == 'Darwin' ]]; then
BOOST_TOOLSET="darwin"
else
BOOST_TOOLSET="gcc"
fi
MASON_NAME=boost_liball
MASON_VERSION=1.49.0
# this boost package has multiple libraries to we
# reference this empty file as a placeholder for all of them
MASON_LIB_FILE=lib/libboost_placeholder.txt
. ${MASON_DIR}/mason.sh
function mason_load_source {
mason_download \
http://downloads.sourceforge.net/project/boost/boost/${BOOST_VERSION1}/boost_${BOOST_VERSION2}.tar.bz2 \
1175031e7689f17591363d907f9dad3be0559dee
export MASON_BUILD_PATH=${MASON_ROOT}/.build/boost_${BOOST_VERSION2}
mason_extract_tar_bz2
}
function gen_config() {
echo "using $1 : : $(which $2)" > user-config.jam
if [[ "${AR:-false}" != false ]] || [[ "${RANLIB:-false}" != false ]]; then
echo ' : ' >> user-config.jam
if [[ "${AR:-false}" != false ]]; then
echo "<archiver>${AR} " >> user-config.jam
fi
if [[ "${RANLIB:-false}" != false ]]; then
echo "<ranlib>${RANLIB} " >> user-config.jam
fi
fi
echo ' ;' >> user-config.jam
}
function mason_prepare_compile {
${MASON_DIR}/mason install icu 54.1
MASON_ICU=$(${MASON_DIR}/mason prefix icu 54.1)
BOOST_LDFLAGS="-L${MASON_ICU}/lib -licuuc -licui18n -licudata"
}
function write_python_config() {
# usage:
# write_python_config <user-config.jam> <version> <base> <variant>
PYTHON_VERSION=$2
# note: apple pythons need '/System'
PYTHON_BASE=$3
# note: python 3 uses 'm'
PYTHON_VARIANT=$4
if [[ ${UNAME} == 'Darwin' ]]; then
echo "
using python
: ${PYTHON_VERSION} # version
: ${PYTHON_BASE}/Library/Frameworks/Python.framework/Versions/${PYTHON_VERSION}/bin/python${PYTHON_VERSION}${PYTHON_VARIANT} # cmd-or-prefix
: ${PYTHON_BASE}/Library/Frameworks/Python.framework/Versions/${PYTHON_VERSION}/include/python${PYTHON_VERSION}${PYTHON_VARIANT} # includes
: ${PYTHON_BASE}/Library/Frameworks/Python.framework/Versions/${PYTHON_VERSION}/lib/python${PYTHON_VERSION}/config${PYTHON_VARIANT} # a lib actually symlink
: <toolset>${BOOST_TOOLSET} # condition
;
" >> $1
else
if [[ ${UNAME} == 'FreeBSD' ]]; then
echo "
using python
: ${PYTHON_VERSION} # version
: /usr/local/bin/python${PYTHON_VERSION}${PYTHON_VARIANT} # cmd-or-prefix
: /usr/local/include/python${PYTHON_VERSION} # includes
: /usr/local/lib/python${PYTHON_VERSION}/config${PYTHON_VARIANT}
: <toolset>${BOOST_TOOLSET} # condition
;
" >> $1
else
echo "
using python
: ${PYTHON_VERSION} # version
: /usr/bin/python${PYTHON_VERSION}${PYTHON_VARIANT} # cmd-or-prefix
: /usr/include/python${PYTHON_VERSION} # includes
: /usr/lib/python${PYTHON_VERSION}/config${PYTHON_VARIANT}
: <toolset>${BOOST_TOOLSET} # condition
;
" >> $1
fi
fi
}
function mason_compile {
if [[ -f ../../../patch.diff ]]; then
patch -N -p0 < ../../../patch.diff
else
# patch to workaround crashes in python.input
# https://github.com/mapnik/mapnik/issues/1968
mason_step "Loading patch 'https://github.com/mapbox/mason/blob/${MASON_SLUG}/patch.diff'..."
curl --retry 3 -s -f -# -L \
https://raw.githubusercontent.com/mapbox/mason/${MASON_SLUG}/patch.diff \
-O || (mason_error "Could not find patch for ${MASON_SLUG}" && exit 1)
patch -N -p0 < ./patch.diff
fi
gen_config ${BOOST_TOOLSET} g++
perl -i -p -e "s/\-march=i386/\-m64/g;" ./tools/build/v2/tools/gcc.jam
write_python_config user-config.jam "2.7" "/System" ""
if [[ ! -f ./b2 ]] ; then
./bootstrap.sh
fi
CXXFLAGS="${CXXFLAGS} -fvisibility=hidden"
./b2 \
--with-regex \
--with-system \
--with-thread \
--with-filesystem \
--with-program_options \
--with-python \
--prefix=${MASON_PREFIX} \
-j${MASON_CONCURRENCY} \
-sHAVE_ICU=1 -sICU_PATH=${MASON_ICU} \
linkflags="${BOOST_LDFLAGS}" \
cxxflags="${CXXFLAGS:-" "}" \
-d0 \
--ignore-site-config --user-config=user-config.jam \
architecture="${BOOST_ARCH}" \
address-model=64 \
toolset="${BOOST_TOOLSET}" \
link=static \
variant=release \
install
mkdir -p ${MASON_PREFIX}/lib/
touch ${MASON_PREFIX}/lib/libboost_placeholder.txt
}
function mason_ldflags {
echo "-lboost_regex -lboost_system -lboost_thread -lboost_filesystem -lboost_program_options -lboost_python"
}
function mason_clean {
make clean
}
mason_run "$@"

24
third_party/mason/scripts/boost_liball/1.58.0/.travis.yml vendored Normal file
View File

@ -0,0 +1,24 @@
language: cpp
sudo: false
matrix:
include:
- os: osx
compiler: clang
- os: linux
compiler: clang
env:
global:
- secure: "clCFM3prHnDocZ8lXlimPxAogvFirD1Zx8cMcFJ/XpkTA/0pCgnhpArM4y/NzLHR57pNZTSCr3p6XZI1c1iTG4Zm8x0sK2A4aTFRahypXNy/e+LzAbtd1y1+dEEDwlJvNNGxizQX4frhOgSNQFDFnWLtmF3stlft5YWyc2kI+FI="
- secure: "jKJErCng8Sk8YJ0IN2FX3lhv7G1LeudMfFBAXViZaXn8w/gWPs+SlfXQmIJ5SruU7U2GQKnAhzbjwXjVAgAh8OAblzny0DDm5Lh5WmwkgAP8JH1LpsBwCYx2S/v8qyR4DX1RVhHS8mQu298180ZDVgGccw+hd8xrE/S5TEQcNfQ="
before_install:
- source ./scripts/setup_cpp11_toolchain.sh
script:
- ./mason build ${MASON_NAME} ${MASON_VERSION}
after_success:
- ./mason publish ${MASON_NAME} ${MASON_VERSION}

12
third_party/mason/scripts/boost_liball/1.58.0/patch.diff vendored Normal file
View File

@ -0,0 +1,12 @@
--- libs/python/src/converter/builtin_converters.cpp 2012-12-07 11:51:06.000000000 -0800
+++ libs/python/src/converter/builtin_converters.cpp 2014-04-01 17:24:37.000000000 -0700
@@ -32,7 +32,9 @@
void shared_ptr_deleter::operator()(void const*)
{
+ PyGILState_STATE gil = PyGILState_Ensure();
owner.reset();
+ PyGILState_Release(gil);
}
namespace

140
third_party/mason/scripts/boost_liball/1.58.0/script.sh vendored Executable file
View File

@ -0,0 +1,140 @@
#!/usr/bin/env bash
BOOST_VERSION1="1.58.0"
BOOST_VERSION2="1_58_0"
BOOST_LIBRARY="regex"
BOOST_TOOLSET="clang"
BOOST_ARCH="x86"
MASON_NAME=boost_liball
MASON_VERSION=1.58.0
# this boost package has multiple libraries to we
# reference this empty file as a placeholder for all of them
MASON_LIB_FILE=lib/libboost_placeholder.txt
. ${MASON_DIR}/mason.sh
function mason_load_source {
mason_download \
http://downloads.sourceforge.net/project/boost/boost/1.58.0/boost_1_58_0.tar.bz2 \
43e46651e762e4daf72a5d21dca86ae151e65378
export MASON_BUILD_PATH=${MASON_ROOT}/.build/boost_${BOOST_VERSION2}
mason_extract_tar_bz2
}
function gen_config() {
echo "using $1 : : $(which $2)" > user-config.jam
if [[ "${AR:-false}" != false ]] || [[ "${RANLIB:-false}" != false ]]; then
echo ' : ' >> user-config.jam
if [[ "${AR:-false}" != false ]]; then
echo "<archiver>${AR} " >> user-config.jam
fi
if [[ "${RANLIB:-false}" != false ]]; then
echo "<ranlib>${RANLIB} " >> user-config.jam
fi
fi
echo ' ;' >> user-config.jam
}
function mason_prepare_compile {
${MASON_DIR}/mason install icu 54.1
MASON_ICU=$(${MASON_DIR}/mason prefix icu 54.1)
BOOST_LDFLAGS="-L${MASON_ICU}/lib -licuuc -licui18n -licudata"
}
function write_python_config() {
# usage:
# write_python_config <user-config.jam> <version> <base> <variant>
PYTHON_VERSION=$2
# note: apple pythons need '/System'
PYTHON_BASE=$3
# note: python 3 uses 'm'
PYTHON_VARIANT=$4
if [[ ${UNAME} == 'Darwin' ]]; then
echo "
using python
: ${PYTHON_VERSION} # version
: ${PYTHON_BASE}/Library/Frameworks/Python.framework/Versions/${PYTHON_VERSION}/bin/python${PYTHON_VERSION}${PYTHON_VARIANT} # cmd-or-prefix
: ${PYTHON_BASE}/Library/Frameworks/Python.framework/Versions/${PYTHON_VERSION}/include/python${PYTHON_VERSION}${PYTHON_VARIANT} # includes
: ${PYTHON_BASE}/Library/Frameworks/Python.framework/Versions/${PYTHON_VERSION}/lib/python${PYTHON_VERSION}/config${PYTHON_VARIANT} # a lib actually symlink
: <toolset>${BOOST_TOOLSET} # condition
;
" >> $1
else
if [[ ${UNAME} == 'FreeBSD' ]]; then
echo "
using python
: ${PYTHON_VERSION} # version
: /usr/local/bin/python${PYTHON_VERSION}${PYTHON_VARIANT} # cmd-or-prefix
: /usr/local/include/python${PYTHON_VERSION} # includes
: /usr/local/lib/python${PYTHON_VERSION}/config${PYTHON_VARIANT}
: <toolset>${BOOST_TOOLSET} # condition
;
" >> $1
else
echo "
using python
: ${PYTHON_VERSION} # version
: /usr/bin/python${PYTHON_VERSION}${PYTHON_VARIANT} # cmd-or-prefix
: /usr/include/python${PYTHON_VERSION} # includes
: /usr/lib/python${PYTHON_VERSION}/config${PYTHON_VARIANT}
: <toolset>${BOOST_TOOLSET} # condition
;
" >> $1
fi
fi
}
function mason_compile {
if [[ -f ../../../patch.diff ]]; then
patch -N -p0 < ../../../patch.diff
else
# patch to workaround crashes in python.input
# https://github.com/mapnik/mapnik/issues/1968
mason_step "Loading patch 'https://github.com/mapbox/mason/blob/${MASON_SLUG}/patch.diff'..."
curl --retry 3 -s -f -# -L \
https://raw.githubusercontent.com/mapbox/mason/${MASON_SLUG}/patch.diff \
-O || (mason_error "Could not find patch for ${MASON_SLUG}" && exit 1)
patch -N -p0 < ./patch.diff
fi
gen_config ${BOOST_TOOLSET} clang++
if [[ ! -f ./b2 ]] ; then
./bootstrap.sh
fi
CXXFLAGS="${CXXFLAGS} -fvisibility=hidden"
./b2 \
--with-regex \
--with-system \
--with-thread \
--with-filesystem \
--with-program_options \
--with-python \
--prefix=${MASON_PREFIX} \
-j${MASON_CONCURRENCY} \
-sHAVE_ICU=1 -sICU_PATH=${MASON_ICU} \
linkflags="${LDFLAGS:-" "} ${BOOST_LDFLAGS}" \
cxxflags="${CXXFLAGS:-" "}" \
-d0 \
--ignore-site-config --user-config=user-config.jam \
architecture="${BOOST_ARCH}" \
toolset="${BOOST_TOOLSET}" \
link=static \
variant=release \
install
mkdir -p ${MASON_PREFIX}/lib/
touch ${MASON_PREFIX}/lib/libboost_placeholder.txt
}
function mason_ldflags {
:
}
function mason_clean {
make clean
}
mason_run "$@"

28
third_party/mason/scripts/boost_liball/1.59.0/.travis.yml vendored Normal file
View File

@ -0,0 +1,28 @@
language: cpp
sudo: false
matrix:
include:
- os: osx
osx_image: xcode6
compiler: clang
- os: osx
osx_image: xcode7
compiler: clang
- os: linux
compiler: clang
env:
global:
- secure: "clCFM3prHnDocZ8lXlimPxAogvFirD1Zx8cMcFJ/XpkTA/0pCgnhpArM4y/NzLHR57pNZTSCr3p6XZI1c1iTG4Zm8x0sK2A4aTFRahypXNy/e+LzAbtd1y1+dEEDwlJvNNGxizQX4frhOgSNQFDFnWLtmF3stlft5YWyc2kI+FI="
- secure: "jKJErCng8Sk8YJ0IN2FX3lhv7G1LeudMfFBAXViZaXn8w/gWPs+SlfXQmIJ5SruU7U2GQKnAhzbjwXjVAgAh8OAblzny0DDm5Lh5WmwkgAP8JH1LpsBwCYx2S/v8qyR4DX1RVhHS8mQu298180ZDVgGccw+hd8xrE/S5TEQcNfQ="
before_install:
- source ./scripts/setup_cpp11_toolchain.sh
script:
- ./mason build ${MASON_NAME} ${MASON_VERSION}
after_success:
- ./mason publish ${MASON_NAME} ${MASON_VERSION}

22
third_party/mason/scripts/boost_liball/1.59.0/patch.diff vendored Normal file
View File

@ -0,0 +1,22 @@
--- libs/python/src/converter/builtin_converters.cpp 2012-12-07 11:51:06.000000000 -0800
+++ libs/python/src/converter/builtin_converters.cpp 2014-04-01 17:24:37.000000000 -0700
@@ -32,7 +32,9 @@
void shared_ptr_deleter::operator()(void const*)
{
+ PyGILState_STATE gil = PyGILState_Ensure();
owner.reset();
+ PyGILState_Release(gil);
}
namespace
--- libs/filesystem/src/operations.cpp 2015-05-01 18:49:26.000000000 -0700
+++ libs/filesystem/src/operations.cpp 2015-05-01 18:49:22.000000000 -0700
@@ -1416,6 +1416,7 @@
// - See the fchmodat() Linux man page:
// "http://man7.org/linux/man-pages/man2/fchmodat.2.html"
# if defined(AT_FDCWD) && defined(AT_SYMLINK_NOFOLLOW) \
+ && !(defined(__APPLE__)) \
&& !(defined(__SUNPRO_CC) || defined(__sun) || defined(sun)) \
&& !(defined(linux) || defined(__linux) || defined(__linux__))
if (::fchmodat(AT_FDCWD, p.c_str(), mode_cast(prms),

140
third_party/mason/scripts/boost_liball/1.59.0/script.sh vendored Executable file
View File

@ -0,0 +1,140 @@
#!/usr/bin/env bash
BOOST_VERSION1="1.59.0"
BOOST_VERSION2="1_59_0"
BOOST_LIBRARY="regex"
BOOST_TOOLSET="clang"
BOOST_ARCH="x86"
MASON_NAME=boost_liball
MASON_VERSION=1.59.0
# this boost package has multiple libraries to we
# reference this empty file as a placeholder for all of them
MASON_LIB_FILE=lib/libboost_placeholder.txt
. ${MASON_DIR}/mason.sh
function mason_load_source {
mason_download \
http://downloads.sourceforge.net/project/boost/boost/1.59.0/boost_1_59_0.tar.bz2 \
ff2e48f4d7e3c4b393d41e07a2f5d923b990967d
export MASON_BUILD_PATH=${MASON_ROOT}/.build/boost_${BOOST_VERSION2}
mason_extract_tar_bz2
}
function gen_config() {
echo "using $1 : : $(which $2)" > user-config.jam
if [[ "${AR:-false}" != false ]] || [[ "${RANLIB:-false}" != false ]]; then
echo ' : ' >> user-config.jam
if [[ "${AR:-false}" != false ]]; then
echo "<archiver>${AR} " >> user-config.jam
fi
if [[ "${RANLIB:-false}" != false ]]; then
echo "<ranlib>${RANLIB} " >> user-config.jam
fi
fi
echo ' ;' >> user-config.jam
}
function mason_prepare_compile {
${MASON_DIR}/mason install icu 55.1
MASON_ICU=$(${MASON_DIR}/mason prefix icu 55.1)
BOOST_LDFLAGS="-L${MASON_ICU}/lib -licuuc -licui18n -licudata"
}
function write_python_config() {
# usage:
# write_python_config <user-config.jam> <version> <base> <variant>
PYTHON_VERSION=$2
# note: apple pythons need '/System'
PYTHON_BASE=$3
# note: python 3 uses 'm'
PYTHON_VARIANT=$4
if [[ ${UNAME} == 'Darwin' ]]; then
echo "
using python
: ${PYTHON_VERSION} # version
: ${PYTHON_BASE}/Library/Frameworks/Python.framework/Versions/${PYTHON_VERSION}/bin/python${PYTHON_VERSION}${PYTHON_VARIANT} # cmd-or-prefix
: ${PYTHON_BASE}/Library/Frameworks/Python.framework/Versions/${PYTHON_VERSION}/include/python${PYTHON_VERSION}${PYTHON_VARIANT} # includes
: ${PYTHON_BASE}/Library/Frameworks/Python.framework/Versions/${PYTHON_VERSION}/lib/python${PYTHON_VERSION}/config${PYTHON_VARIANT} # a lib actually symlink
: <toolset>${BOOST_TOOLSET} # condition
;
" >> $1
else
if [[ ${UNAME} == 'FreeBSD' ]]; then
echo "
using python
: ${PYTHON_VERSION} # version
: /usr/local/bin/python${PYTHON_VERSION}${PYTHON_VARIANT} # cmd-or-prefix
: /usr/local/include/python${PYTHON_VERSION} # includes
: /usr/local/lib/python${PYTHON_VERSION}/config${PYTHON_VARIANT}
: <toolset>${BOOST_TOOLSET} # condition
;
" >> $1
else
echo "
using python
: ${PYTHON_VERSION} # version
: /usr/bin/python${PYTHON_VERSION}${PYTHON_VARIANT} # cmd-or-prefix
: /usr/include/python${PYTHON_VERSION} # includes
: /usr/lib/python${PYTHON_VERSION}/config${PYTHON_VARIANT}
: <toolset>${BOOST_TOOLSET} # condition
;
" >> $1
fi
fi
}
function mason_compile {
if [[ -f ../../../patch.diff ]]; then
patch -N -p0 < ../../../patch.diff
else
# patch to workaround crashes in python.input
# https://github.com/mapnik/mapnik/issues/1968
mason_step "Loading patch 'https://github.com/mapbox/mason/blob/${MASON_SLUG}/patch.diff'..."
curl --retry 3 -s -f -# -L \
https://raw.githubusercontent.com/mapbox/mason/${MASON_SLUG}/patch.diff \
-O || (mason_error "Could not find patch for ${MASON_SLUG}" && exit 1)
patch -N -p0 < ./patch.diff
fi
gen_config ${BOOST_TOOLSET} clang++
if [[ ! -f ./b2 ]] ; then
./bootstrap.sh
fi
CXXFLAGS="${CXXFLAGS} -fvisibility=hidden"
./b2 \
--with-regex \
--with-system \
--with-thread \
--with-filesystem \
--with-program_options \
--with-python \
--prefix=${MASON_PREFIX} \
-j${MASON_CONCURRENCY} \
-sHAVE_ICU=1 -sICU_PATH=${MASON_ICU} \
linkflags="${LDFLAGS:-" "} ${BOOST_LDFLAGS}" \
cxxflags="${CXXFLAGS:-" "}" \
-d0 \
--ignore-site-config --user-config=user-config.jam \
architecture="${BOOST_ARCH}" \
toolset="${BOOST_TOOLSET}" \
link=static \
variant=release \
install
mkdir -p ${MASON_PREFIX}/lib/
touch ${MASON_PREFIX}/lib/libboost_placeholder.txt
}
function mason_ldflags {
:
}
function mason_clean {
make clean
}
mason_run "$@"

37
third_party/mason/scripts/boost_liball_osrm/1.59.0/.travis.yml vendored Normal file
View File

@ -0,0 +1,37 @@
language: cpp
sudo: false
matrix:
include:
- os: osx
osx_image: xcode6
compiler: clang
- os: osx
osx_image: xcode7
compiler: clang
- os: linux
compiler: clang
addons:
apt:
sources:
- ubuntu-toolchain-r-test
packages:
- g++-5
env:
global:
- secure: "clCFM3prHnDocZ8lXlimPxAogvFirD1Zx8cMcFJ/XpkTA/0pCgnhpArM4y/NzLHR57pNZTSCr3p6XZI1c1iTG4Zm8x0sK2A4aTFRahypXNy/e+LzAbtd1y1+dEEDwlJvNNGxizQX4frhOgSNQFDFnWLtmF3stlft5YWyc2kI+FI="
- secure: "jKJErCng8Sk8YJ0IN2FX3lhv7G1LeudMfFBAXViZaXn8w/gWPs+SlfXQmIJ5SruU7U2GQKnAhzbjwXjVAgAh8OAblzny0DDm5Lh5WmwkgAP8JH1LpsBwCYx2S/v8qyR4DX1RVhHS8mQu298180ZDVgGccw+hd8xrE/S5TEQcNfQ="
before_install:
- export CC=/usr/bin/gcc-5
- export CXX=/usr/bin/g++-5
- export MASON_CONCURRENCY_OVERRIDE=2
script:
- ./mason build ${MASON_NAME} ${MASON_VERSION}
after_success:
- ./mason publish ${MASON_NAME} ${MASON_VERSION}

10
third_party/mason/scripts/boost_liball_osrm/1.59.0/patch.diff vendored Normal file
View File

@ -0,0 +1,10 @@
--- libs/filesystem/src/operations.cpp 2015-05-01 18:49:26.000000000 -0700
+++ libs/filesystem/src/operations.cpp 2015-05-01 18:49:22.000000000 -0700
@@ -1416,6 +1416,7 @@
// - See the fchmodat() Linux man page:
// "http://man7.org/linux/man-pages/man2/fchmodat.2.html"
# if defined(AT_FDCWD) && defined(AT_SYMLINK_NOFOLLOW) \
+ && !(defined(__APPLE__)) \
&& !(defined(__SUNPRO_CC) || defined(__sun) || defined(sun)) \
&& !(defined(linux) || defined(__linux) || defined(__linux__))
if (::fchmodat(AT_FDCWD, p.c_str(), mode_cast(prms),

96
third_party/mason/scripts/boost_liball_osrm/1.59.0/script.sh vendored Executable file
View File

@ -0,0 +1,96 @@
#!/usr/bin/env bash
BOOST_VERSION1="1.59.0"
BOOST_VERSION2="1_59_0"
BOOST_LIBRARY="regex"
BOOST_TOOLSET="clang"
BOOST_ARCH="x86"
MASON_NAME=boost_liball_osrm
MASON_VERSION=1.59.0
# this boost package has multiple libraries to we
# reference this empty file as a placeholder for all of them
MASON_LIB_FILE=lib/libboost_placeholder.txt
. ${MASON_DIR}/mason.sh
export CXX=${CXX:-clang++}
export MASON_CONCURRENCY_OVERRIDE=${MASON_CONCURRENCY_OVERRIDE:-${MASON_CONCURRENCY}}
function mason_load_source {
mason_download \
http://downloads.sourceforge.net/project/boost/boost/1.59.0/boost_1_59_0.tar.bz2 \
ff2e48f4d7e3c4b393d41e07a2f5d923b990967d
export MASON_BUILD_PATH=${MASON_ROOT}/.build/boost_${BOOST_VERSION2}
mason_extract_tar_bz2
}
function gen_config() {
echo "using $1 : : $(which $2)" > user-config.jam
if [[ "${AR:-false}" != false ]] || [[ "${RANLIB:-false}" != false ]]; then
echo ' : ' >> user-config.jam
if [[ "${AR:-false}" != false ]]; then
echo "<archiver>${AR} " >> user-config.jam
fi
if [[ "${RANLIB:-false}" != false ]]; then
echo "<ranlib>${RANLIB} " >> user-config.jam
fi
fi
echo ' ;' >> user-config.jam
}
function mason_compile {
if [[ -f ../../../patch.diff ]]; then
patch -N -p0 < ../../../patch.diff
else
# patch to workaround crashes in python.input
# https://github.com/mapnik/mapnik/issues/1968
mason_step "Loading patch 'https://github.com/mapbox/mason/blob/${MASON_SLUG}/patch.diff'..."
curl --retry 3 -s -f -# -L \
https://raw.githubusercontent.com/mapbox/mason/${MASON_SLUG}/patch.diff \
-O || (mason_error "Could not find patch for ${MASON_SLUG}" && exit 1)
patch -N -p0 < ./patch.diff
fi
gen_config ${BOOST_TOOLSET} ${CXX}
if [[ ! -f ./b2 ]] ; then
./bootstrap.sh
fi
CXXFLAGS="${CXXFLAGS} -fvisibility=hidden"
./b2 \
--with-regex \
--with-system \
--with-thread \
--with-filesystem \
--with-program_options \
--with-test \
--with-date_time \
--with-iostreams \
--prefix=${MASON_PREFIX} \
-j${MASON_CONCURRENCY_OVERRIDE} \
-sHAVE_ICU=0 \
linkflags="${LDFLAGS:-" "} ${BOOST_LDFLAGS}" \
cxxflags="${CXXFLAGS:-" "}" \
-d0 \
--ignore-site-config --user-config=user-config.jam \
architecture="${BOOST_ARCH}" \
toolset="${BOOST_TOOLSET}" \
link=static \
variant=release \
install
mkdir -p ${MASON_PREFIX}/lib/
touch ${MASON_PREFIX}/lib/libboost_placeholder.txt
}
function mason_ldflags {
:
}
function mason_clean {
make clean
}
mason_run "$@"

27
third_party/mason/scripts/boost_libatomic/1.61.0/.travis.yml vendored Normal file
View File

@ -0,0 +1,27 @@
language: generic
matrix:
include:
- os: osx
osx_image: xcode7.3
- os: linux
sudo: false
env: CXX=clang++-3.5 CC=clang-3.5
addons:
apt:
sources:
- ubuntu-toolchain-r-test
- llvm-toolchain-precise-3.5
packages:
- clang-3.5
env:
global:
- secure: "clCFM3prHnDocZ8lXlimPxAogvFirD1Zx8cMcFJ/XpkTA/0pCgnhpArM4y/NzLHR57pNZTSCr3p6XZI1c1iTG4Zm8x0sK2A4aTFRahypXNy/e+LzAbtd1y1+dEEDwlJvNNGxizQX4frhOgSNQFDFnWLtmF3stlft5YWyc2kI+FI="
- secure: "jKJErCng8Sk8YJ0IN2FX3lhv7G1LeudMfFBAXViZaXn8w/gWPs+SlfXQmIJ5SruU7U2GQKnAhzbjwXjVAgAh8OAblzny0DDm5Lh5WmwkgAP8JH1LpsBwCYx2S/v8qyR4DX1RVhHS8mQu298180ZDVgGccw+hd8xrE/S5TEQcNfQ="
script:
- ./mason build ${MASON_NAME} ${MASON_VERSION}
after_success:
- ./mason publish ${MASON_NAME} ${MASON_VERSION}

26
third_party/mason/scripts/boost_libatomic/1.61.0/script.sh vendored Executable file
View File

@ -0,0 +1,26 @@
#!/usr/bin/env bash
# dynamically determine the path to this package
HERE="$( cd "$( dirname "${BASH_SOURCE[0]}" )" > /dev/null && pwd )"
# key properties unique to this library
THIS_DIR=$(basename $(dirname $HERE))
BOOST_LIBRARY=${THIS_DIR#boost_lib}
MASON_NAME=boost_lib${BOOST_LIBRARY}
MASON_LIB_FILE=lib/libboost_${BOOST_LIBRARY}.a
# hack for inconsistently named test lib
if [[ ${MASON_LIB_FILE} == "lib/libboost_test.a" ]]; then
MASON_LIB_FILE=lib/libboost_unit_test_framework.a
fi
# inherit from boost base (used for all boost library packages)
BASE_PATH=${HERE}/../../boost/$(basename $HERE)
source ${BASE_PATH}/base.sh
# setup mason env
. ${MASON_DIR}/mason.sh
# source common build functions
source ${BASE_PATH}/common.sh
mason_run "$@"

27
third_party/mason/scripts/boost_libchrono/1.61.0/.travis.yml vendored Normal file
View File

@ -0,0 +1,27 @@
language: generic
matrix:
include:
- os: osx
osx_image: xcode7.3
- os: linux
sudo: false
env: CXX=clang++-3.5 CC=clang-3.5
addons:
apt:
sources:
- ubuntu-toolchain-r-test
- llvm-toolchain-precise-3.5
packages:
- clang-3.5
env:
global:
- secure: "clCFM3prHnDocZ8lXlimPxAogvFirD1Zx8cMcFJ/XpkTA/0pCgnhpArM4y/NzLHR57pNZTSCr3p6XZI1c1iTG4Zm8x0sK2A4aTFRahypXNy/e+LzAbtd1y1+dEEDwlJvNNGxizQX4frhOgSNQFDFnWLtmF3stlft5YWyc2kI+FI="
- secure: "jKJErCng8Sk8YJ0IN2FX3lhv7G1LeudMfFBAXViZaXn8w/gWPs+SlfXQmIJ5SruU7U2GQKnAhzbjwXjVAgAh8OAblzny0DDm5Lh5WmwkgAP8JH1LpsBwCYx2S/v8qyR4DX1RVhHS8mQu298180ZDVgGccw+hd8xrE/S5TEQcNfQ="
script:
- ./mason build ${MASON_NAME} ${MASON_VERSION}
after_success:
- ./mason publish ${MASON_NAME} ${MASON_VERSION}

26
third_party/mason/scripts/boost_libchrono/1.61.0/script.sh vendored Executable file
View File

@ -0,0 +1,26 @@
#!/usr/bin/env bash
# dynamically determine the path to this package
HERE="$( cd "$( dirname "${BASH_SOURCE[0]}" )" > /dev/null && pwd )"
# key properties unique to this library
THIS_DIR=$(basename $(dirname $HERE))
BOOST_LIBRARY=${THIS_DIR#boost_lib}
MASON_NAME=boost_lib${BOOST_LIBRARY}
MASON_LIB_FILE=lib/libboost_${BOOST_LIBRARY}.a
# hack for inconsistently named test lib
if [[ ${MASON_LIB_FILE} == "lib/libboost_test.a" ]]; then
MASON_LIB_FILE=lib/libboost_unit_test_framework.a
fi
# inherit from boost base (used for all boost library packages)
BASE_PATH=${HERE}/../../boost/$(basename $HERE)
source ${BASE_PATH}/base.sh
# setup mason env
. ${MASON_DIR}/mason.sh
# source common build functions
source ${BASE_PATH}/common.sh
mason_run "$@"

24
third_party/mason/scripts/boost_libdate_time/1.57.0/.travis.yml vendored Normal file
View File

@ -0,0 +1,24 @@
language: cpp
sudo: false
matrix:
include:
- os: osx
compiler: clang
- os: linux
compiler: clang
env:
global:
- secure: "clCFM3prHnDocZ8lXlimPxAogvFirD1Zx8cMcFJ/XpkTA/0pCgnhpArM4y/NzLHR57pNZTSCr3p6XZI1c1iTG4Zm8x0sK2A4aTFRahypXNy/e+LzAbtd1y1+dEEDwlJvNNGxizQX4frhOgSNQFDFnWLtmF3stlft5YWyc2kI+FI="
- secure: "jKJErCng8Sk8YJ0IN2FX3lhv7G1LeudMfFBAXViZaXn8w/gWPs+SlfXQmIJ5SruU7U2GQKnAhzbjwXjVAgAh8OAblzny0DDm5Lh5WmwkgAP8JH1LpsBwCYx2S/v8qyR4DX1RVhHS8mQu298180ZDVgGccw+hd8xrE/S5TEQcNfQ="
before_install:
- source ./scripts/setup_cpp11_toolchain.sh
script:
- ./mason build ${MASON_NAME} ${MASON_VERSION}
after_success:
- ./mason publish ${MASON_NAME} ${MASON_VERSION}

70
third_party/mason/scripts/boost_libdate_time/1.57.0/script.sh vendored Executable file
View File

@ -0,0 +1,70 @@
#!/usr/bin/env bash
BOOST_VERSION1="1.57.0"
BOOST_VERSION2="1_57_0"
BOOST_LIBRARY="date_time"
BOOST_TOOLSET="clang"
BOOST_ARCH="x86"
MASON_NAME=boost_lib${BOOST_LIBRARY}
MASON_VERSION=1.57.0
MASON_LIB_FILE=lib/libboost_${BOOST_LIBRARY}.a
. ${MASON_DIR}/mason.sh
function mason_load_source {
mason_download \
http://downloads.sourceforge.net/project/boost/boost/${BOOST_VERSION1}/boost_${BOOST_VERSION2}.tar.bz2 \
397306fa6d0858c4885fbba7d43a0164dcb7f53e
export MASON_BUILD_PATH=${MASON_ROOT}/.build/boost_${BOOST_VERSION2}
mason_extract_tar_bz2
}
function gen_config() {
echo "using $1 : : $(which $2)" > user-config.jam
if [[ "${AR:-false}" != false ]] || [[ "${RANLIB:-false}" != false ]]; then
echo ' : ' >> user-config.jam
if [[ "${AR:-false}" != false ]]; then
echo "<archiver>${AR} " >> user-config.jam
fi
if [[ "${RANLIB:-false}" != false ]]; then
echo "<ranlib>${RANLIB} " >> user-config.jam
fi
fi
echo ' ;' >> user-config.jam
}
function mason_compile {
gen_config ${BOOST_TOOLSET} clang++
if [[ ! -f ./b2 ]] ; then
./bootstrap.sh
fi
CXXFLAGS="${CXXFLAGS} -fvisibility=hidden"
./b2 \
--with-${BOOST_LIBRARY} \
--prefix=${MASON_PREFIX} \
-j${MASON_CONCURRENCY} \
-d0 \
--ignore-site-config --user-config=user-config.jam \
architecture="${BOOST_ARCH}" \
toolset="${BOOST_TOOLSET}" \
link=static \
variant=release \
linkflags="${LDFLAGS:-" "}" \
cxxflags="${CXXFLAGS:-" "}" \
stage
mkdir -p $(dirname ${MASON_PREFIX}/${MASON_LIB_FILE})
mv stage/${MASON_LIB_FILE} ${MASON_PREFIX}/${MASON_LIB_FILE}
}
function mason_ldflags {
echo "-lboost_${BOOST_LIBRARY}"
}
function mason_clean {
make clean
}
mason_run "$@"

27
third_party/mason/scripts/boost_libdate_time/1.61.0/.travis.yml vendored Normal file
View File

@ -0,0 +1,27 @@
language: generic
matrix:
include:
- os: osx
osx_image: xcode7.3
- os: linux
sudo: false
env: CXX=clang++-3.5 CC=clang-3.5
addons:
apt:
sources:
- ubuntu-toolchain-r-test
- llvm-toolchain-precise-3.5
packages:
- clang-3.5
env:
global:
- secure: "clCFM3prHnDocZ8lXlimPxAogvFirD1Zx8cMcFJ/XpkTA/0pCgnhpArM4y/NzLHR57pNZTSCr3p6XZI1c1iTG4Zm8x0sK2A4aTFRahypXNy/e+LzAbtd1y1+dEEDwlJvNNGxizQX4frhOgSNQFDFnWLtmF3stlft5YWyc2kI+FI="
- secure: "jKJErCng8Sk8YJ0IN2FX3lhv7G1LeudMfFBAXViZaXn8w/gWPs+SlfXQmIJ5SruU7U2GQKnAhzbjwXjVAgAh8OAblzny0DDm5Lh5WmwkgAP8JH1LpsBwCYx2S/v8qyR4DX1RVhHS8mQu298180ZDVgGccw+hd8xrE/S5TEQcNfQ="
script:
- ./mason build ${MASON_NAME} ${MASON_VERSION}
after_success:
- ./mason publish ${MASON_NAME} ${MASON_VERSION}

26
third_party/mason/scripts/boost_libdate_time/1.61.0/script.sh vendored Executable file
View File

@ -0,0 +1,26 @@
#!/usr/bin/env bash
# dynamically determine the path to this package
HERE="$( cd "$( dirname "${BASH_SOURCE[0]}" )" > /dev/null && pwd )"
# key properties unique to this library
THIS_DIR=$(basename $(dirname $HERE))
BOOST_LIBRARY=${THIS_DIR#boost_lib}
MASON_NAME=boost_lib${BOOST_LIBRARY}
MASON_LIB_FILE=lib/libboost_${BOOST_LIBRARY}.a
# hack for inconsistently named test lib
if [[ ${MASON_LIB_FILE} == "lib/libboost_test.a" ]]; then
MASON_LIB_FILE=lib/libboost_unit_test_framework.a
fi
# inherit from boost base (used for all boost library packages)
BASE_PATH=${HERE}/../../boost/$(basename $HERE)
source ${BASE_PATH}/base.sh
# setup mason env
. ${MASON_DIR}/mason.sh
# source common build functions
source ${BASE_PATH}/common.sh
mason_run "$@"

32
third_party/mason/scripts/boost_libeverything/1.59.0/.travis.yml vendored Normal file
View File

@ -0,0 +1,32 @@
language: C
sudo: false
matrix:
include:
- os: osx
compiler: clang
- os: linux
compiler: clang
env:
global:
- secure: "clCFM3prHnDocZ8lXlimPxAogvFirD1Zx8cMcFJ/XpkTA/0pCgnhpArM4y/NzLHR57pNZTSCr3p6XZI1c1iTG4Zm8x0sK2A4aTFRahypXNy/e+LzAbtd1y1+dEEDwlJvNNGxizQX4frhOgSNQFDFnWLtmF3stlft5YWyc2kI+FI="
- secure: "jKJErCng8Sk8YJ0IN2FX3lhv7G1LeudMfFBAXViZaXn8w/gWPs+SlfXQmIJ5SruU7U2GQKnAhzbjwXjVAgAh8OAblzny0DDm5Lh5WmwkgAP8JH1LpsBwCYx2S/v8qyR4DX1RVhHS8mQu298180ZDVgGccw+hd8xrE/S5TEQcNfQ="
addons:
apt:
sources:
- ubuntu-toolchain-r-test
- llvm-toolchain-precise-3.5
packages:
- clang-3.5
before_install:
script:
- export CXX="clang++-3.5"
- ./mason build ${MASON_NAME} ${MASON_VERSION}
after_success:
- ./mason publish ${MASON_NAME} ${MASON_VERSION}

22
third_party/mason/scripts/boost_libeverything/1.59.0/patch.diff vendored Normal file
View File

@ -0,0 +1,22 @@
--- libs/python/src/converter/builtin_converters.cpp 2012-12-07 11:51:06.000000000 -0800
+++ libs/python/src/converter/builtin_converters.cpp 2014-04-01 17:24:37.000000000 -0700
@@ -32,7 +32,9 @@
void shared_ptr_deleter::operator()(void const*)
{
+ PyGILState_STATE gil = PyGILState_Ensure();
owner.reset();
+ PyGILState_Release(gil);
}
namespace
--- libs/filesystem/src/operations.cpp 2015-05-01 18:49:26.000000000 -0700
+++ libs/filesystem/src/operations.cpp 2015-05-01 18:49:22.000000000 -0700
@@ -1416,6 +1416,7 @@
// - See the fchmodat() Linux man page:
// "http://man7.org/linux/man-pages/man2/fchmodat.2.html"
# if defined(AT_FDCWD) && defined(AT_SYMLINK_NOFOLLOW) \
+ && !(defined(__APPLE__)) \
&& !(defined(__SUNPRO_CC) || defined(__sun) || defined(sun)) \
&& !(defined(linux) || defined(__linux) || defined(__linux__))
if (::fchmodat(AT_FDCWD, p.c_str(), mode_cast(prms),

133
third_party/mason/scripts/boost_libeverything/1.59.0/script.sh vendored Executable file
View File

@ -0,0 +1,133 @@
#!/usr/bin/env bash
BOOST_VERSION1="1.59.0"
BOOST_VERSION2="1_59_0"
BOOST_LIBRARY="regex"
BOOST_TOOLSET="clang"
BOOST_ARCH="x86"
MASON_NAME=boost_libeverything
MASON_VERSION=1.59.0
# this boost package has multiple libraries to we
# reference this empty file as a placeholder for all of them
MASON_LIB_FILE=lib/libboost_placeholder.txt
. ${MASON_DIR}/mason.sh
function mason_load_source {
mason_download \
http://downloads.sourceforge.net/project/boost/boost/1.59.0/boost_1_59_0.tar.bz2 \
ff2e48f4d7e3c4b393d41e07a2f5d923b990967d
export MASON_BUILD_PATH=${MASON_ROOT}/.build/boost_${BOOST_VERSION2}
mason_extract_tar_bz2
}
function gen_config() {
echo "using $1 : : $(which $2)" > user-config.jam
if [[ "${AR:-false}" != false ]] || [[ "${RANLIB:-false}" != false ]]; then
echo ' : ' >> user-config.jam
if [[ "${AR:-false}" != false ]]; then
echo "<archiver>${AR} " >> user-config.jam
fi
if [[ "${RANLIB:-false}" != false ]]; then
echo "<ranlib>${RANLIB} " >> user-config.jam
fi
fi
echo ' ;' >> user-config.jam
}
function mason_prepare_compile {
${MASON_DIR}/mason install icu 55.1
MASON_ICU=$(${MASON_DIR}/mason prefix icu 55.1)
BOOST_LDFLAGS="-L${MASON_ICU}/lib -licuuc -licui18n -licudata"
}
function write_python_config() {
# usage:
# write_python_config <user-config.jam> <version> <base> <variant>
PYTHON_VERSION=$2
# note: apple pythons need '/System'
PYTHON_BASE=$3
# note: python 3 uses 'm'
PYTHON_VARIANT=$4
if [[ ${UNAME} == 'Darwin' ]]; then
echo "
using python
: ${PYTHON_VERSION} # version
: ${PYTHON_BASE}/Library/Frameworks/Python.framework/Versions/${PYTHON_VERSION}/bin/python${PYTHON_VERSION}${PYTHON_VARIANT} # cmd-or-prefix
: ${PYTHON_BASE}/Library/Frameworks/Python.framework/Versions/${PYTHON_VERSION}/include/python${PYTHON_VERSION}${PYTHON_VARIANT} # includes
: ${PYTHON_BASE}/Library/Frameworks/Python.framework/Versions/${PYTHON_VERSION}/lib/python${PYTHON_VERSION}/config${PYTHON_VARIANT} # a lib actually symlink
: <toolset>${BOOST_TOOLSET} # condition
;
" >> $1
else
if [[ ${UNAME} == 'FreeBSD' ]]; then
echo "
using python
: ${PYTHON_VERSION} # version
: /usr/local/bin/python${PYTHON_VERSION}${PYTHON_VARIANT} # cmd-or-prefix
: /usr/local/include/python${PYTHON_VERSION} # includes
: /usr/local/lib/python${PYTHON_VERSION}/config${PYTHON_VARIANT}
: <toolset>${BOOST_TOOLSET} # condition
;
" >> $1
else
echo "
using python
: ${PYTHON_VERSION} # version
: /usr/bin/python${PYTHON_VERSION}${PYTHON_VARIANT} # cmd-or-prefix
: /usr/include/python${PYTHON_VERSION} # includes
: /usr/lib/python${PYTHON_VERSION}/config${PYTHON_VARIANT}
: <toolset>${BOOST_TOOLSET} # condition
;
" >> $1
fi
fi
}
function mason_compile {
if [[ -f ../../../patch.diff ]]; then
patch -N -p0 < ../../../patch.diff
else
# patch to workaround crashes in python.input
# https://github.com/mapnik/mapnik/issues/1968
mason_step "Loading patch 'https://github.com/mapbox/mason/blob/${MASON_SLUG}/patch.diff'..."
curl --retry 3 -s -f -# -L \
https://raw.githubusercontent.com/mapbox/mason/${MASON_SLUG}/patch.diff \
-O || (mason_error "Could not find patch for ${MASON_SLUG}" && exit 1)
patch -N -p0 < ./patch.diff
fi
gen_config ${BOOST_TOOLSET} clang++
if [[ ! -f ./b2 ]] ; then
./bootstrap.sh
fi
CXXFLAGS="${CXXFLAGS} -fvisibility=hidden"
./b2 \
--prefix=${MASON_PREFIX} \
-j${MASON_CONCURRENCY} \
-sHAVE_ICU=1 -sICU_PATH=${MASON_ICU} \
linkflags="${LDFLAGS:-" "} ${BOOST_LDFLAGS}" \
cxxflags="${CXXFLAGS:-" "}" \
-d0 \
--ignore-site-config --user-config=user-config.jam \
architecture="${BOOST_ARCH}" \
toolset="${BOOST_TOOLSET}" \
variant=release \
install
mkdir -p ${MASON_PREFIX}/lib/
touch ${MASON_PREFIX}/lib/libboost_placeholder.txt
}
function mason_ldflags {
:
}
function mason_clean {
make clean
}
mason_run "$@"

24
third_party/mason/scripts/boost_libfilesystem/1.57.0/.travis.yml vendored Normal file
View File

@ -0,0 +1,24 @@
language: cpp
sudo: false
matrix:
include:
- os: osx
compiler: clang
- os: linux
compiler: clang
env:
global:
- secure: "clCFM3prHnDocZ8lXlimPxAogvFirD1Zx8cMcFJ/XpkTA/0pCgnhpArM4y/NzLHR57pNZTSCr3p6XZI1c1iTG4Zm8x0sK2A4aTFRahypXNy/e+LzAbtd1y1+dEEDwlJvNNGxizQX4frhOgSNQFDFnWLtmF3stlft5YWyc2kI+FI="
- secure: "jKJErCng8Sk8YJ0IN2FX3lhv7G1LeudMfFBAXViZaXn8w/gWPs+SlfXQmIJ5SruU7U2GQKnAhzbjwXjVAgAh8OAblzny0DDm5Lh5WmwkgAP8JH1LpsBwCYx2S/v8qyR4DX1RVhHS8mQu298180ZDVgGccw+hd8xrE/S5TEQcNfQ="
before_install:
- source ./scripts/setup_cpp11_toolchain.sh
script:
- ./mason build ${MASON_NAME} ${MASON_VERSION}
after_success:
- ./mason publish ${MASON_NAME} ${MASON_VERSION}

10
third_party/mason/scripts/boost_libfilesystem/1.57.0/patch.diff vendored Normal file
View File

@ -0,0 +1,10 @@
--- libs/filesystem/src/operations.cpp 2015-05-01 18:49:26.000000000 -0700
+++ libs/filesystem/src/operations.cpp 2015-05-01 18:49:22.000000000 -0700
@@ -1416,6 +1416,7 @@
// - See the fchmodat() Linux man page:
// "http://man7.org/linux/man-pages/man2/fchmodat.2.html"
# if defined(AT_FDCWD) && defined(AT_SYMLINK_NOFOLLOW) \
+ && !(defined(__APPLE__)) \
&& !(defined(__SUNPRO_CC) || defined(__sun) || defined(sun)) \
&& !(defined(linux) || defined(__linux) || defined(__linux__))
if (::fchmodat(AT_FDCWD, p.c_str(), mode_cast(prms),

76
third_party/mason/scripts/boost_libfilesystem/1.57.0/script.sh vendored Executable file
View File

@ -0,0 +1,76 @@
#!/usr/bin/env bash
BOOST_VERSION1="1.57.0"
BOOST_VERSION2="1_57_0"
BOOST_LIBRARY="filesystem"
BOOST_TOOLSET="clang"
BOOST_ARCH="x86"
MASON_NAME=boost_lib${BOOST_LIBRARY}
MASON_VERSION=1.57.0
MASON_LIB_FILE=lib/libboost_${BOOST_LIBRARY}.a
. ${MASON_DIR}/mason.sh
function mason_load_source {
mason_download \
http://downloads.sourceforge.net/project/boost/boost/${BOOST_VERSION1}/boost_${BOOST_VERSION2}.tar.bz2 \
397306fa6d0858c4885fbba7d43a0164dcb7f53e
export MASON_BUILD_PATH=${MASON_ROOT}/.build/boost_${BOOST_VERSION2}
mason_extract_tar_bz2
}
function gen_config() {
echo "using $1 : : $(which $2)" > user-config.jam
if [[ "${AR:-false}" != false ]] || [[ "${RANLIB:-false}" != false ]]; then
echo ' : ' >> user-config.jam
if [[ "${AR:-false}" != false ]]; then
echo "<archiver>${AR} " >> user-config.jam
fi
if [[ "${RANLIB:-false}" != false ]]; then
echo "<ranlib>${RANLIB} " >> user-config.jam
fi
fi
echo ' ;' >> user-config.jam
}
function mason_compile {
mason_step "Loading patch 'https://github.com/mapbox/mason/blob/${MASON_SLUG}/patch.diff'..."
curl --retry 3 -s -f -# -L \
https://raw.githubusercontent.com/mapbox/mason/${MASON_SLUG}/patch.diff \
-O || (mason_error "Could not find patch for ${MASON_SLUG}" && exit 1)
patch -N -p0 < ./patch.diff
gen_config ${BOOST_TOOLSET} clang++
if [[ ! -f ./b2 ]] ; then
./bootstrap.sh
fi
CXXFLAGS="${CXXFLAGS} -fvisibility=hidden"
./b2 \
--with-${BOOST_LIBRARY} \
--prefix=${MASON_PREFIX} \
-j${MASON_CONCURRENCY} \
-d0 \
--ignore-site-config --user-config=user-config.jam \
architecture="${BOOST_ARCH}" \
toolset="${BOOST_TOOLSET}" \
link=static \
variant=release \
linkflags="${LDFLAGS:-" "}" \
cxxflags="${CXXFLAGS:-" "}" \
stage
mkdir -p $(dirname ${MASON_PREFIX}/${MASON_LIB_FILE})
mv stage/${MASON_LIB_FILE} ${MASON_PREFIX}/${MASON_LIB_FILE}
}
function mason_ldflags {
echo "-lboost_${BOOST_LIBRARY}"
}
function mason_clean {
make clean
}
mason_run "$@"

27
third_party/mason/scripts/boost_libfilesystem/1.61.0/.travis.yml vendored Normal file
View File

@ -0,0 +1,27 @@
language: generic
matrix:
include:
- os: osx
osx_image: xcode7.3
- os: linux
sudo: false
env: CXX=clang++-3.5 CC=clang-3.5
addons:
apt:
sources:
- ubuntu-toolchain-r-test
- llvm-toolchain-precise-3.5
packages:
- clang-3.5
env:
global:
- secure: "clCFM3prHnDocZ8lXlimPxAogvFirD1Zx8cMcFJ/XpkTA/0pCgnhpArM4y/NzLHR57pNZTSCr3p6XZI1c1iTG4Zm8x0sK2A4aTFRahypXNy/e+LzAbtd1y1+dEEDwlJvNNGxizQX4frhOgSNQFDFnWLtmF3stlft5YWyc2kI+FI="
- secure: "jKJErCng8Sk8YJ0IN2FX3lhv7G1LeudMfFBAXViZaXn8w/gWPs+SlfXQmIJ5SruU7U2GQKnAhzbjwXjVAgAh8OAblzny0DDm5Lh5WmwkgAP8JH1LpsBwCYx2S/v8qyR4DX1RVhHS8mQu298180ZDVgGccw+hd8xrE/S5TEQcNfQ="
script:
- ./mason build ${MASON_NAME} ${MASON_VERSION}
after_success:
- ./mason publish ${MASON_NAME} ${MASON_VERSION}

Some files were not shown because too many files have changed in this diff Show More