gentoo-x86/eclass/qt4-build.eclass

# Copyright 2007-2009 Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2
# $Header: /var/cvsroot/gentoo-x86/eclass/qt4-build.eclass,v 1.21 2009/02/14 22:25:10 hwoarang Exp $

# @ECLASS: qt4-build.eclass
# @MAINTAINER:
# Ben de Groot <yngwin@gentoo.org>
# Markos Chandras <hwoarang@gentoo.org>
# Caleb Tennis <caleb@gentoo.org>
# @BLURB: Eclass for Qt4 split ebuilds.
# @DESCRIPTION:
# This eclass contains various functions that are used when building Qt4

inherit eutils multilib toolchain-funcs flag-o-matic versionator

IUSE="${IUSE} custom-cxxflags debug pch"

case "${PV}" in
        4.?.?_rc*)
                SRCTYPE="${SRCTYPE:-opensource-src}"
                MY_PV="${PV/_rc/-rc}"
                ;;
        *)
                SRCTYPE="${SRCTYPE:-opensource-src}"
                MY_PV="${PV}"
                ;;
esac
MY_P=qt-x11-${SRCTYPE}-${MY_PV}
S=${WORKDIR}/${MY_P}

HOMEPAGE="http://www.qtsoftware.com/"
SRC_URI="ftp://ftp.trolltech.com/qt/source/${MY_P}.tar.bz2"

case "${PV}" in
        4.4.?) SRC_URI="${SRC_URI} mirror://gentoo/${MY_P}-headers.tar.bz2" ;;
        *)     ;;
esac

qt4-build_pkg_setup() {
        # EAPI=2 ebuilds set use-deps, others need this:
        if [[ $EAPI != 2 ]]; then
                # Make sure debug setting corresponds with qt-core (bug 258512)
                if [[ $PN != "qt-core" ]]; then
                        use debug && QT4_BUILT_WITH_USE_CHECK="${QT4_BUILT_WITH_USE_CHECK}
                                ~x11-libs/qt-core-${PV} debug"
                fi

                # Check USE requirements
                qt4-build_check_use
        fi

        # Set up installation directories
        QTBASEDIR=/usr/$(get_libdir)/qt4
        QTPREFIXDIR=/usr
        QTBINDIR=/usr/bin
        QTLIBDIR=/usr/$(get_libdir)/qt4
        QTPCDIR=/usr/$(get_libdir)/pkgconfig
        QTDATADIR=/usr/share/qt4
        QTDOCDIR=/usr/share/doc/qt-${PV}
        QTHEADERDIR=/usr/include/qt4
        QTPLUGINDIR=${QTLIBDIR}/plugins
        QTSYSCONFDIR=/etc/qt4
        QTTRANSDIR=${QTDATADIR}/translations
        QTEXAMPLESDIR=${QTDATADIR}/examples
        QTDEMOSDIR=${QTDATADIR}/demos

        PLATFORM=$(qt_mkspecs_dir)

        PATH="${S}/bin:${PATH}"
        LD_LIBRARY_PATH="${S}/lib:${LD_LIBRARY_PATH}"

        if ! version_is_at_least 4.1 $(gcc-version) ; then
                ewarn "Using a GCC version lower than 4.1 is not supported!"
                echo
                ebeep 5
        fi

        if use custom-cxxflags; then
                echo
                ewarn "You have set USE=custom-cxxflags, which means Qt will be built with the"
                ewarn "CXXFLAGS you have set in /etc/make.conf. This is not supported, and we"
                ewarn "recommend to unset this useflag. But you are free to experiment with it."
                ewarn "Just do not start crying if it breaks your system, or eats your kitten"
                ewarn "for breakfast. ;-) "
                echo
        fi

}

qt4-build_src_unpack() {
        local target targets
        for target in configure LICENSE.{GPL2,GPL3} projects.pro \
                src/{qbase,qt_targets,qt_install}.pri bin config.tests mkspecs qmake \
                ${QT4_EXTRACT_DIRECTORIES}; do
                        targets="${targets} ${MY_P}/${target}"
        done

        echo tar xjpf "${DISTDIR}"/${MY_P}.tar.bz2 ${targets}
        tar xjpf "${DISTDIR}"/${MY_P}.tar.bz2 ${targets}

        case "${PV}" in
                4.4.?)
                        echo tar xjpf "${DISTDIR}"/${MY_P}-headers.tar.bz2
                        tar xjpf "${DISTDIR}"/${MY_P}-headers.tar.bz2
                        ;;
        esac

        # Be backwards compatible for now
        if [[ $EAPI != 2 ]]; then
                qt4-build_src_prepare
        fi
}

qt4-build_src_prepare() {
        cd "${S}"

        if [[ ${PN} != qt-core ]]; then
                skip_qmake_build_patch
                skip_project_generation_patch
                symlink_binaries_to_buildtree
        fi
        
        # Bug 172219    
        if ! use custom-cxxflags;then
                # Don't let the user go too overboard with flags.
                strip-flags
                replace-flags -O3 -O2
        fi

        # Bug 253127
        # Unsupported old gcc versions - hardened needs this :(
        if [[ $(gcc-major-version) -lt "4" ]] ; then
                ewarn "Appending -fno-stack-protector to CXXFLAGS"
                append-cxxflags -fno-stack-protector
        fi

        # Bug 178652
        if [[ "$(gcc-major-version)" == "3" ]] && use amd64; then
                ewarn "Appending -fno-gcse to CFLAGS/CXXFLAGS"
                append-flags -fno-gcse
        fi

        
        sed -e "s:QMAKE_CFLAGS_RELEASE.*=.*:QMAKE_CFLAGS_RELEASE=${CFLAGS}:" \
                -e "s:QMAKE_CXXFLAGS_RELEASE.*=.*:QMAKE_CXXFLAGS_RELEASE=${CXXFLAGS}:" \
                -e "s:QMAKE_LFLAGS_RELEASE.*=.*:QMAKE_LFLAGS_RELEASE=${LDFLAGS}:" \
                -e "s:X11R6/::" \
                -i "${S}"/mkspecs/$(qt_mkspecs_dir)/qmake.conf || die "sed ${S}/mkspecs/$(qt_mkspecs_dir)/qmake.conf failed"

        sed -e "s:QMAKE_CFLAGS_RELEASE.*=.*:QMAKE_CFLAGS_RELEASE=${CFLAGS}:" \
                -e "s:QMAKE_CXXFLAGS_RELEASE.*=.*:QMAKE_CXXFLAGS_RELEASE=${CXXFLAGS}:" \
                -e "s:QMAKE_LFLAGS_RELEASE.*=.*:QMAKE_LFLAGS_RELEASE=${LDFLAGS}:" \
                -i "${S}"/mkspecs/common/g++.conf || die "sed ${S}/mkspecs/common/g++.conf failed"

}

qt4-build_src_configure() {

        myconf="$(standard_configure_options) ${myconf}"

        echo ./configure ${myconf}
        ./configure ${myconf} || die "./configure failed"
}

qt4-build_src_compile() {
        # Be backwards compatible for now
        if [[ $EAPI != 2 ]]; then
                qt4-build_src_configure
        fi

        build_directories "${QT4_TARGET_DIRECTORIES}"
}

qt4-build_src_install() {
        install_directories "${QT4_TARGET_DIRECTORIES}"
        install_qconfigs
        fix_library_files
}

standard_configure_options() {
        local myconf=""

        [[ $(get_libdir) != "lib" ]] && myconf="${myconf} -L/usr/$(get_libdir)"

        # Disable visibility explicitly if gcc version isn't 4
        if [[ "$(gcc-major-version)" -lt "4" ]]; then
                myconf="${myconf} -no-reduce-exports"
        fi

        # precompiled headers doesn't work on hardened, where the flag is masked.
        if use pch; then
                myconf="${myconf} -pch"
        else
                myconf="${myconf} -no-pch"
        fi

        if use debug; then
                myconf="${myconf} -debug -no-separate-debug-info"
        else
                myconf="${myconf} -release -no-separate-debug-info"
        fi

        # ARCH is set on Gentoo. Qt now falls back to generic on an unsupported
        # ${ARCH}. Therefore we convert it to supported values.
        case "${ARCH}" in
                amd64) myconf="${myconf} -arch x86_64" ;;
                ppc|ppc64) myconf="${myconf} -arch powerpc" ;;
                x86|x86-*) myconf="${myconf} -arch i386" ;;
                alpha|arm|ia64|mips|s390|sparc) myconf="${myconf} -arch ${ARCH}" ;;
                hppa|sh) myconf="${myconf} -arch generic" ;;
                *) die "${ARCH} is unsupported by this eclass. Please file a bug." ;;
        esac

        myconf="${myconf} -stl -verbose -largefile -confirm-license -no-rpath
                -prefix ${QTPREFIXDIR} -bindir ${QTBINDIR} -libdir ${QTLIBDIR}
                -datadir ${QTDATADIR} -docdir ${QTDOCDIR} -headerdir ${QTHEADERDIR}
                -plugindir ${QTPLUGINDIR} -sysconfdir ${QTSYSCONFDIR}
                -translationdir ${QTTRANSDIR} -examplesdir ${QTEXAMPLESDIR}
                -demosdir ${QTDEMOSDIR} -silent -fast
                $([[ ${PN} == qt-xmlpatterns ]] || echo -no-exceptions)
                $(use x86-fbsd || echo -reduce-relocations)
                -nomake examples -nomake demos"

        echo "${myconf}"
}

build_directories() {
        local dirs="$@"
        for x in ${dirs}; do
                cd "${S}"/${x}
                "${S}"/bin/qmake "LIBS+=-L${QTLIBDIR}" "CONFIG+=nostrip" || die "qmake failed"
                emake || die "emake failed"
        done
}

install_directories() {
        local dirs="$@"
        for x in ${dirs}; do
                pushd "${S}"/${x} >/dev/null || die "Can't pushd ${S}/${x}"
                emake INSTALL_ROOT="${D}" install || die "emake install failed"
                popd >/dev/null || die "Can't popd from ${S}/${x}"
        done
}

# @ECLASS-VARIABLE: QCONFIG_ADD
# @DESCRIPTION:
# List options that need to be added to QT_CONFIG in qconfig.pri
QCONFIG_ADD="${QCONFIG_ADD:-}"

# @ECLASS-VARIABLE: QCONFIG_REMOVE
# @DESCRIPTION:
# List options that need to be removed from QT_CONFIG in qconfig.pri
QCONFIG_REMOVE="${QCONFIG_REMOVE:-}"

# @ECLASS-VARIABLE: QCONFIG_DEFINE
# @DESCRIPTION:
# List variables that should be defined at the top of QtCore/qconfig.h
QCONFIG_DEFINE="${QCONFIG_DEFINE:-}"

install_qconfigs() {
        local x
        if [[ -n ${QCONFIG_ADD} || -n ${QCONFIG_REMOVE} ]]; then
                for x in QCONFIG_ADD QCONFIG_REMOVE; do
                        [[ -n ${!x} ]] && echo ${x}=${!x} >> "${T}"/${PN}-qconfig.pri
                done
                insinto ${QTDATADIR}/mkspecs/gentoo
                doins "${T}"/${PN}-qconfig.pri || die "installing ${PN}-qconfig.pri failed"
        fi

        if [[ -n ${QCONFIG_DEFINE} ]]; then
                for x in ${QCONFIG_DEFINE}; do
                        echo "#define ${x}" >> "${T}"/gentoo-${PN}-qconfig.h
                done
                insinto ${QTHEADERDIR}/Gentoo
                doins "${T}"/gentoo-${PN}-qconfig.h || die "installing ${PN}-qconfig.h failed"
        fi
}

generate_qconfigs() {
        if [[ -n ${QCONFIG_ADD} || -n ${QCONFIG_REMOVE} || -n ${QCONFIG_DEFINE} || ${CATEGORY}/${PN} == x11-libs/qt-core ]]; then
                local x qconfig_add qconfig_remove qconfig_new
                for x in "${ROOT}${QTDATADIR}"/mkspecs/gentoo/*-qconfig.pri; do
                        [[ -f ${x} ]] || continue
                        qconfig_add="${qconfig_add} $(sed -n 's/^QCONFIG_ADD=//p' "${x}")"
                        qconfig_remove="${qconfig_remove} $(sed -n 's/^QCONFIG_REMOVE=//p' "${x}")"
                done

                # these error checks do not use die because dying in pkg_post{inst,rm}
                # just makes things worse.
                if [[ -e "${ROOT}${QTDATADIR}"/mkspecs/gentoo/qconfig.pri ]]; then
                        # start with the qconfig.pri that qt-core installed
                        if ! cp "${ROOT}${QTDATADIR}"/mkspecs/gentoo/qconfig.pri \
                                "${ROOT}${QTDATADIR}"/mkspecs/qconfig.pri; then
                                eerror "cp qconfig failed."
                                return 1
                        fi

                        # generate list of QT_CONFIG entries from the existing list
                        # including qconfig_add and excluding qconfig_remove
                        for x in $(sed -n 's/^QT_CONFIG +=//p' \
                                "${ROOT}${QTDATADIR}"/mkspecs/qconfig.pri) ${qconfig_add}; do
                                        hasq ${x} ${qconfig_remove} || qconfig_new="${qconfig_new} ${x}"
                        done

                        # replace the existing QT_CONFIG list with qconfig_new
                        if ! sed -i -e "s/QT_CONFIG +=.*/QT_CONFIG += ${qconfig_new}/" \
                                "${ROOT}${QTDATADIR}"/mkspecs/qconfig.pri; then
                                eerror "Sed for QT_CONFIG failed"
                                return 1
                        fi

                        # create Gentoo/qconfig.h
                        if [[ ! -e ${ROOT}${QTHEADERDIR}/Gentoo ]]; then
                                if ! mkdir -p "${ROOT}${QTHEADERDIR}"/Gentoo; then
                                        eerror "mkdir ${QTHEADERDIR}/Gentoo failed"
                                        return 1
                                fi
                        fi
                        : > "${ROOT}${QTHEADERDIR}"/Gentoo/gentoo-qconfig.h
                        for x in "${ROOT}${QTHEADERDIR}"/Gentoo/gentoo-*-qconfig.h; do
                                [[ -f ${x} ]] || continue
                                cat "${x}" >> "${ROOT}${QTHEADERDIR}"/Gentoo/gentoo-qconfig.h
                        done
                else
                        rm -f "${ROOT}${QTDATADIR}"/mkspecs/qconfig.pri
                        rm -f "${ROOT}${QTHEADERDIR}"/Gentoo/gentoo-qconfig.h
                        rmdir "${ROOT}${QTDATADIR}"/mkspecs \
                                "${ROOT}${QTDATADIR}" \
                                "${ROOT}${QTHEADERDIR}"/Gentoo \
                                "${ROOT}${QTHEADERDIR}" 2>/dev/null
                fi
        fi
}

qt4-build_pkg_postrm() {
        generate_qconfigs
}

qt4-build_pkg_postinst() {
        generate_qconfigs
        echo
        ewarn "After a rebuild or upgrade of Qt, it can happen that Qt plugins (such as Qt"
        ewarn "and KDE styles and widgets) can no longer be loaded. In this situation you"
        ewarn "should recompile the packages providing these plugins. Also, make sure you"
        ewarn "compile the Qt packages, and the packages that depend on it, with the same"
        ewarn "GCC version and the same USE flag settings (especially the debug flag)."
        ewarn
        ewarn "Packages that typically need to be recompiled are kdelibs from KDE4, any"
        ewarn "additional KDE4/Qt4 styles, qscintilla and PyQt4. Before filing a bug report,"
        ewarn "make sure all your Qt4 packages are up-to-date and built with the same"
        ewarn "configuration."
        ewarn
        ewarn "For more information, see http://doc.trolltech.com/4.4/plugins-howto.html"
        echo
}

skip_qmake_build_patch() {
        # Don't need to build qmake, as it's already installed from qt-core
        sed -i -e "s:if true:if false:g" "${S}"/configure || die "Sed failed"
}

skip_project_generation_patch() {
        # Exit the script early by throwing in an exit before all of the .pro files are scanned
        sed -e "s:echo \"Finding:exit 0\n\necho \"Finding:g" \
                -i "${S}"/configure || die "Sed failed"
}

symlink_binaries_to_buildtree() {
        for bin in qmake moc uic rcc; do
                ln -s ${QTBINDIR}/${bin} "${S}"/bin/ || die "Symlinking ${bin} to ${S}/bin failed."
        done
}

fix_library_files() {
        for libfile in "${D}"/${QTLIBDIR}/{*.la,*.prl,pkgconfig/*.pc}; do
                if [[ -e ${libfile} ]]; then
                        sed -i -e "s:${S}/lib:${QTLIBDIR}:g" ${libfile} || die "Sed on ${libfile} failed."
                fi
        done

        # pkgconfig files refer to WORKDIR/bin as the moc and uic locations.  Fix:
        for libfile in "${D}"/${QTLIBDIR}/pkgconfig/*.pc; do
                if [[ -e ${libfile} ]]; then
                        sed -i -e "s:${S}/bin:${QTBINDIR}:g" ${libfile} || die "Sed failed"

        # Move .pc files into the pkgconfig directory

                dodir ${QTPCDIR}
                mv ${libfile} "${D}"/${QTPCDIR}/ \
                        || die "Moving ${libfile} to ${D}/${QTPCDIR}/ failed."
                fi
        done

        # Don't install an empty directory
        rmdir "${D}"/${QTLIBDIR}/pkgconfig
}

qt_use() {
        local flag="${1}"
        local feature="${1}"
        local enableval=

        [[ -n ${2} ]] && feature=${2}
        [[ -n ${3} ]] && enableval="-${3}"

        if use ${flag}; then
                echo "${enableval}-${feature}"
        else
                echo "-no-${feature}"
        fi
}

# @ECLASS-VARIABLE: QT4_BUILT_WITH_USE_CHECK
# @DESCRIPTION:
# The contents of $QT4_BUILT_WITH_USE_CHECK gets fed to built_with_use
# (eutils.eclass), line per line.
#
# Example:
# @CODE
# pkg_setup() {
#       use qt3support && QT4_BUILT_WITH_USE_CHECK="${QT4_BUILT_WITH_USE_CHECK}
#               ~x11-libs/qt-gui-${PV} qt3support"
#       qt4-build_check_use
# }
# @CODE

# Run built_with_use on each flag and print appropriate error messages if any
# flags are missing
_qt_built_with_use() {
        local missing opt pkg flag flags

        if [[ ${1} = "--missing" ]]; then
                missing="${1} ${2}" && shift 2
        fi
        if [[ ${1:0:1} = "-" ]]; then
                opt=${1} && shift
        fi

        pkg=${1} && shift

        for flag in "${@}"; do
                flags="${flags} ${flag}"
                if ! built_with_use ${missing} ${opt} ${pkg} ${flag}; then
                        flags="${flags}*"
                else
                        [[ ${opt} = "-o" ]] && return 0
                fi
        done
        if [[ "${flags# }" = "${@}" ]]; then
                return 0
        fi
        if [[ ${opt} = "-o" ]]; then
                eerror "This package requires '${pkg}' to be built with any of the following USE flags: '$*'."
        else
                eerror "This package requires '${pkg}' to be built with the following USE flags: '${flags# }'."
        fi
        return 1
}

# @FUNCTION: qt4-build_check_use
# @DESCRIPTION:
# Check if the listed packages in $QT4_BUILT_WITH_USE_CHECK are built with the
# USE flags listed.
#
# If any of the required USE flags are missing, an eerror will be printed for
# each package with missing USE flags.
qt4-build_check_use() {
        local line missing
        while read line; do
                [[ -z ${line} ]] && continue
                if ! _qt_built_with_use ${line}; then
                        missing=true
                fi
        done <<< "${QT4_BUILT_WITH_USE_CHECK}"
        if [[ -n ${missing} ]]; then
                echo
                eerror "Flags marked with an * are missing."
                die "Missing USE flags found"
        fi
}

qt_mkspecs_dir() {
        # Allows us to define which mkspecs dir we want to use.
        local spec

        case ${CHOST} in
                *-freebsd*|*-dragonfly*)
                        spec="freebsd" ;;
                *-openbsd*)
                        spec="openbsd" ;;
                *-netbsd*)
                        spec="netbsd" ;;
                *-darwin*)
                        spec="darwin" ;;
                *-linux-*|*-linux)
                        spec="linux" ;;
                *)
                        die "Unknown CHOST, no platform choosen."
        esac

        CXX=$(tc-getCXX)
        if [[ ${CXX/g++/} != ${CXX} ]]; then
                spec="${spec}-g++"
        elif [[ ${CXX/icpc/} != ${CXX} ]]; then
                spec="${spec}-icc"
        else
                die "Unknown compiler ${CXX}."
        fi

        echo "${spec}"
}

case ${EAPI:-0} in
        0|1) EXPORT_FUNCTIONS pkg_setup src_unpack src_compile src_install pkg_postrm pkg_postinst ;;
        2) EXPORT_FUNCTIONS pkg_setup src_unpack src_prepare src_configure src_compile src_install pkg_postrm pkg_postinst ;;
esac
1	yngwin	1.20	# Copyright 2007-2009 Gentoo Foundation
2	caleb	1.1	# Distributed under the terms of the GNU General Public License v2
3	hwoarang	1.22	# $Header: /var/cvsroot/gentoo-x86/eclass/qt4-build.eclass,v 1.21 2009/02/14 22:25:10 hwoarang Exp $
4	caleb	1.1
5			# @ECLASS: qt4-build.eclass
6			# @MAINTAINER:
7	yngwin	1.20	# Ben de Groot <yngwin@gentoo.org>
8			# Markos Chandras <hwoarang@gentoo.org>
9	caleb	1.1	# Caleb Tennis <caleb@gentoo.org>
10	ingmar	1.8	# @BLURB: Eclass for Qt4 split ebuilds.
11	caleb	1.1	# @DESCRIPTION:
12			# This eclass contains various functions that are used when building Qt4
13
14	yngwin	1.20	inherit eutils multilib toolchain-funcs flag-o-matic versionator
15	caleb	1.1
16	yngwin	1.20	IUSE="${IUSE} custom-cxxflags debug pch"
17	caleb	1.1
18	ingmar	1.7	case "${PV}" in
19	yngwin	1.20	4.?.?_rc*)
20	ingmar	1.11	SRCTYPE="${SRCTYPE:-opensource-src}"
21			MY_PV="${PV/_rc/-rc}"
22			;;
23	ingmar	1.7	*)
24			SRCTYPE="${SRCTYPE:-opensource-src}"
25			MY_PV="${PV}"
26			;;
27			esac
28	ingmar	1.11	MY_P=qt-x11-${SRCTYPE}-${MY_PV}
29			S=${WORKDIR}/${MY_P}
30	ingmar	1.7
31	yngwin	1.20	HOMEPAGE="http://www.qtsoftware.com/"
32	ingmar	1.11	SRC_URI="ftp://ftp.trolltech.com/qt/source/${MY_P}.tar.bz2"
33
34			case "${PV}" in
35	yngwin	1.20	4.4.?) SRC_URI="${SRC_URI} mirror://gentoo/${MY_P}-headers.tar.bz2" ;;
36			*) ;;
37	ingmar	1.11	esac
38	ingmar	1.7
39	caleb	1.1	qt4-build_pkg_setup() {
40	yngwin	1.20	# EAPI=2 ebuilds set use-deps, others need this:
41			if [[ $EAPI != 2 ]]; then
42			# Make sure debug setting corresponds with qt-core (bug 258512)
43			if [[ $PN != "qt-core" ]]; then
44			use debug && QT4_BUILT_WITH_USE_CHECK="${QT4_BUILT_WITH_USE_CHECK}
45			~x11-libs/qt-core-${PV} debug"
46			fi
47
48			# Check USE requirements
49			qt4-build_check_use
50			fi
51	ingmar	1.7
52	caleb	1.1	# Set up installation directories
53	caleb	1.5	QTBASEDIR=/usr/$(get_libdir)/qt4
54			QTPREFIXDIR=/usr
55			QTBINDIR=/usr/bin
56			QTLIBDIR=/usr/$(get_libdir)/qt4
57			QTPCDIR=/usr/$(get_libdir)/pkgconfig
58			QTDATADIR=/usr/share/qt4
59	caleb	1.6	QTDOCDIR=/usr/share/doc/qt-${PV}
60	caleb	1.5	QTHEADERDIR=/usr/include/qt4
61			QTPLUGINDIR=${QTLIBDIR}/plugins
62			QTSYSCONFDIR=/etc/qt4
63			QTTRANSDIR=${QTDATADIR}/translations
64			QTEXAMPLESDIR=${QTDATADIR}/examples
65			QTDEMOSDIR=${QTDATADIR}/demos
66	caleb	1.1
67	caleb	1.5	PLATFORM=$(qt_mkspecs_dir)
68	caleb	1.1
69			PATH="${S}/bin:${PATH}"
70			LD_LIBRARY_PATH="${S}/lib:${LD_LIBRARY_PATH}"
71	yngwin	1.20
72			if ! version_is_at_least 4.1 $(gcc-version) ; then
73			ewarn "Using a GCC version lower than 4.1 is not supported!"
74			echo
75			ebeep 5
76			fi
77	hwoarang	1.21
78			if use custom-cxxflags; then
79			echo
80			ewarn "You have set USE=custom-cxxflags, which means Qt will be built with the"
81			ewarn "CXXFLAGS you have set in /etc/make.conf. This is not supported, and we"
82			ewarn "recommend to unset this useflag. But you are free to experiment with it."
83			ewarn "Just do not start crying if it breaks your system, or eats your kitten"
84			ewarn "for breakfast. ;-) "
85			echo
86			fi
87
88	caleb	1.1	}
89
90	yngwin	1.20	qt4-build_src_unpack() {
91	ingmar	1.11	local target targets
92	yngwin	1.15	for target in configure LICENSE.{GPL2,GPL3} projects.pro \
93	ingmar	1.11	src/{qbase,qt_targets,qt_install}.pri bin config.tests mkspecs qmake \
94	ingmar	1.13	${QT4_EXTRACT_DIRECTORIES}; do
95	ingmar	1.11	targets="${targets} ${MY_P}/${target}"
96			done
97
98			echo tar xjpf "${DISTDIR}"/${MY_P}.tar.bz2 ${targets}
99			tar xjpf "${DISTDIR}"/${MY_P}.tar.bz2 ${targets}
100
101			case "${PV}" in
102	yngwin	1.20	4.4.?)
103	ingmar	1.11	echo tar xjpf "${DISTDIR}"/${MY_P}-headers.tar.bz2
104			tar xjpf "${DISTDIR}"/${MY_P}-headers.tar.bz2
105			;;
106			esac
107	yngwin	1.20
108			# Be backwards compatible for now
109			if [[ $EAPI != 2 ]]; then
110			qt4-build_src_prepare
111			fi
112	ingmar	1.11	}
113
114	yngwin	1.20	qt4-build_src_prepare() {
115			cd "${S}"
116
117	ingmar	1.7	if [[ ${PN} != qt-core ]]; then
118			skip_qmake_build_patch
119			skip_project_generation_patch
120			symlink_binaries_to_buildtree
121			fi
122	hwoarang	1.21
123			# Bug 172219
124	hwoarang	1.22	if ! use custom-cxxflags;then
125	hwoarang	1.21	# Don't let the user go too overboard with flags.
126			strip-flags
127			replace-flags -O3 -O2
128			fi
129	ingmar	1.7
130	gengor	1.18	# Bug 253127
131	hwoarang	1.21	# Unsupported old gcc versions - hardened needs this :(
132	gengor	1.18	if [[ $(gcc-major-version) -lt "4" ]] ; then
133	hwoarang	1.21	ewarn "Appending -fno-stack-protector to CXXFLAGS"
134			append-cxxflags -fno-stack-protector
135			fi
136
137			# Bug 178652
138			if [[ "$(gcc-major-version)" == "3" ]] && use amd64; then
139			ewarn "Appending -fno-gcse to CFLAGS/CXXFLAGS"
140			append-flags -fno-gcse
141	gengor	1.18	fi
142
143	hwoarang	1.21
144	ingmar	1.7	sed -e "s:QMAKE_CFLAGS_RELEASE.=.:QMAKE_CFLAGS_RELEASE=${CFLAGS}:" \
145			-e "s:QMAKE_CXXFLAGS_RELEASE.=.:QMAKE_CXXFLAGS_RELEASE=${CXXFLAGS}:" \
146			-e "s:QMAKE_LFLAGS_RELEASE.=.:QMAKE_LFLAGS_RELEASE=${LDFLAGS}:" \
147			-e "s:X11R6/::" \
148			-i "${S}"/mkspecs/$(qt_mkspecs_dir)/qmake.conf \|\| die "sed ${S}/mkspecs/$(qt_mkspecs_dir)/qmake.conf failed"
149
150			sed -e "s:QMAKE_CFLAGS_RELEASE.=.:QMAKE_CFLAGS_RELEASE=${CFLAGS}:" \
151			-e "s:QMAKE_CXXFLAGS_RELEASE.=.:QMAKE_CXXFLAGS_RELEASE=${CXXFLAGS}:" \
152			-e "s:QMAKE_LFLAGS_RELEASE.=.:QMAKE_LFLAGS_RELEASE=${LDFLAGS}:" \
153			-i "${S}"/mkspecs/common/g++.conf \|\| die "sed ${S}/mkspecs/common/g++.conf failed"
154	hwoarang	1.21
155	ingmar	1.7	}
156
157	yngwin	1.20	qt4-build_src_configure() {
158	ingmar	1.10
159	ingmar	1.7	myconf="$(standard_configure_options) ${myconf}"
160
161			echo ./configure ${myconf}
162			./configure ${myconf} \|\| die "./configure failed"
163	yngwin	1.20	}
164	ingmar	1.7
165	yngwin	1.20	qt4-build_src_compile() {
166			# Be backwards compatible for now
167			if [[ $EAPI != 2 ]]; then
168			qt4-build_src_configure
169			fi
170
171			build_directories "${QT4_TARGET_DIRECTORIES}"
172	caleb	1.1	}
173
174	caleb	1.4	qt4-build_src_install() {
175			install_directories "${QT4_TARGET_DIRECTORIES}"
176	ingmar	1.7	install_qconfigs
177	caleb	1.4	fix_library_files
178			}
179
180	caleb	1.1	standard_configure_options() {
181			local myconf=""
182
183	ingmar	1.7	[[ $(get_libdir) != "lib" ]] && myconf="${myconf} -L/usr/$(get_libdir)"
184	caleb	1.1
185			# Disable visibility explicitly if gcc version isn't 4
186	ingmar	1.7	if [[ "$(gcc-major-version)" -lt "4" ]]; then
187	caleb	1.1	myconf="${myconf} -no-reduce-exports"
188			fi
189
190	ingmar	1.12	# precompiled headers doesn't work on hardened, where the flag is masked.
191			if use pch; then
192			myconf="${myconf} -pch"
193			else
194			myconf="${myconf} -no-pch"
195			fi
196
197	ingmar	1.7	if use debug; then
198			myconf="${myconf} -debug -no-separate-debug-info"
199			else
200			myconf="${myconf} -release -no-separate-debug-info"
201			fi
202	caleb	1.1
203	yngwin	1.20	# ARCH is set on Gentoo. Qt now falls back to generic on an unsupported
204	ingmar	1.11	# ${ARCH}. Therefore we convert it to supported values.
205			case "${ARCH}" in
206			amd64) myconf="${myconf} -arch x86_64" ;;
207			ppc\|ppc64) myconf="${myconf} -arch powerpc" ;;
208	ingmar	1.14	x86\|x86-*) myconf="${myconf} -arch i386" ;;
209	ingmar	1.11	alpha\|arm\|ia64\|mips\|s390\|sparc) myconf="${myconf} -arch ${ARCH}" ;;
210			hppa\|sh) myconf="${myconf} -arch generic" ;;
211			*) die "${ARCH} is unsupported by this eclass. Please file a bug." ;;
212			esac
213
214	ingmar	1.7	myconf="${myconf} -stl -verbose -largefile -confirm-license -no-rpath
215			-prefix ${QTPREFIXDIR} -bindir ${QTBINDIR} -libdir ${QTLIBDIR}
216			-datadir ${QTDATADIR} -docdir ${QTDOCDIR} -headerdir ${QTHEADERDIR}
217			-plugindir ${QTPLUGINDIR} -sysconfdir ${QTSYSCONFDIR}
218			-translationdir ${QTTRANSDIR} -examplesdir ${QTEXAMPLESDIR}
219	yngwin	1.20	-demosdir ${QTDEMOSDIR} -silent -fast
220			$([[ ${PN} == qt-xmlpatterns ]] \|\| echo -no-exceptions)
221			$(use x86-fbsd \|\| echo -reduce-relocations)
222	ingmar	1.7	-nomake examples -nomake demos"
223	caleb	1.1
224			echo "${myconf}"
225			}
226
227			build_directories() {
228			local dirs="$@"
229			for x in ${dirs}; do
230			cd "${S}"/${x}
231	ingmar	1.7	"${S}"/bin/qmake "LIBS+=-L${QTLIBDIR}" "CONFIG+=nostrip" \|\| die "qmake failed"
232			emake \|\| die "emake failed"
233	caleb	1.1	done
234			}
235
236			install_directories() {
237			local dirs="$@"
238			for x in ${dirs}; do
239	ingmar	1.7	pushd "${S}"/${x} >/dev/null \|\| die "Can't pushd ${S}/${x}"
240			emake INSTALL_ROOT="${D}" install \|\| die "emake install failed"
241			popd >/dev/null \|\| die "Can't popd from ${S}/${x}"
242	caleb	1.1	done
243			}
244
245	ingmar	1.7	# @ECLASS-VARIABLE: QCONFIG_ADD
246			# @DESCRIPTION:
247			# List options that need to be added to QT_CONFIG in qconfig.pri
248			QCONFIG_ADD="${QCONFIG_ADD:-}"
249
250			# @ECLASS-VARIABLE: QCONFIG_REMOVE
251			# @DESCRIPTION:
252			# List options that need to be removed from QT_CONFIG in qconfig.pri
253			QCONFIG_REMOVE="${QCONFIG_REMOVE:-}"
254
255			# @ECLASS-VARIABLE: QCONFIG_DEFINE
256			# @DESCRIPTION:
257			# List variables that should be defined at the top of QtCore/qconfig.h
258			QCONFIG_DEFINE="${QCONFIG_DEFINE:-}"
259
260			install_qconfigs() {
261	zlin	1.9	local x
262			if [[ -n ${QCONFIG_ADD} \|\| -n ${QCONFIG_REMOVE} ]]; then
263	ingmar	1.7	for x in QCONFIG_ADD QCONFIG_REMOVE; do
264			[[ -n ${!x} ]] && echo ${x}=${!x} >> "${T}"/${PN}-qconfig.pri
265			done
266			insinto ${QTDATADIR}/mkspecs/gentoo
267			doins "${T}"/${PN}-qconfig.pri \|\| die "installing ${PN}-qconfig.pri failed"
268	zlin	1.9	fi
269	ingmar	1.7
270	zlin	1.9	if [[ -n ${QCONFIG_DEFINE} ]]; then
271	ingmar	1.7	for x in ${QCONFIG_DEFINE}; do
272			echo "#define ${x}" >> "${T}"/gentoo-${PN}-qconfig.h
273			done
274			insinto ${QTHEADERDIR}/Gentoo
275			doins "${T}"/gentoo-${PN}-qconfig.h \|\| die "installing ${PN}-qconfig.h failed"
276			fi
277			}
278
279			generate_qconfigs() {
280			if [[ -n ${QCONFIG_ADD} \|\| -n ${QCONFIG_REMOVE} \|\| -n ${QCONFIG_DEFINE} \|\| ${CATEGORY}/${PN} == x11-libs/qt-core ]]; then
281			local x qconfig_add qconfig_remove qconfig_new
282			for x in "${ROOT}${QTDATADIR}"/mkspecs/gentoo/*-qconfig.pri; do
283			[[ -f ${x} ]] \|\| continue
284			qconfig_add="${qconfig_add} $(sed -n 's/^QCONFIG_ADD=//p' "${x}")"
285			qconfig_remove="${qconfig_remove} $(sed -n 's/^QCONFIG_REMOVE=//p' "${x}")"
286			done
287
288			# these error checks do not use die because dying in pkg_post{inst,rm}
289			# just makes things worse.
290			if [[ -e "${ROOT}${QTDATADIR}"/mkspecs/gentoo/qconfig.pri ]]; then
291			# start with the qconfig.pri that qt-core installed
292			if ! cp "${ROOT}${QTDATADIR}"/mkspecs/gentoo/qconfig.pri \
293			"${ROOT}${QTDATADIR}"/mkspecs/qconfig.pri; then
294			eerror "cp qconfig failed."
295			return 1
296			fi
297
298			# generate list of QT_CONFIG entries from the existing list
299			# including qconfig_add and excluding qconfig_remove
300			for x in $(sed -n 's/^QT_CONFIG +=//p' \
301			"${ROOT}${QTDATADIR}"/mkspecs/qconfig.pri) ${qconfig_add}; do
302			hasq ${x} ${qconfig_remove} \|\| qconfig_new="${qconfig_new} ${x}"
303			done
304
305			# replace the existing QT_CONFIG list with qconfig_new
306			if ! sed -i -e "s/QT_CONFIG +=.*/QT_CONFIG += ${qconfig_new}/" \
307			"${ROOT}${QTDATADIR}"/mkspecs/qconfig.pri; then
308			eerror "Sed for QT_CONFIG failed"
309			return 1
310			fi
311
312			# create Gentoo/qconfig.h
313			if [[ ! -e ${ROOT}${QTHEADERDIR}/Gentoo ]]; then
314			if ! mkdir -p "${ROOT}${QTHEADERDIR}"/Gentoo; then
315			eerror "mkdir ${QTHEADERDIR}/Gentoo failed"
316			return 1
317			fi
318			fi
319			: > "${ROOT}${QTHEADERDIR}"/Gentoo/gentoo-qconfig.h
320			for x in "${ROOT}${QTHEADERDIR}"/Gentoo/gentoo-*-qconfig.h; do
321			[[ -f ${x} ]] \|\| continue
322			cat "${x}" >> "${ROOT}${QTHEADERDIR}"/Gentoo/gentoo-qconfig.h
323			done
324			else
325			rm -f "${ROOT}${QTDATADIR}"/mkspecs/qconfig.pri
326			rm -f "${ROOT}${QTHEADERDIR}"/Gentoo/gentoo-qconfig.h
327			rmdir "${ROOT}${QTDATADIR}"/mkspecs \
328			"${ROOT}${QTDATADIR}" \
329			"${ROOT}${QTHEADERDIR}"/Gentoo \
330			"${ROOT}${QTHEADERDIR}" 2>/dev/null
331			fi
332			fi
333			}
334
335			qt4-build_pkg_postrm() {
336			generate_qconfigs
337	caleb	1.1	}
338
339	ingmar	1.7	qt4-build_pkg_postinst() {
340			generate_qconfigs
341	yngwin	1.17	echo
342			ewarn "After a rebuild or upgrade of Qt, it can happen that Qt plugins (such as Qt"
343			ewarn "and KDE styles and widgets) can no longer be loaded. In this situation you"
344			ewarn "should recompile the packages providing these plugins. Also, make sure you"
345			ewarn "compile the Qt packages, and the packages that depend on it, with the same"
346			ewarn "GCC version and the same USE flag settings (especially the debug flag)."
347			ewarn
348			ewarn "Packages that typically need to be recompiled are kdelibs from KDE4, any"
349			ewarn "additional KDE4/Qt4 styles, qscintilla and PyQt4. Before filing a bug report,"
350			ewarn "make sure all your Qt4 packages are up-to-date and built with the same"
351			ewarn "configuration."
352			ewarn
353			ewarn "For more information, see http://doc.trolltech.com/4.4/plugins-howto.html"
354			echo
355	caleb	1.1	}
356
357			skip_qmake_build_patch() {
358	ingmar	1.7	# Don't need to build qmake, as it's already installed from qt-core
359			sed -i -e "s:if true:if false:g" "${S}"/configure \|\| die "Sed failed"
360	caleb	1.1	}
361
362			skip_project_generation_patch() {
363			# Exit the script early by throwing in an exit before all of the .pro files are scanned
364	ingmar	1.7	sed -e "s:echo \"Finding:exit 0\n\necho \"Finding:g" \
365			-i "${S}"/configure \|\| die "Sed failed"
366	caleb	1.1	}
367
368	ingmar	1.7	symlink_binaries_to_buildtree() {
369			for bin in qmake moc uic rcc; do
370			ln -s ${QTBINDIR}/${bin} "${S}"/bin/ \|\| die "Symlinking ${bin} to ${S}/bin failed."
371			done
372	caleb	1.1	}
373
374			fix_library_files() {
375	ingmar	1.7	for libfile in "${D}"/${QTLIBDIR}/{.la,.prl,pkgconfig/*.pc}; do
376			if [[ -e ${libfile} ]]; then
377			sed -i -e "s:${S}/lib:${QTLIBDIR}:g" ${libfile} \|\| die "Sed on ${libfile} failed."
378			fi
379			done
380	caleb	1.1
381			# pkgconfig files refer to WORKDIR/bin as the moc and uic locations. Fix:
382	ingmar	1.7	for libfile in "${D}"/${QTLIBDIR}/pkgconfig/*.pc; do
383			if [[ -e ${libfile} ]]; then
384			sed -i -e "s:${S}/bin:${QTBINDIR}:g" ${libfile} \|\| die "Sed failed"
385	caleb	1.1
386			# Move .pc files into the pkgconfig directory
387	ingmar	1.7
388			dodir ${QTPCDIR}
389			mv ${libfile} "${D}"/${QTPCDIR}/ \
390			\|\| die "Moving ${libfile} to ${D}/${QTPCDIR}/ failed."
391			fi
392			done
393
394			# Don't install an empty directory
395			rmdir "${D}"/${QTLIBDIR}/pkgconfig
396	caleb	1.1	}
397
398			qt_use() {
399	ingmar	1.7	local flag="${1}"
400			local feature="${1}"
401	caleb	1.5	local enableval=
402	caleb	1.1
403	ingmar	1.7	[[ -n ${2} ]] && feature=${2}
404			[[ -n ${3} ]] && enableval="-${3}"
405
406			if use ${flag}; then
407			echo "${enableval}-${feature}"
408			else
409			echo "-no-${feature}"
410			fi
411			}
412
413			# @ECLASS-VARIABLE: QT4_BUILT_WITH_USE_CHECK
414			# @DESCRIPTION:
415			# The contents of $QT4_BUILT_WITH_USE_CHECK gets fed to built_with_use
416			# (eutils.eclass), line per line.
417			#
418			# Example:
419			# @CODE
420			# pkg_setup() {
421			# use qt3support && QT4_BUILT_WITH_USE_CHECK="${QT4_BUILT_WITH_USE_CHECK}
422			# ~x11-libs/qt-gui-${PV} qt3support"
423			# qt4-build_check_use
424			# }
425			# @CODE
426
427			# Run built_with_use on each flag and print appropriate error messages if any
428			# flags are missing
429			_qt_built_with_use() {
430			local missing opt pkg flag flags
431	caleb	1.1
432	ingmar	1.7	if [[ ${1} = "--missing" ]]; then
433			missing="${1} ${2}" && shift 2
434			fi
435			if [[ ${1:0:1} = "-" ]]; then
436			opt=${1} && shift
437			fi
438
439			pkg=${1} && shift
440
441			for flag in "${@}"; do
442			flags="${flags} ${flag}"
443			if ! built_with_use ${missing} ${opt} ${pkg} ${flag}; then
444			flags="${flags}*"
445			else
446			[[ ${opt} = "-o" ]] && return 0
447			fi
448			done
449			if [[ "${flags# }" = "${@}" ]]; then
450			return 0
451			fi
452			if [[ ${opt} = "-o" ]]; then
453			eerror "This package requires '${pkg}' to be built with any of the following USE flags: '$*'."
454			else
455			eerror "This package requires '${pkg}' to be built with the following USE flags: '${flags# }'."
456			fi
457			return 1
458			}
459
460			# @FUNCTION: qt4-build_check_use
461			# @DESCRIPTION:
462			# Check if the listed packages in $QT4_BUILT_WITH_USE_CHECK are built with the
463			# USE flags listed.
464			#
465			# If any of the required USE flags are missing, an eerror will be printed for
466			# each package with missing USE flags.
467			qt4-build_check_use() {
468			local line missing
469			while read line; do
470			[[ -z ${line} ]] && continue
471			if ! _qt_built_with_use ${line}; then
472			missing=true
473			fi
474			done <<< "${QT4_BUILT_WITH_USE_CHECK}"
475			if [[ -n ${missing} ]]; then
476			echo
477			eerror "Flags marked with an * are missing."
478			die "Missing USE flags found"
479			fi
480	caleb	1.1	}
481
482			qt_mkspecs_dir() {
483	caleb	1.5	# Allows us to define which mkspecs dir we want to use.
484			local spec
485	caleb	1.1
486	caleb	1.5	case ${CHOST} in
487			-freebsd\|-dragonfly)
488			spec="freebsd" ;;
489			-openbsd)
490			spec="openbsd" ;;
491			-netbsd)
492			spec="netbsd" ;;
493	ingmar	1.7	-darwin)
494	caleb	1.5	spec="darwin" ;;
495			-linux-\|*-linux)
496			spec="linux" ;;
497			*)
498	ingmar	1.7	die "Unknown CHOST, no platform choosen."
499	caleb	1.5	esac
500
501			CXX=$(tc-getCXX)
502			if [[ ${CXX/g++/} != ${CXX} ]]; then
503			spec="${spec}-g++"
504			elif [[ ${CXX/icpc/} != ${CXX} ]]; then
505			spec="${spec}-icc"
506			else
507			die "Unknown compiler ${CXX}."
508			fi
509	caleb	1.1
510	caleb	1.5	echo "${spec}"
511	caleb	1.1	}
512
513	yngwin	1.20	case ${EAPI:-0} in
514			0\|1) EXPORT_FUNCTIONS pkg_setup src_unpack src_compile src_install pkg_postrm pkg_postinst ;;
515			2) EXPORT_FUNCTIONS pkg_setup src_unpack src_prepare src_configure src_compile src_install pkg_postrm pkg_postinst ;;
516			esac