gentoo-x86/eclass/libtool.eclass

# Copyright 1999-2007 Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2
# $Header: /var/cvsroot/gentoo-x86/eclass/libtool.eclass,v 1.85 2010/03/12 08:17:40 haubi Exp $
#
# Maintainer: base-system@gentoo.org
#
# This eclass patches ltmain.sh distributed with libtoolized packages with the
# relink and portage patch among others
#
# Note, this eclass does not require libtool as it only applies patches to
# generated libtool files.  We do not run the libtoolize program because that
# requires a regeneration of the main autotool files in order to work properly.

DESCRIPTION="Based on the ${ECLASS} eclass"

ELIBTOOL_VERSION="2.0.2"

inherit toolchain-funcs

ELT_PATCH_DIR="${ECLASSDIR}/ELT-patches"
ELT_APPLIED_PATCHES=
ELT_LTMAIN_SH=

#
# Returns all the directories containing ltmain.sh
#
ELT_find_ltmain_sh() {
        local x=
        local dirlist=

        for x in $(find "${S}" -name 'ltmain.sh') ; do
                dirlist="${dirlist} ${x%/*}"
        done

        echo "${dirlist}"
}

#
# See if we can apply $2 on $1, and if so, do it
#
ELT_try_and_apply_patch() {
        local ret=0
        local file=$1
        local patch=$2

        # We only support patchlevel of 0 - why worry if its static patches?
        if patch -p0 --dry-run "${file}" "${patch}" &> "${T}/elibtool.log" ; then
                einfo "  Applying $(basename "$(dirname "${patch}")")-${patch##*/}.patch ..."
                patch -p0 -g0 --no-backup-if-mismatch "${file}" "${patch}" \
                        &> "${T}/elibtool.log"
                ret=$?
                export ELT_APPLIED_PATCHES="${ELT_APPLIED_PATCHES} ${patch##*/}"
        else
                ret=1
        fi

        return "${ret}"
}

#
# Get string version of ltmain.sh or ltconfig (passed as $1)
#
ELT_libtool_version() {
        local ltmain_sh=$1
        local version=

        version=$(eval $(grep -e '^[[:space:]]*VERSION=' "${ltmain_sh}"); \
                         echo "${VERSION}")
        [[ -z ${version} ]] && version="0"

        echo "${version}"
}

#
# Run through the patches in $2 and see if any
# apply to $1 ...
#
ELT_walk_patches() {
        local patch
        local ret=1
        local file=$1
        local patch_set=$2
        local patch_dir="${ELT_PATCH_DIR}/${patch_set}"
        local rem_int_dep=$3

        [[ -z ${patch_set} ]] && return 1
        [[ ! -d ${patch_dir} ]] && return 1

        pushd "${ELT_PATCH_DIR}" >/dev/null

        # Go through the patches in reverse order (newer version to older)
        for patch in $(find "${patch_set}" -maxdepth 1 -type f | LC_ALL=C sort -r) ; do
                # For --remove-internal-dep ...
                if [[ -n ${rem_int_dep} ]] ; then
                        # For replace @REM_INT_DEP@ with what was passed
                        # to --remove-internal-dep
                        local tmp="${T}/$$.rem_int_deps.patch"
                        sed -e "s|@REM_INT_DEP@|${rem_int_dep}|g" "${patch}" > "${tmp}"
                        patch=${tmp}
                fi

                if ELT_try_and_apply_patch "${file}" "${patch}" ; then
                        # Break to unwind w/popd rather than return directly
                        ret=0
                        break
                fi
        done

        popd "${patch_dir}" >/dev/null
        return ${ret}
}

elibtoolize() {
        local x=
        local y=
        local do_portage="no"
        local do_reversedeps="no"
        local do_only_patches="no"
        local do_uclibc="yes"
        local deptoremove=
        local my_dirlist=
        local elt_patches="install-sh ltmain portage relink max_cmd_len sed test tmp cross as-needed"
        local start_dir=${PWD}

        my_dirlist=$(ELT_find_ltmain_sh)

        for x in "$@" ; do
                case "${x}" in
                        "--portage")
                                # Only apply portage patch, and don't
                                # 'libtoolize --copy --force' if all patches fail.
                                do_portage="yes"
                                ;;
                        "--reverse-deps")
                                # Apply the reverse-deps patch
                                # http://bugzilla.gnome.org/show_bug.cgi?id=75635
                                do_reversedeps="yes"
                                elt_patches="${elt_patches} fix-relink"
                                ;;
                        "--patch-only")
                                # Do not run libtoolize if none of the patches apply ..
                                do_only_patches="yes"
                                ;;
                        "^--remove-internal-dep="*)
                                # We will replace @REM_INT_DEP@ with what is needed
                                # in ELT_walk_patches() ...
                                deptoremove=$(echo "${x}" | sed -e 's|--remove-internal-dep=||')

                                # Add the patch for this ...
                                [[ -n ${deptoremove} ]] && elt_patches="${elt_patches} rem-int-dep"
                                ;;
                        "--shallow")
                                # Only patch the ltmain.sh in ${S}
                                if [[ -f ${S}/ltmain.sh ]] ; then
                                        my_dirlist=${S}
                                else
                                        my_dirlist=
                                fi
                                ;;
                        "--no-uclibc")
                                do_uclibc="no"
                                ;;
                        *)
                                eerror "Invalid elibtoolize option: ${x}"
                                die "elibtoolize called with ${x} ??"
                esac
        done

        [[ ${do_uclibc} == "yes" ]] && \
                elt_patches="${elt_patches} uclibc-conf uclibc-ltconf"

        case "${CHOST}" in
                *-aix*)
                        elt_patches="${elt_patches} hardcode aixrtl"
                ;;
                *-darwin*)
                        elt_patches="${elt_patches} darwin-ltconf darwin-ltmain darwin-conf"
                ;;
                *-freebsd*)
                        elt_patches="${elt_patches} fbsd-conf fbsd-ltconf"
                ;;
                *-hpux*)
                        elt_patches="${elt_patches} hpux-conf deplibs hc-flag-ld hardcode hardcode-relink relink-prog no-lc"
                ;;
                *-irix*)
                        elt_patches="${elt_patches} irix-ltmain"
                ;;
                *-mint*)
                        elt_patches="${elt_patches} mint-conf"
                ;;
        esac

        for x in ${my_dirlist} ; do
                local tmp=$(echo "${x}" | sed -e "s|${WORKDIR}||")
                export ELT_APPLIED_PATCHES=
                export ELT_LTMAIN_SH="${x}/ltmain.sh"

                [[ -f ${x}/.elibtoolized ]] && continue

                cd ${x}
                einfo "Running elibtoolize in: $(echo "/${tmp}" | sed -e 's|//|/|g; s|^/||')"

                for y in ${elt_patches} ; do
                        local ret=0

                        case "${y}" in
                                "portage")
                                        # Stupid test to see if its already applied ...
                                        if [[ -z $(grep 'We do not want portage' "${x}/ltmain.sh") ]] ; then
                                                ELT_walk_patches "${x}/ltmain.sh" "${y}"
                                                ret=$?
                                        fi
                                        ;;
                                "rem-int-dep")
                                        ELT_walk_patches "${x}/ltmain.sh" "${y}" "${deptoremove}"
                                        ret=$?
                                        ;;
                                "fix-relink")
                                        # Do not apply if we do not have the relink patch applied ...
                                        if [[ -n $(grep 'inst_prefix_dir' "${x}/ltmain.sh") ]] ; then
                                                ELT_walk_patches "${x}/ltmain.sh" "${y}"
                                                ret=$?
                                        fi
                                        ;;
                                "max_cmd_len")
                                        # Do not apply if $max_cmd_len is not used ...
                                        if [[ -n $(grep 'max_cmd_len' "${x}/ltmain.sh") ]] ; then
                                                ELT_walk_patches "${x}/ltmain.sh" "${y}"
                                                ret=$?
                                        fi
                                        ;;
                                "as-needed")
                                        ELT_walk_patches "${x}/ltmain.sh" "${y}"
                                        ret=$?
                                        ;;
                                "uclibc-conf")
                                        if [[ -e ${x}/configure && \
                                              -n $(grep 'Transform linux' "${x}/configure") ]] ; then
                                                ELT_walk_patches "${x}/configure" "${y}"
                                                ret=$?
                                        # ltmain.sh and co might be in a subdirectory ...
                                        elif [[ ! -e ${x}/configure && -e ${x}/../configure && \
                                                -n $(grep 'Transform linux' "${x}/../configure") ]] ; then
                                                ELT_walk_patches "${x}/../configure" "${y}"
                                                ret=$?
                                        fi
                                        ;;
                                "uclibc-ltconf")
                                        # Newer libtoolize clears ltconfig, as not used anymore
                                        if [[ -s ${x}/ltconfig ]] ; then
                                                ELT_walk_patches "${x}/ltconfig" "${y}"
                                                ret=$?
                                        fi
                                        ;;
                                "fbsd-conf")
                                        if [[ -e ${x}/configure && \
                                              -n $(grep 'version_type=freebsd-' "${x}/configure") ]] ; then
                                                ELT_walk_patches "${x}/configure" "${y}"
                                                ret=$?
                                        # ltmain.sh and co might be in a subdirectory ...
                                        elif [[ ! -e ${x}/configure && -e ${x}/../configure && \
                                                -n $(grep 'version_type=freebsd-' "${x}/../configure") ]] ; then
                                                ELT_walk_patches "${x}/../configure" "${y}"
                                                ret=$?
                                        fi
                                        ;;
                                "fbsd-ltconf")
                                        if [[ -s ${x}/ltconfig ]] ; then
                                                ELT_walk_patches "${x}/ltconfig" "${y}"
                                                ret=$?
                                        fi
                                        ;;
                                "darwin-conf")
                                        if [[ -e ${x}/configure && \
                                              -n $(grep '&& echo \.so ||' "${x}/configure") ]] ; then
                                                ELT_walk_patches "${x}/configure" "${y}"
                                                ret=$?
                                        # ltmain.sh and co might be in a subdirectory ...
                                        elif [[ ! -e ${x}/configure && -e ${x}/../configure && \
                                                -n $(grep '&& echo \.so ||' "${x}/../configure") ]] ; then
                                                ELT_walk_patches "${x}/../configure" "${y}"
                                                ret=$?
                                        fi
                                        ;;
                                "darwin-ltconf")
                                        # Newer libtoolize clears ltconfig, as not used anymore
                                        if [[ -s ${x}/ltconfig ]] ; then
                                                ELT_walk_patches "${x}/ltconfig" "${y}"
                                                ret=$?
                                        fi
                                        ;;
                                "darwin-ltmain")
                                        # special case to avoid false positives (failing to apply
                                        # ltmain.sh path message), newer libtools have this patch
                                        # built in, so not much to patch around then
                                        if [[ -e ${x}/ltmain.sh && \
                                              -z $(grep 'verstring="-compatibility_version' "${x}/ltmain.sh") ]] ; then
                                                ELT_walk_patches "${x}/ltmain.sh" "${y}"
                                                ret=$?
                                        fi
                                        ;;
                                "aixrtl" | "hpux-conf")
                                        ret=1
                                        local subret=0
                                        # apply multiple patches as often as they match
                                        while [[ $subret -eq 0 ]]; do
                                                subret=1
                                                if [[ -e ${x}/configure ]]; then
                                                        ELT_walk_patches "${x}/configure" "${y}"
                                                        subret=$?
                                                # ltmain.sh and co might be in a subdirectory ...
                                                elif [[ ! -e ${x}/configure && -e ${x}/../configure ]] ; then
                                                        ELT_walk_patches "${x}/../configure" "${y}"
                                                        subret=$?
                                                fi
                                                if [[ $subret -eq 0 ]]; then
                                                        # have at least one patch succeeded.
                                                        ret=0
                                                fi
                                        done
                                        ;;
                                "mint-conf")
                                        ret=1
                                        local subret=1
                                        if [[ -e ${x}/configure ]]; then
                                                ELT_walk_patches "${x}/configure" "${y}"
                                                subret=$?
                                        # ltmain.sh and co might be in a subdirectory ...
                                        elif [[ ! -e ${x}/configure && -e ${x}/../configure ]] ; then
                                                ELT_walk_patches "${x}/../configure" "${y}"
                                                subret=$?
                                        fi
                                        if [[ $subret -eq 0 ]]; then
                                                # have at least one patch succeeded.
                                                ret=0
                                        fi
                                        ;;
                                "install-sh")
                                        ELT_walk_patches "${x}/install-sh" "${y}"
                                        ret=$?
                                        ;;
                                "cross")
                                        if tc-is-cross-compiler ; then
                                                ELT_walk_patches "${x}/ltmain.sh" "${y}"
                                                ret=$?
                                        fi
                                        ;;
                                *)
                                        ELT_walk_patches "${x}/ltmain.sh" "${y}"
                                        ret=$?
                                        ;;
                        esac

                        if [[ ${ret} -ne 0 ]] ; then
                                case ${y} in
                                        "relink")
                                                local version=$(ELT_libtool_version "${x}/ltmain.sh")
                                                # Critical patch, but could be applied ...
                                                # FIXME:  Still need a patch for ltmain.sh > 1.4.0
                                                if [[ -z $(grep 'inst_prefix_dir' "${x}/ltmain.sh") && \
                                                      $(VER_to_int "${version}") -ge $(VER_to_int "1.4.0") ]] ; then
                                                        ewarn "  Could not apply relink.patch!"
                                                fi
                                                ;;
                                        "portage")
                                                # Critical patch - for this one we abort, as it can really
                                                # cause breakage without it applied!
                                                if [[ ${do_portage} == "yes" ]] ; then
                                                        # Stupid test to see if its already applied ...
                                                        if [[ -z $(grep 'We do not want portage' "${x}/ltmain.sh") ]] ; then
                                                                echo
                                                                eerror "Portage patch requested, but failed to apply!"
                                                                eerror "Please bug azarah or vapier to add proper patch."
                                                                die "Portage patch requested, but failed to apply!"
                                                        fi
                                                else
                                                        if [[ -n $(grep 'We do not want portage' "${x}/ltmain.sh") ]] ; then
                                                        #       ewarn "  Portage patch seems to be already applied."
                                                        #       ewarn "  Please verify that it is not needed."
                                                                :
                                                        else
                                                            local version=$( \
                                                                        eval $(grep -e '^[[:space:]]*VERSION=' "${x}/ltmain.sh"); \
                                                                        echo "${VERSION}")

                                                                echo
                                                                eerror "Portage patch failed to apply (ltmain.sh version ${version})!"
                                                                eerror "Please bug azarah or vapier to add proper patch."
                                                                die "Portage patch failed to apply!"
                                                        fi
                                                        # We do not want to run libtoolize ...
                                                        ELT_APPLIED_PATCHES="portage"
                                                fi
                                                ;;
                                        "uclibc-"*)
                                                [[ ${CHOST} == *"-uclibc" ]] && \
                                                        ewarn "  uClibc patch set '${y}' failed to apply!"
                                                ;;
                                        "fbsd-"*)
                                                if [[ ${CHOST} == *"-freebsd"* ]] ; then
                                                        if [[ -z $(grep 'Handle Gentoo/FreeBSD as it was Linux' \
                                                                "${x}/configure" "${x}/../configure" 2>/dev/null) ]]; then
                                                                eerror "  FreeBSD patch set '${y}' failed to apply!"
                                                                die "FreeBSD patch set '${y}' failed to apply!"
                                                        fi
                                                fi
                                                ;;
                                        "darwin-"*)
                                                [[ ${CHOST} == *"-darwin"* ]] && \
                                                        ewarn "  Darwin patch set '${y}' failed to apply!"
                                                ;;
                                esac
                        fi
                done

                if [[ -z ${ELT_APPLIED_PATCHES} ]] ; then
                        if [[ ${do_portage} == "no" && \
                                  ${do_reversedeps} == "no" && \
                                  ${do_only_patches} == "no" && \
                                  ${deptoremove} == "" ]]
                        then
                                ewarn "Cannot apply any patches, please file a bug about this"
                                die
                        fi
                fi

                [[ -f ${x}/libtool ]] && rm -f "${x}/libtool"

                >> "${x}/.elibtoolized"
        done

        cd "${start_dir}"
}

uclibctoolize() {
        ewarn "uclibctoolize() is deprecated, please just use elibtoolize()!"
        elibtoolize
}

darwintoolize() {
        ewarn "darwintoolize() is deprecated, please just use elibtoolize()!"
        elibtoolize
}

# char *VER_major(string)
#
#    Return the Major (X of X.Y.Z) version
#
VER_major() {
        [[ -z $1 ]] && return 1

        local VER=$@
        echo "${VER%%[^[:digit:]]*}"
}

# char *VER_minor(string)
#
#    Return the Minor (Y of X.Y.Z) version
#
VER_minor() {
        [[ -z $1 ]] && return 1

        local VER=$@
        VER=${VER#*.}
        echo "${VER%%[^[:digit:]]*}"
}

# char *VER_micro(string)
#
#    Return the Micro (Z of X.Y.Z) version.
#
VER_micro() {
        [[ -z $1 ]] && return 1

        local VER=$@
        VER=${VER#*.*.}
        echo "${VER%%[^[:digit:]]*}"
}

# int VER_to_int(string)
#
#    Convert a string type version (2.4.0) to an int (132096)
#    for easy compairing or versions ...
#
VER_to_int() {
        [[ -z $1 ]] && return 1

        local VER_MAJOR=$(VER_major "$1")
        local VER_MINOR=$(VER_minor "$1")
        local VER_MICRO=$(VER_micro "$1")
        local VER_int=$(( VER_MAJOR * 65536 + VER_MINOR * 256 + VER_MICRO ))

        # We make version 1.0.0 the minimum version we will handle as
        # a sanity check ... if its less, we fail ...
        if [[ ${VER_int} -ge 65536 ]] ; then
                echo "${VER_int}"
                return 0
        fi

        echo 1
        return 1
}
1	vapier	1.75	# Copyright 1999-2007 Gentoo Foundation
2	vapier	1.15	# Distributed under the terms of the GNU General Public License v2
3	vapier	1.86	# $Header: /var/cvsroot/gentoo-x86/eclass/libtool.eclass,v 1.85 2010/03/12 08:17:40 haubi Exp $
4	vapier	1.20	#
5	vapier	1.75	# Maintainer: base-system@gentoo.org
6	vapier	1.20	#
7	azarah	1.1	# This eclass patches ltmain.sh distributed with libtoolized packages with the
8	azarah	1.24	# relink and portage patch among others
9	vapier	1.75	#
10			# Note, this eclass does not require libtool as it only applies patches to
11			# generated libtool files. We do not run the libtoolize program because that
12			# requires a regeneration of the main autotool files in order to work properly.
13	rac	1.34
14	vapier	1.22	DESCRIPTION="Based on the ${ECLASS} eclass"
15	azarah	1.1
16	azarah	1.44	ELIBTOOL_VERSION="2.0.2"
17	azarah	1.1
18	vapier	1.82	inherit toolchain-funcs
19
20	azarah	1.67	ELT_PATCH_DIR="${ECLASSDIR}/ELT-patches"
21	azarah	1.24	ELT_APPLIED_PATCHES=
22	azarah	1.53	ELT_LTMAIN_SH=
23	azarah	1.24
24			#
25			# Returns all the directories containing ltmain.sh
26			#
27			ELT_find_ltmain_sh() {
28			local x=
29			local dirlist=
30
31	vapier	1.42	for x in $(find "${S}" -name 'ltmain.sh') ; do
32	mr_bones_	1.27	dirlist="${dirlist} ${x%/*}"
33			done
34	azarah	1.24
35	mr_bones_	1.27	echo "${dirlist}"
36	azarah	1.24	}
37
38			#
39			# See if we can apply $2 on $1, and if so, do it
40			#
41			ELT_try_and_apply_patch() {
42			local ret=0
43	azarah	1.57	local file=$1
44			local patch=$2
45	azarah	1.24
46			# We only support patchlevel of 0 - why worry if its static patches?
47	azarah	1.62	if patch -p0 --dry-run "${file}" "${patch}" &> "${T}/elibtool.log" ; then
48	vapier	1.37	einfo " Applying $(basename "$(dirname "${patch}")")-${patch##*/}.patch ..."
49	azarah	1.62	patch -p0 -g0 --no-backup-if-mismatch "${file}" "${patch}" \
50			&> "${T}/elibtool.log"
51	azarah	1.24	ret=$?
52			export ELT_APPLIED_PATCHES="${ELT_APPLIED_PATCHES} ${patch##*/}"
53			else
54			ret=1
55			fi
56
57	azarah	1.57	return "${ret}"
58	azarah	1.24	}
59
60			#
61	azarah	1.59	# Get string version of ltmain.sh or ltconfig (passed as $1)
62			#
63			ELT_libtool_version() {
64			local ltmain_sh=$1
65			local version=
66
67			version=$(eval $(grep -e '^[[:space:]]*VERSION=' "${ltmain_sh}"); \
68			echo "${VERSION}")
69			[[ -z ${version} ]] && version="0"
70
71			echo "${version}"
72			}
73
74			#
75	azarah	1.24	# Run through the patches in $2 and see if any
76			# apply to $1 ...
77			#
78			ELT_walk_patches() {
79	vapier	1.86	local patch
80	azarah	1.24	local ret=1
81	azarah	1.57	local file=$1
82			local patch_set=$2
83	vapier	1.86	local patch_dir="${ELT_PATCH_DIR}/${patch_set}"
84	azarah	1.57	local rem_int_dep=$3
85	azarah	1.2
86	vapier	1.86	[[ -z ${patch_set} ]] && return 1
87			[[ ! -d ${patch_dir} ]] && return 1
88	mr_bones_	1.27
89	vapier	1.86	pushd "${ELT_PATCH_DIR}" >/dev/null
90	azarah	1.43
91	vapier	1.86	# Go through the patches in reverse order (newer version to older)
92			for patch in $(find "${patch_set}" -maxdepth 1 -type f \| LC_ALL=C sort -r) ; do
93			# For --remove-internal-dep ...
94			if [[ -n ${rem_int_dep} ]] ; then
95			# For replace @REM_INT_DEP@ with what was passed
96			# to --remove-internal-dep
97			local tmp="${T}/$$.rem_int_deps.patch"
98			sed -e "s\|@REM_INT_DEP@\|${rem_int_dep}\|g" "${patch}" > "${tmp}"
99			patch=${tmp}
100			fi
101	azarah	1.43
102	vapier	1.86	if ELT_try_and_apply_patch "${file}" "${patch}" ; then
103			# Break to unwind w/popd rather than return directly
104			ret=0
105			break
106			fi
107			done
108	azarah	1.24
109	vapier	1.86	popd "${patch_dir}" >/dev/null
110			return ${ret}
111	azarah	1.24	}
112
113			elibtoolize() {
114			local x=
115			local y=
116			local do_portage="no"
117			local do_reversedeps="no"
118			local do_only_patches="no"
119	azarah	1.56	local do_uclibc="yes"
120	azarah	1.24	local deptoremove=
121			local my_dirlist=
122	loki_val	1.83	local elt_patches="install-sh ltmain portage relink max_cmd_len sed test tmp cross as-needed"
123	azarah	1.57	local start_dir=${PWD}
124	azarah	1.24
125	azarah	1.57	my_dirlist=$(ELT_find_ltmain_sh)
126	mr_bones_	1.27
127	vapier	1.42	for x in "$@" ; do
128	azarah	1.24	case "${x}" in
129			"--portage")
130			# Only apply portage patch, and don't
131			# 'libtoolize --copy --force' if all patches fail.
132			do_portage="yes"
133			;;
134			"--reverse-deps")
135			# Apply the reverse-deps patch
136			# http://bugzilla.gnome.org/show_bug.cgi?id=75635
137			do_reversedeps="yes"
138			elt_patches="${elt_patches} fix-relink"
139			;;
140			"--patch-only")
141			# Do not run libtoolize if none of the patches apply ..
142			do_only_patches="yes"
143			;;
144			"^--remove-internal-dep="*)
145			# We will replace @REM_INT_DEP@ with what is needed
146			# in ELT_walk_patches() ...
147	azarah	1.57	deptoremove=$(echo "${x}" \| sed -e 's\|--remove-internal-dep=\|\|')
148	azarah	1.24
149			# Add the patch for this ...
150	azarah	1.57	[[ -n ${deptoremove} ]] && elt_patches="${elt_patches} rem-int-dep"
151	azarah	1.24	;;
152			"--shallow")
153			# Only patch the ltmain.sh in ${S}
154	azarah	1.57	if [[ -f ${S}/ltmain.sh ]] ; then
155			my_dirlist=${S}
156	azarah	1.24	else
157			my_dirlist=
158			fi
159			;;
160	vapier	1.40	"--no-uclibc")
161	azarah	1.56	do_uclibc="no"
162	vapier	1.40	;;
163	vapier	1.42	*)
164	azarah	1.57	eerror "Invalid elibtoolize option: ${x}"
165			die "elibtoolize called with ${x} ??"
166	azarah	1.24	esac
167	azarah	1.4	done
168	azarah	1.1
169	azarah	1.56	[[ ${do_uclibc} == "yes" ]] && \
170			elt_patches="${elt_patches} uclibc-conf uclibc-ltconf"
171
172	grobian	1.84	case "${CHOST}" in
173			-aix)
174			elt_patches="${elt_patches} hardcode aixrtl"
175			;;
176			-darwin)
177			elt_patches="${elt_patches} darwin-ltconf darwin-ltmain darwin-conf"
178			;;
179			-freebsd)
180			elt_patches="${elt_patches} fbsd-conf fbsd-ltconf"
181			;;
182			-hpux)
183			elt_patches="${elt_patches} hpux-conf deplibs hc-flag-ld hardcode hardcode-relink relink-prog no-lc"
184			;;
185			-irix)
186			elt_patches="${elt_patches} irix-ltmain"
187			;;
188			-mint)
189			elt_patches="${elt_patches} mint-conf"
190			;;
191			esac
192	usata	1.36
193	vapier	1.42	for x in ${my_dirlist} ; do
194	azarah	1.51	local tmp=$(echo "${x}" \| sed -e "s\|${WORKDIR}\|\|")
195	azarah	1.24	export ELT_APPLIED_PATCHES=
196	azarah	1.53	export ELT_LTMAIN_SH="${x}/ltmain.sh"
197	mr_bones_	1.27
198	azarah	1.52	[[ -f ${x}/.elibtoolized ]] && continue
199
200	azarah	1.1	cd ${x}
201	azarah	1.51	einfo "Running elibtoolize in: $(echo "/${tmp}" \| sed -e 's\|//\|/\|g; s\|^/\|\|')"
202	azarah	1.2
203	vapier	1.42	for y in ${elt_patches} ; do
204	azarah	1.24	local ret=0
205
206			case "${y}" in
207	azarah	1.64	"portage")
208			# Stupid test to see if its already applied ...
209			if [[ -z $(grep 'We do not want portage' "${x}/ltmain.sh") ]] ; then
210			ELT_walk_patches "${x}/ltmain.sh" "${y}"
211			ret=$?
212			fi
213			;;
214	azarah	1.24	"rem-int-dep")
215			ELT_walk_patches "${x}/ltmain.sh" "${y}" "${deptoremove}"
216			ret=$?
217			;;
218			"fix-relink")
219			# Do not apply if we do not have the relink patch applied ...
220	vapier	1.42	if [[ -n $(grep 'inst_prefix_dir' "${x}/ltmain.sh") ]] ; then
221	azarah	1.24	ELT_walk_patches "${x}/ltmain.sh" "${y}"
222			ret=$?
223			fi
224			;;
225	azarah	1.25	"max_cmd_len")
226			# Do not apply if $max_cmd_len is not used ...
227	vapier	1.42	if [[ -n $(grep 'max_cmd_len' "${x}/ltmain.sh") ]] ; then
228	azarah	1.25	ELT_walk_patches "${x}/ltmain.sh" "${y}"
229			ret=$?
230			fi
231			;;
232	loki_val	1.83	"as-needed")
233			ELT_walk_patches "${x}/ltmain.sh" "${y}"
234			ret=$?
235			;;
236	azarah	1.53	"uclibc-conf")
237	azarah	1.58	if [[ -e ${x}/configure && \
238			-n $(grep 'Transform linux' "${x}/configure") ]] ; then
239	azarah	1.53	ELT_walk_patches "${x}/configure" "${y}"
240			ret=$?
241			# ltmain.sh and co might be in a subdirectory ...
242	azarah	1.58	elif [[ ! -e ${x}/configure && -e ${x}/../configure && \
243			-n $(grep 'Transform linux' "${x}/../configure") ]] ; then
244	azarah	1.53	ELT_walk_patches "${x}/../configure" "${y}"
245			ret=$?
246			fi
247			;;
248			"uclibc-ltconf")
249	azarah	1.60	# Newer libtoolize clears ltconfig, as not used anymore
250			if [[ -s ${x}/ltconfig ]] ; then
251	azarah	1.53	ELT_walk_patches "${x}/ltconfig" "${y}"
252			ret=$?
253			fi
254			;;
255	flameeyes	1.55	"fbsd-conf")
256	azarah	1.58	if [[ -e ${x}/configure && \
257			-n $(grep 'version_type=freebsd-' "${x}/configure") ]] ; then
258	flameeyes	1.55	ELT_walk_patches "${x}/configure" "${y}"
259			ret=$?
260			# ltmain.sh and co might be in a subdirectory ...
261	azarah	1.58	elif [[ ! -e ${x}/configure && -e ${x}/../configure && \
262			-n $(grep 'version_type=freebsd-' "${x}/../configure") ]] ; then
263	flameeyes	1.55	ELT_walk_patches "${x}/../configure" "${y}"
264			ret=$?
265			fi
266			;;
267	flameeyes	1.68	"fbsd-ltconf")
268			if [[ -s ${x}/ltconfig ]] ; then
269			ELT_walk_patches "${x}/ltconfig" "${y}"
270			ret=$?
271			fi
272			;;
273	grobian	1.84	"darwin-conf")
274			if [[ -e ${x}/configure && \
275			-n $(grep '&& echo \.so \|\|' "${x}/configure") ]] ; then
276			ELT_walk_patches "${x}/configure" "${y}"
277			ret=$?
278			# ltmain.sh and co might be in a subdirectory ...
279			elif [[ ! -e ${x}/configure && -e ${x}/../configure && \
280			-n $(grep '&& echo \.so \|\|' "${x}/../configure") ]] ; then
281			ELT_walk_patches "${x}/../configure" "${y}"
282			ret=$?
283			fi
284			;;
285	azarah	1.60	"darwin-ltconf")
286			# Newer libtoolize clears ltconfig, as not used anymore
287			if [[ -s ${x}/ltconfig ]] ; then
288			ELT_walk_patches "${x}/ltconfig" "${y}"
289			ret=$?
290			fi
291			;;
292	grobian	1.84	"darwin-ltmain")
293			# special case to avoid false positives (failing to apply
294			# ltmain.sh path message), newer libtools have this patch
295			# built in, so not much to patch around then
296			if [[ -e ${x}/ltmain.sh && \
297			-z $(grep 'verstring="-compatibility_version' "${x}/ltmain.sh") ]] ; then
298			ELT_walk_patches "${x}/ltmain.sh" "${y}"
299			ret=$?
300			fi
301			;;
302	haubi	1.85	"aixrtl" \| "hpux-conf")
303			ret=1
304			local subret=0
305			# apply multiple patches as often as they match
306			while [[ $subret -eq 0 ]]; do
307			subret=1
308			if [[ -e ${x}/configure ]]; then
309			ELT_walk_patches "${x}/configure" "${y}"
310			subret=$?
311			# ltmain.sh and co might be in a subdirectory ...
312			elif [[ ! -e ${x}/configure && -e ${x}/../configure ]] ; then
313			ELT_walk_patches "${x}/../configure" "${y}"
314			subret=$?
315			fi
316			if [[ $subret -eq 0 ]]; then
317			# have at least one patch succeeded.
318			ret=0
319			fi
320			done
321			;;
322			"mint-conf")
323	grobian	1.84	ret=1
324			local subret=1
325			if [[ -e ${x}/configure ]]; then
326			ELT_walk_patches "${x}/configure" "${y}"
327			subret=$?
328			# ltmain.sh and co might be in a subdirectory ...
329			elif [[ ! -e ${x}/configure && -e ${x}/../configure ]] ; then
330			ELT_walk_patches "${x}/../configure" "${y}"
331			subret=$?
332			fi
333			if [[ $subret -eq 0 ]]; then
334			# have at least one patch succeeded.
335			ret=0
336			fi
337			;;
338	uberlord	1.78	"install-sh")
339			ELT_walk_patches "${x}/install-sh" "${y}"
340			ret=$?
341			;;
342	vapier	1.82	"cross")
343			if tc-is-cross-compiler ; then
344			ELT_walk_patches "${x}/ltmain.sh" "${y}"
345			ret=$?
346			fi
347			;;
348	azarah	1.24	*)
349			ELT_walk_patches "${x}/ltmain.sh" "${y}"
350			ret=$?
351			;;
352			esac
353	mr_bones_	1.27
354	vapier	1.42	if [[ ${ret} -ne 0 ]] ; then
355	azarah	1.3	case ${y} in
356	azarah	1.24	"relink")
357	azarah	1.59	local version=$(ELT_libtool_version "${x}/ltmain.sh")
358	azarah	1.24	# Critical patch, but could be applied ...
359	azarah	1.59	# FIXME: Still need a patch for ltmain.sh > 1.4.0
360			if [[ -z $(grep 'inst_prefix_dir' "${x}/ltmain.sh") && \
361			$(VER_to_int "${version}") -ge $(VER_to_int "1.4.0") ]] ; then
362	azarah	1.24	ewarn " Could not apply relink.patch!"
363			fi
364			;;
365			"portage")
366			# Critical patch - for this one we abort, as it can really
367			# cause breakage without it applied!
368	vapier	1.42	if [[ ${do_portage} == "yes" ]] ; then
369	azarah	1.24	# Stupid test to see if its already applied ...
370	vapier	1.42	if [[ -z $(grep 'We do not want portage' "${x}/ltmain.sh") ]] ; then
371	azarah	1.24	echo
372			eerror "Portage patch requested, but failed to apply!"
373	azarah	1.63	eerror "Please bug azarah or vapier to add proper patch."
374	azarah	1.24	die "Portage patch requested, but failed to apply!"
375			fi
376			else
377	azarah	1.45	if [[ -n $(grep 'We do not want portage' "${x}/ltmain.sh") ]] ; then
378	azarah	1.51	# ewarn " Portage patch seems to be already applied."
379			# ewarn " Please verify that it is not needed."
380			:
381	azarah	1.45	else
382	azarah	1.46	local version=$( \
383			eval $(grep -e '^[[:space:]]*VERSION=' "${x}/ltmain.sh"); \
384			echo "${VERSION}")
385
386	azarah	1.45	echo
387	azarah	1.46	eerror "Portage patch failed to apply (ltmain.sh version ${version})!"
388	azarah	1.63	eerror "Please bug azarah or vapier to add proper patch."
389	azarah	1.45	die "Portage patch failed to apply!"
390			fi
391			# We do not want to run libtoolize ...
392			ELT_APPLIED_PATCHES="portage"
393	azarah	1.3	fi
394			;;
395	azarah	1.53	"uclibc-"*)
396			[[ ${CHOST} == *"-uclibc" ]] && \
397			ewarn " uClibc patch set '${y}' failed to apply!"
398			;;
399	flameeyes	1.55	"fbsd-"*)
400	azarah	1.60	if [[ ${CHOST} == "-freebsd" ]] ; then
401	flameeyes	1.65	if [[ -z $(grep 'Handle Gentoo/FreeBSD as it was Linux' \
402			"${x}/configure" "${x}/../configure" 2>/dev/null) ]]; then
403	flameeyes	1.61	eerror " FreeBSD patch set '${y}' failed to apply!"
404			die "FreeBSD patch set '${y}' failed to apply!"
405			fi
406	azarah	1.60	fi
407			;;
408			"darwin-"*)
409	grobian	1.74	[[ ${CHOST} == "-darwin" ]] && \
410	azarah	1.60	ewarn " Darwin patch set '${y}' failed to apply!"
411	flameeyes	1.55	;;
412	azarah	1.3	esac
413	azarah	1.1	fi
414	azarah	1.52	done
415	azarah	1.11
416	azarah	1.52	if [[ -z ${ELT_APPLIED_PATCHES} ]] ; then
417			if [[ ${do_portage} == "no" && \
418			${do_reversedeps} == "no" && \
419			${do_only_patches} == "no" && \
420			${deptoremove} == "" ]]
421			then
422			ewarn "Cannot apply any patches, please file a bug about this"
423	vapier	1.75	die
424	azarah	1.1	fi
425	azarah	1.52	fi
426
427			[[ -f ${x}/libtool ]] && rm -f "${x}/libtool"
428
429	drac	1.81	>> "${x}/.elibtoolized"
430	azarah	1.1	done
431	azarah	1.6
432	vapier	1.29	cd "${start_dir}"
433	vapier	1.30	}
434
435			uclibctoolize() {
436	cardoe	1.76	ewarn "uclibctoolize() is deprecated, please just use elibtoolize()!"
437	azarah	1.53	elibtoolize
438	azarah	1.1	}
439	usata	1.36
440			darwintoolize() {
441	cardoe	1.76	ewarn "darwintoolize() is deprecated, please just use elibtoolize()!"
442	azarah	1.60	elibtoolize
443	usata	1.36	}
444	azarah	1.44
445			# char *VER_major(string)
446			#
447			# Return the Major (X of X.Y.Z) version
448			#
449			VER_major() {
450			[[ -z $1 ]] && return 1
451
452			local VER=$@
453	azarah	1.57	echo "${VER%%[^[:digit:]]*}"
454	azarah	1.44	}
455
456			# char *VER_minor(string)
457			#
458			# Return the Minor (Y of X.Y.Z) version
459			#
460			VER_minor() {
461			[[ -z $1 ]] && return 1
462
463			local VER=$@
464			VER=${VER#*.}
465	azarah	1.57	echo "${VER%%[^[:digit:]]*}"
466	azarah	1.44	}
467
468			# char *VER_micro(string)
469			#
470			# Return the Micro (Z of X.Y.Z) version.
471			#
472			VER_micro() {
473			[[ -z $1 ]] && return 1
474
475			local VER=$@
476			VER=${VER#..}
477	azarah	1.57	echo "${VER%%[^[:digit:]]*}"
478	azarah	1.44	}
479
480			# int VER_to_int(string)
481			#
482			# Convert a string type version (2.4.0) to an int (132096)
483			# for easy compairing or versions ...
484			#
485			VER_to_int() {
486			[[ -z $1 ]] && return 1
487
488			local VER_MAJOR=$(VER_major "$1")
489			local VER_MINOR=$(VER_minor "$1")
490			local VER_MICRO=$(VER_micro "$1")
491			local VER_int=$(( VER_MAJOR * 65536 + VER_MINOR * 256 + VER_MICRO ))
492
493			# We make version 1.0.0 the minimum version we will handle as
494			# a sanity check ... if its less, we fail ...
495			if [[ ${VER_int} -ge 65536 ]] ; then
496			echo "${VER_int}"
497			return 0
498			fi
499
500			echo 1
501			return 1
502			}