gentoo-x86/eclass/libtool.eclass

# Copyright 1999-2013 Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2
# $Header: /var/cvsroot/gentoo-x86/eclass/libtool.eclass,v 1.105 2013/05/07 14:23:33 vapier 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}"
}

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}"

        if [[ ! -e ${file} ]] ; then
                echo "File not found: ${file}" >> "${log}"
                return 1
        fi

        # Save file for permission restoration.  `patch` sometimes resets things.
        # Ideally we'd want 'stat -c %a', but stat is highly non portable and we are
        # guaranted to have GNU find, so use that instead.
        local perms="$(find ${file} -maxdepth 0 -printf '%m')"
        # 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
        chmod "${perms}" "${file}"

        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 target-nm"

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