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.87 2010/04/14 18:14:45 vapier 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 >/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 file a bug report to add a 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 file a bug report to add a 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.88	# $Header: /var/cvsroot/gentoo-x86/eclass/libtool.eclass,v 1.87 2010/04/14 18:14:45 vapier 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.87	popd >/dev/null
110	vapier	1.86	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	vapier	1.88	eerror "Please file a bug report to add a 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	vapier	1.88	eerror "Please file a bug report to add a 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			}