buildall

#!/usr/bin/env bash

#
# The BSD 3-Clause License. http://www.opensource.org/licenses/BSD-3-Clause
#
# This file is part of 'Qt-builds' project.
# Copyright (c) 2013 by Alexpux (alexpux@gmail.com)
# All rights reserved.
#
# Project: Qt-builds ( https://github.com/Alexpux/Qt-builds )
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
# - Redistributions of source code must retain the above copyright
#     notice, this list of conditions and the following disclaimer.
# - Redistributions in binary form must reproduce the above copyright
#     notice, this list of conditions and the following disclaimer in
#     the documentation and/or other materials provided with the distribution.
# - Neither the name of the 'Qt-builds' nor the names of its contributors may
#     be used to endorse or promote products derived from this software
#     without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED.
# IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
# OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
# USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#

# **************************************************************************

export TERM=cygwin
export MSYSTEM=MINGW32
export LC_ALL=en_US.UTF-8
unset SHELL

QT_BUILDS_VERSION="Qt-builds-0.5.0"
BUG_URL=https://github.com/Alexpux/Qt-builds

ORIGINAL_PATH=$PATH

pushd $SYSTEMROOT > /dev/null
WIN_SYS=`pwd`
popd > /dev/null

WINDOWS_PART_PATH=$WIN_SYS/system32:$WIN_SYS
MSYS_PART_PATH=.:/usr/local/bin:/bin
export PATH=$MSYS_PART_PATH:$WINDOWS_PART_PATH

[[ $(env | grep PROCESSOR_ARCHITECTURE) =~ AMD64 || $(env | grep PROCESSOR_ARCHITEW6432) =~ AMD64 ]] && {
	IS_64BIT_HOST=yes
} || {
	IS_64BIT_HOST=no
}

# directories
TOP_DIR=`pwd`
PREFIX_TOP=/c/QtSDK
PATCH_DIR=${TOP_DIR}/patches
PACKAGE_DIR=${TOP_DIR}/packages
PROG_DIR=${TOP_DIR}/progs
SCENARIOS=${TOP_DIR}/scenarios
ROOT_DIR=${TOP_DIR}/work

# DirectX SDK installation and logviewer paths
[[ $IS_64BIT_HOST == yes ]] && {
	DXSDK_DIR="C:/Program Files (x86)/Microsoft DirectX SDK (June 2010)/"
	LOGVIEWER="c:/progra~2/notepad++/notepad++.exe"
} || {
	DXSDK_DIR="C:/Program Files/Microsoft DirectX SDK (June 2010)/"
	LOGVIEWER="c:/progra~1/notepad++/notepad++.exe"
}
[[ -d "$DXSDK_DIR" ]] || echo "WARNING: You need installed DirectX SDK for building Qt5..."
[[ -f "$LOGVIEWER" ]] || LOGVIEWER="/c/Windows/system32/notepad.exe"
SHOW_LOG_ON_ERROR=yes

# MinGW toolchain links

# setup toolchain details
GCC_VERSION=4.8.1
REV_VERSION=rev5
ROOT_URL=http://sourceforge.net/projects/mingwbuilds/files/host-windows/releases

# threads=posix
URL_MINGW32_POSIX=${ROOT_URL}/${GCC_VERSION}/32-bit/threads-posix/dwarf/x32-${GCC_VERSION}-release-posix-dwarf-${REV_VERSION}.7z
URL_MINGW64_POSIX=${ROOT_URL}/${GCC_VERSION}/64-bit/threads-posix/seh/x64-${GCC_VERSION}-release-posix-seh-${REV_VERSION}.7z
TOOLCHAINS_DIR_POSIX=${TOP_DIR}/toolchains_posix
# threads=win32
URL_MINGW32_WIN32=${ROOT_URL}/${GCC_VERSION}/32-bit/threads-win32/dwarf/x32-${GCC_VERSION}-release-win32-dwarf-${REV_VERSION}.7z
URL_MINGW64_WIN32=${ROOT_URL}/${GCC_VERSION}/64-bit/threads-win32/seh/x64-${GCC_VERSION}-release-win32-seh-${REV_VERSION}.7z
TOOLCHAINS_DIR_WIN32=${TOP_DIR}/toolchains_win32

# By default use posix toolchains
TOOLCHAINS_DIR=${TOOLCHAINS_DIR_POSIX}
URL_MINGW32=${URL_MINGW32_POSIX}
URL_MINGW64=${URL_MINGW64_POSIX}

# Use system installed toolchains
USER_DEFINED_TOOLCHAINS=no

# Update sources from repositories
UPDATE_SOURCES=no

# MinGW-builds contain prebuilded python in opt subdirectory.
# Does we use msys-python, mingw-builds python or build python yourself.
USE_PYTHON=msys

# Build and use Ruby
BUILD_RUBY=no

# Build and use Perl
BUILD_PERL=yes

# Build Qt-Creator
BUILD_QTCREATOR=yes

# Build some extra libraries
BUILD_EXTRA_STUFF=no
BUILD_OSG=no
BUILD_COIN3D=no

# Build Flags
MAKE_OPTS="-j3"
STATIC_LINK_FLAGS="--enable-static --disable-shared"
SHARED_LINK_FLAGS="--enable-shared --disable-static"

# How to link dependencies
LNKDEPS=$SHARED_LINK_FLAGS
STATIC_DEPS=no
STATIC_SUFFIX=""
STATIC_LD=""

# Default Qt version to build
QT_VERSION="5.1.1"

#Use different folders for building Qt with different opengl options
QTDIR_PREFIX="angle"

# Qt5 git branch to build
QT_GIT_BRANCH="stable"

# Build Qt5 with "-opengl desktop"
USE_OPENGL_DESKTOP=no

RUN_ARGS="$@"
[[ $# == 1 && $1 == --help	|| $[ $# == 0 ] == 1 ]] && {
	echo "usage:"
	echo "  ./${0##*/} <i686|x86_64> [OPTIONS]"
	echo "  help:"
	echo "    --buildroot=<path>      - specifies the build root directory"
	echo "                              Default is $ROOT_DIR/work"
	echo "    --install-top           - specifies the top installation directory"
	echo "                              Default is $PREFIX_TOP"
	echo "    --toolchains-dir=<path> - specifies directory where installed Mingw 32-bit and 64-bit toolchains"
	echo "                              You must have mingw32 and mingw64 directories there"
	echo "    --update-sources        - try update sources from repositories"
	echo "    --opengl-desktop        - build Qt with opengl=desktop (for Qt-5.x only)"
	echo "    --qt-version=<version>  - specifies the Qt version to build"
	echo "                              Default Qt version is $QT_VERSION"
	echo "    --qt-git-branch=<branch> - Specify what Qt git branch to clone when building Qt from git"
	echo "                               Default branch is - $QT_GIT_BRANCH"
	echo "    --build-python          - specifies to the script to build Python and use it when building Qt"
	echo "    --toolchain-python      - specifies to the script to use Python from mingw-builds toolchain"
	echo "    --build-ruby            - specifies to the script to build Ruby and use it when building Qt"
	echo "                              By default using MSYS2 Ruby"
	echo "    --make-jobs=<x>         - specifies number of jobs for make command (-jx)"
	echo "                              Default is 3"
	echo "    --no-qtcreator          - disable building Qt-Creator"
	echo "    --static-qt             - build Qt to static libraries"
	echo "    --extra-stuff           - build extra libraries"
	echo "    --osg                   - build OpenSceneGraph"
	echo "    --coin3d                - build Coin3D"
	echo "    --version               - print the version of the Qt-builds scripts"
	echo "  Available Qt versions:"
	echo "    4.8.4, 4.8.5, 5.0.0, 5.0.1, 5.0.2, 5.1.0, 5.1.1, git"

	exit 0
}

export INSTALL=/bin/install

source helpers_functions.sh

[[ -d /mingw ]] && {
	die "please remove \"/mingw\" directory. terminate."
}

[[ -n $(which "gcc.exe" 2>/dev/null) || \
	-n $(which "i686-pc-mingw32-gcc.exe" 2>/dev/null) || \
	-n $(which "i686-w64-mingw32-gcc.exe" 2>/dev/null) || \
	-n $(which "x86_64-w64-mingw32-gcc.exe" 2>/dev/null) \
]] && {
	die "remove from PATH any existing MinGW directory. terminate."
}

while [[ $# > 0 ]]; do
	case $1 in
		--buildroot=*)
			ROOT_DIR=${1/--buildroot=/}
			ROOT_DIR=${ROOT_DIR//:/:\/}
			ROOT_DIR=${ROOT_DIR//\/\//\/}
			
			mkdir -p ${ROOT_DIR} || die "Incorrect directory ${ROOT_DIR}"
			pushd ${ROOT_DIR} > /dev/null
			ROOT_DIR=`pwd`
			popd > /dev/null
		;;
		--install-top=*)
			PREFIX_TOP=${1/--install-top=/}
			PREFIX_TOP=${PREFIX_TOP//:/:\/}
			PREFIX_TOP=${PREFIX_TOP//\/\//\/}
			
			mkdir -p ${PREFIX_TOP} || die "Incorrect directory ${PREFIX_TOP}"
			pushd ${PREFIX_TOP} > /dev/null
			PREFIX_TOP=`pwd`
			popd > /dev/null
		;;
		--toolchains-dir=*)
			TOOLCHAINS_DIR=${1/--toolchains-dir=/}
			TOOLCHAINS_DIR=${TOOLCHAINS_DIR//:/:\/}
			TOOLCHAINS_DIR=${TOOLCHAINS_DIR//\/\//\/}

			mkdir -p ${TOOLCHAINS_DIR} || die "Incorrect directory ${TOOLCHAINS_DIR}"
			pushd ${TOOLCHAINS_DIR} > /dev/null
			TOOLCHAINS_DIR=`pwd`
			popd > /dev/null
			USER_DEFINED_TOOLCHAINS=yes
		;;
		--update-sources) UPDATE_SOURCES=yes ;;
		--opengl-desktop)
			USE_OPENGL_DESKTOP=yes
			QTDIR_PREFIX="opengl"
		;;
		--qt-version=*) QT_VERSION=${1/--qt-version=/} ;;
		--qt-git-branch=*) QT_GIT_BRANCH=${1/--qt-git-branch=/} ;;
		--version) echo $QT_BUILDS_VERSION; exit 0 ;;
		--build-python) USE_PYTHON=self ;;
		--toolchain-python) USE_PYTHON=toolchain ;;
		--build-ruby) BUILD_RUBY=yes ;;
		--make-jobs=*) MAKE_OPTS=${1/--make-jobs=/} ;;
		--no-qtcreator) BUILD_QTCREATOR=no ;;
		--static-qt)
			export lt_cv_deplibs_check_method='pass_all'
			LNKDEPS=$STATIC_LINK_FLAGS
			USE_OPENGL_DESKTOP=yes
			BUILD_QTCREATOR=no
			BUILD_QDESKTOPCOMPONENTS=no
			STATIC_DEPS=yes
			STATIC_SUFFIX="-s"
			STATIC_LD="-static-libstdc++ -static-libgcc"
			# For static building prefer to use toolchains with threads=win32
			# to avoid dependency from libwinpthread-1.dll
			[[ $USER_DEFINED_TOOLCHAINS == no ]] && {
				TOOLCHAINS_DIR=${TOOLCHAINS_DIR_WIN32}
			}
			URL_MINGW32=${URL_MINGW32_WIN32}
			URL_MINGW64=${URL_MINGW64_WIN32}
		;;
		--extra-stuff) BUILD_EXTRA_STUFF=yes ;;
		--osg) 
			BUILD_EXTRA_STUFF=yes
			BUILD_OSG=yes
		;;
		--coin3d)
			BUILD_EXTRA_STUFF=yes
			BUILD_COIN3D=yes
		;;
		i686)
			[[ ${BUILD_ARCHITECTURES[@]} =~ i686 ]] && { shift; continue; }
			BUILD_ARCHITECTURES=( ${BUILD_ARCHITECTURES[@]} i686 )
		;;
		x86_64)
			[[ ${BUILD_ARCHITECTURES[@]} =~ x86_64 ]] && { shift; continue; }
			BUILD_ARCHITECTURES=( ${BUILD_ARCHITECTURES[@]} x86_64 )
		;;
		
		*)
			echo "bad command line: \"$1\""
			die "terminate."
		;;
	esac
	shift
done

SRC_DIR=${ROOT_DIR}/src
MARKERS_DIR=${ROOT_DIR}/markers
UNPACK_DIR=${ROOT_DIR}/unpack

mkdir -p $SRC_DIR $MARKERS_DIR $TOOLCHAINS_DIR $UNPACK_DIR

[[ ${#BUILD_ARCHITECTURES[@]} > 2 || ${#BUILD_ARCHITECTURES[@]} == 0 || \
	${BUILD_ARCHITECTURES[0]} == ${BUILD_ARCHITECTURES[1]} ]] && {
	die "error in build architectures(${BUILD_ARCHITECTURES[@]}). terminate."
}

[[ $IS_64BIT_HOST == no && ${BUILD_ARCHITECTURES[@]} =~ x86_64 ]] && {
	die "you can't build 64-bit programs using 32-bit OS. terminate."
}

[[ ! -f $SCENARIOS/qt-${QT_VERSION}.sh ]] && {
	die "Can't find script to build version $QT_VERSION of Qt."
}

i686_HOST_MINGW_PATH=${TOOLCHAINS_DIR}/mingw32
x86_64_HOST_MINGW_PATH=${TOOLCHAINS_DIR}/mingw64

[[ $USER_DEFINED_TOOLCHAINS == no ]] && {
	toolchains_prepare
}

[[ ! -d $i686_HOST_MINGW_PATH || ! -d $x86_64_HOST_MINGW_PATH ]] && {
	die "Host toolchains is not installed. Terminate!"
}

[[ $USE_PYTHON == msys ]] && {
    command -v "python" > /dev/null 2>&1 || { USE_PYTHON=self; }
}

[[ $BUILD_RUBY == no ]] && {
    command -v "ruby" > /dev/null 2>&1 || { BUILD_RUBY=yes; }
}
	
source versions.sh
source package_order.sh

for ARCHITECTURE in ${BUILD_ARCHITECTURES[@]}; do

	PREFIX=${PREFIX_TOP}/prerequisites-${ARCHITECTURE}${STATIC_SUFFIX}
	[[ $QT_VERSION == git ]] && {
		QTVER=${QT_VERSION}${STATIC_SUFFIX}-${QT_GIT_BRANCH}
		QTVER=${QTVER//debug/deb}
		QTVER=${QTVER//release/rel}
	} || {
		QTVER=${QT_VERSION}${STATIC_SUFFIX}
	}
	QTDIR=${PREFIX_TOP}/Qt-${QTVER}-${ARCHITECTURE}-${QTDIR_PREFIX}
	BUILD_DIR=${ROOT_DIR}/build-$ARCHITECTURE${STATIC_SUFFIX}
	LOG_DIR=${ROOT_DIR}/logs-$ARCHITECTURE${STATIC_SUFFIX}

	[[ $ARCHITECTURE == i686 ]] && {
		HOST=i686-w64-mingw32
		BUILD=i686-w64-mingw32
		TARGET=i686-w64-mingw32
		OPTIM="-march=i686 -mtune=core2"
		[[ ! -f $i686_HOST_MINGW_PATH/bin/gcc.exe ]] && {
			die "gcc.exe is not exists in the \"$i686_HOST_MINGW_PATH/bin\" directory. terminate."
		}
		MINGWHOME=$i686_HOST_MINGW_PATH
	} || {
		HOST=x86_64-w64-mingw32
		BUILD=x86_64-w64-mingw32
		TARGET=x86_64-w64-mingw32
		OPTIM="-march=nocona -mtune=core2"
		[[ ! -f $x86_64_HOST_MINGW_PATH/bin/gcc.exe ]] && {
			die "gcc.exe is not exists in the \"$x86_64_HOST_MINGW_PATH/bin\" directory. terminate."
		}
		MINGWHOME=$x86_64_HOST_MINGW_PATH
	}

	pushd $MINGWHOME > /dev/null
	MINGWHOME_WIN=`pwd -W`
	popd > /dev/null

	mkdir -p $BUILD_DIR $QTDIR $LOG_DIR $PREFIX

	pushd ${PREFIX} > /dev/null
	export PREFIX_WIN=`pwd -W`
	popd > /dev/null
	
	MINGW_PART_PATH=$PREFIX/bin:$QTDIR/bin:$MINGWHOME/bin

	[[ $USE_PYTHON == toolchain ]] && {
		MINGW_PYTHON2_PREFIX=$MINGWHOME/opt
		MINGW_PYTHON2_PREFIX_W=$MINGWHOME_WIN/opt
		export PYTHONHOME=$MINGW_PYTHON2_PREFIX_W
		MINGW_PART_PATH=$MINGW_PART_PATH:$MINGW_PYTHON2_PREFIX/bin
	}

	export PATH=$MINGW_PART_PATH:$PATH

	HOST_CFLAGS="$OPTIM -pipe -O2"
	HOST_CXXFLAGS="${HOST_CFLAGS}"
	HOST_CPPFLAGS="-I${PREFIX}/include" #-I$PYTHONHOME/include
	HOST_LDFLAGS="$STATIC_LD -pipe -s -L${PREFIX}/lib" #-L$PYTHONHOME/lib/python2.7/config
	export PKG_CONFIG_PATH="${PREFIX}/lib/pkgconfig:${QTDIR}/lib/pkgconfig"

	pushd ${QTDIR} > /dev/null
	export QTDIR_WIN=`pwd -W`
	popd > /dev/null

	echo "-> Start building"

	for sub in ${PACKAGES[@]}; do
		echo -e "-> \E[32;40m$sub\E[37;40m"
		[[ ! -f $SCENARIOS/$sub.sh ]] && {
			die "script for subtarget \"$sub\" is not exists. terminate."
		}

		source ${SCENARIOS}/${sub}.sh

		src_download
		src_unpack
		src_patch
		src_configure
		pkg_build
		pkg_install

	done
done