gentoo-x86/eclass/libtool.eclass

# Copyright 1999-2012 Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2
# $Header: /var/cvsroot/gentoo-x86/eclass/libtool.eclass,v 1.100 2012/05/06 11:42:07 grobian Exp $

# @ECLASS: libtool.eclass
# @MAINTAINER:
# base-system@gentoo.org
# @BLURB: quickly update bundled libtool code
# @DESCRIPTION:
# 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.

if [[ ${___ECLASS_ONCE_LIBTOOL} != "recur -_+^+_- spank" ]] ; then
___ECLASS_ONCE_LIBTOOL="recur -_+^+_- spank"

# If an overlay has eclass overrides, but doesn't actually override the
# libtool.eclass, we'll have ECLASSDIR pointing to the active overlay's
# eclass/ dir, but libtool.eclass is still in the main Gentoo tree.  So
# add a check to locate the ELT-patches/ regardless of what's going on.
ECLASSDIR_LOCAL=${BASH_SOURCE[0]%/*}
elt_patch_dir() {
        local d="${ECLASSDIR}/ELT-patches"
        if [[ ! -d ${d} ]] ; then
                d="${ECLASSDIR_LOCAL}/ELT-patches"
        fi
        echo "${d}"
}

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

inherit multilib toolchain-funcs

#
# 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
        local src=$3
        local disp="${src} patch"
        local log="${T}/elibtool.log"

        if [[ -z ${__ELT_NOTED_TMP} ]] ; then
                __ELT_NOTED_TMP=true
                printf 'temp patch: %s\n' "${patch}" > "${log}"
        fi
        printf '\nTrying %s\n' "${disp}" >> "${log}"

        # We only support patchlevel of 0 - why worry if its static patches?
        if patch -p0 --dry-run "${file}" "${patch}" >> "${log}" 2>&1 ; then
                einfo "  Applying ${disp} ..."
                patch -p0 -g0 --no-backup-if-mismatch "${file}" "${patch}" >> "${log}" 2>&1
                ret=$?
                export ELT_APPLIED_PATCHES="${ELT_APPLIED_PATCHES} ${src}"
        else
                ret=1
        fi

        return "${ret}"
}

#
# Get string version of ltmain.sh or ltconfig (passed as $1)
#
ELT_libtool_version() {
        (
        unset VERSION
        eval $(grep -e '^[[:space:]]*VERSION=' "$1")
        echo "${VERSION:-0}"
        )
}

#
# Run through the patches in $2 and see if any
# apply to $1 ...
#
ELT_walk_patches() {
        local patch tmp
        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

        # Allow patches to use @GENTOO_LIBDIR@ replacements
        local sed_args=( -e "s:@GENTOO_LIBDIR@:$(get_libdir):g" )
        if [[ -n ${rem_int_dep} ]] ; then
                # replace @REM_INT_DEP@ with what was passed
                # to --remove-internal-dep
                sed_args+=( -e "s|@REM_INT_DEP@|${rem_int_dep}|g" )
        fi

        pushd "$(elt_patch_dir)" >/dev/null || die

        # 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
                tmp="${T}/libtool-elt.patch"
                sed "${sed_args[@]}" "${patch}" > "${tmp}" || die
                if ELT_try_and_apply_patch "${file}" "${tmp}" "${patch}" ; then
                        # Break to unwind w/popd rather than return directly
                        ret=0
                        break
                fi
        done

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

# @FUNCTION: elibtoolize
# @USAGE: [dirs] [--portage] [--reverse-deps] [--patch-only] [--remove-internal-dep=xxx] [--shallow] [--no-uclibc]
# @DESCRIPTION:
# Apply a smorgasbord of patches to bundled libtool files.  This function
# should always be safe to run.  If no directories are specified, then
# ${S} will be searched for appropriate files.
#
# If the --shallow option is used, then only ${S}/ltmain.sh will be patched.
#
# The other options should be avoided in general unless you know what's going on.
elibtoolize() {
        local x
        local do_portage="no"
        local do_reversedeps="no"
        local do_only_patches="no"
        local do_uclibc="yes"
        local deptoremove=
        local do_shallow="no"
        local force="false"
        local elt_patches="install-sh ltmain portage relink max_cmd_len sed test tmp cross as-needed"

        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+=" 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=${x#--remove-internal-dep=}

                                # Add the patch for this ...
                                [[ -n ${deptoremove} ]] && elt_patches+=" rem-int-dep"
                                ;;
                        --shallow)
                                # Only patch the ltmain.sh in ${S}
                                do_shallow="yes"
                                ;;
                        --no-uclibc)
                                do_uclibc="no"
                                ;;
                        --force)
                                force="true"
                                ;;
                        *)
                                eerror "Invalid elibtoolize option: ${x}"
                                die "elibtoolize called with ${x} ??"
                esac
        done

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

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

        if $(tc-getLD) --version 2>&1 | grep -qs 'GNU gold'; then
                elt_patches+=" gold-conf"
        fi

        # Reuse "$@" for dirs to patch
        set --
        if [[ ${do_shallow} == "yes" ]] ; then
                [[ -f ${S}/ltmain.sh ]] && set -- "${S}"
        else
                set -- $(find "${S}" -name ltmain.sh -printf '%h ')
        fi

        local d p
        for d in "$@" ; do
                export ELT_APPLIED_PATCHES=

                if [[ -f ${d}/.elibtoolized ]] ; then
                        ${force} || continue
                fi

                local outfunc="einfo"
                [[ -f ${d}/.elibtoolized ]] && outfunc="ewarn"
                ${outfunc} "Running elibtoolize in: ${d#${WORKDIR}/}/"
                if [[ ${outfunc} == "ewarn" ]] ; then
                        ewarn "  We've already been run in this tree; you should"
                        ewarn "  avoid this if possible (perhaps by filing a bug)"
                fi

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

                        case ${p} in
                                portage)
                                        # Stupid test to see if its already applied ...
                                        if ! grep -qs 'We do not want portage' "${d}/ltmain.sh" ; then
                                                ELT_walk_patches "${d}/ltmain.sh" "${p}"
                                                ret=$?
                                        fi
                                        ;;
                                rem-int-dep)
                                        ELT_walk_patches "${d}/ltmain.sh" "${p}" "${deptoremove}"
                                        ret=$?
                                        ;;
                                fix-relink)
                                        # Do not apply if we do not have the relink patch applied ...
                                        if grep -qs 'inst_prefix_dir' "${d}/ltmain.sh" ; then
                                                ELT_walk_patches "${d}/ltmain.sh" "${p}"
                                                ret=$?
                                        fi
                                        ;;
                                max_cmd_len)
                                        # Do not apply if $max_cmd_len is not used ...
                                        if grep -qs 'max_cmd_len' "${d}/ltmain.sh" ; then
                                                ELT_walk_patches "${d}/ltmain.sh" "${p}"
                                                ret=$?
                                        fi
                                        ;;
                                as-needed)
                                        ELT_walk_patches "${d}/ltmain.sh" "${p}"
                                        ret=$?
                                        ;;
                                uclibc-conf)
                                        if grep -qs 'Transform linux' "${d}/configure" ; then
                                                ELT_walk_patches "${d}/configure" "${p}"
                                                ret=$?
                                        # ltmain.sh and co might be in a subdirectory ...
                                        elif [[ ! -e ${d}/configure ]] && \
                                                 grep -qs 'Transform linux' "${d}/../configure" ; then
                                                ELT_walk_patches "${d}/../configure" "${p}"
                                                ret=$?
                                        fi
                                        ;;
                                uclibc-ltconf)
                                        # Newer libtoolize clears ltconfig, as not used anymore
                                        if [[ -s ${d}/ltconfig ]] ; then
                                                ELT_walk_patches "${d}/ltconfig" "${p}"
                                                ret=$?
                                        fi
                                        ;;
                                fbsd-conf)
                                        if grep -qs 'version_type=freebsd-' "${d}/configure" ; then
                                                ELT_walk_patches "${d}/configure" "${p}"
                                                ret=$?
                                        # ltmain.sh and co might be in a subdirectory ...
                                        elif [[ ! -e ${d}/configure ]] && \
                                                 grep -qs 'version_type=freebsd-' "${d}/../configure" ; then
                                                ELT_walk_patches "${d}/../configure" "${p}"
                                                ret=$?
                                        fi
                                        ;;
                                fbsd-ltconf)
                                        if [[ -s ${d}/ltconfig ]] ; then
                                                ELT_walk_patches "${d}/ltconfig" "${p}"
                                                ret=$?
                                        fi
                                        ;;
                                darwin-conf)
                                        if grep -qs '&& echo \.so ||' "${d}/configure" ; then
                                                ELT_walk_patches "${d}/configure" "${p}"
                                                ret=$?
                                        # ltmain.sh and co might be in a subdirectory ...
                                        elif [[ ! -e ${d}/configure ]] && \
                                                 grep -qs '&& echo \.so ||' "${d}/../configure" ; then
                                                ELT_walk_patches "${d}/../configure" "${p}"
                                                ret=$?
                                        fi
                                        ;;
                                darwin-ltconf)
                                        # Newer libtoolize clears ltconfig, as not used anymore
                                        if [[ -s ${d}/ltconfig ]] ; then
                                                ELT_walk_patches "${d}/ltconfig" "${p}"
                                                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 ${d}/ltmain.sh ]] && \
                                           ! grep -qs 'verstring="-compatibility_version' "${d}/ltmain.sh" ; then
                                                ELT_walk_patches "${d}/ltmain.sh" "${p}"
                                                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 ${d}/configure ]]; then
                                                        ELT_walk_patches "${d}/configure" "${p}"
                                                        subret=$?
                                                # ltmain.sh and co might be in a subdirectory ...
                                                elif [[ ! -e ${d}/configure && -e ${d}/../configure ]] ; then
                                                        ELT_walk_patches "${d}/../configure" "${p}"
                                                        subret=$?
                                                fi
                                                if [[ $subret -eq 0 ]]; then
                                                        # have at least one patch succeeded.
                                                        ret=0
                                                fi
                                        done
                                        ;;
                                mint-conf|gold-conf|sol2-conf)
                                        ret=1
                                        local subret=1
                                        if [[ -e ${d}/configure ]]; then
                                                ELT_walk_patches "${d}/configure" "${p}"
                                                subret=$?
                                        # ltmain.sh and co might be in a subdirectory ...
                                        elif [[ -e ${d}/../configure ]] ; then
                                                ELT_walk_patches "${d}/../configure" "${p}"
                                                subret=$?
                                        elif [[ -e ${d}/../../configure ]] ; then
                                                ELT_walk_patches "${d}/../../configure" "${p}"
                                                subret=$?
                                        fi
                                        if [[ $subret -eq 0 ]]; then
                                                # have at least one patch succeeded.
                                                ret=0
                                        fi
                                        ;;
                                install-sh)
                                        ELT_walk_patches "${d}/install-sh" "${p}"
                                        ret=$?
                                        ;;
                                cross)
                                        if tc-is-cross-compiler ; then
                                                ELT_walk_patches "${d}/ltmain.sh" "${p}"
                                                ret=$?
                                        fi
                                        ;;
                                *)
                                        ELT_walk_patches "${d}/ltmain.sh" "${p}"
                                        ret=$?
                                        ;;
                        esac

                        if [[ ${ret} -ne 0 ]] ; then
                                case ${p} in
                                        relink)
                                                local version=$(ELT_libtool_version "${d}/ltmain.sh")
                                                # Critical patch, but could be applied ...
                                                # FIXME:  Still need a patch for ltmain.sh > 1.4.0
                                                if ! grep -qs 'inst_prefix_dir' "${d}/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 ! grep -qs 'We do not want portage' "${d}/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 grep -qs 'We do not want portage' "${d}/ltmain.sh" ; then
                                                        #       ewarn "  Portage patch seems to be already applied."
                                                        #       ewarn "  Please verify that it is not needed."
                                                                :
                                                        else
                                                                local version=$(ELT_libtool_version "${d}"/ltmain.sh)
                                                                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 '${p}' failed to apply!"
                                                ;;
                                        fbsd-*)
                                                if [[ ${CHOST} == *-freebsd* ]] ; then
                                                        if [[ -z $(grep 'Handle Gentoo/FreeBSD as it was Linux' \
                                                                "${d}/configure" "${d}/../configure" 2>/dev/null) ]]; then
                                                                eerror "  FreeBSD patch set '${p}' failed to apply!"
                                                                die "FreeBSD patch set '${p}' failed to apply!"
                                                        fi
                                                fi
                                                ;;
                                        darwin-*)
                                                [[ ${CHOST} == *"-darwin"* ]] && ewarn "  Darwin patch set '${p}' 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

                rm -f "${d}/libtool"

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

uclibctoolize() { die "Use elibtoolize"; }
darwintoolize() { die "Use 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
}

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