gentoo-x86/eclass/libtool.eclass

# Copyright 1999-2005 Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2
# $Header: /var/cvsroot/gentoo-x86/eclass/libtool.eclass,v 1.69 2006/04/23 16:27:19 flameeyes Exp $
#
# Author: Martin Schlemmer <azarah@gentoo.org>
#
# This eclass patches ltmain.sh distributed with libtoolized packages with the
# relink and portage patch among others


# 2004.09.25 rac
# i have verified that at least one package can use this eclass and
# build properly even without libtool installed yet, probably using
# the files in the distribution.  eliminating this dependency fixes
# bug 65209, which is a showstopper for people doing installs using
# stageballs <3.  if anybody decides to revert this, please attempt
# to find an alternate way of resolving that bug at the same time.

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

ELIBTOOL_VERSION="2.0.2"

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 x=
        local y=
        local ret=1
        local file=$1
        local patch_set=$2
        local patch_dir=
        local rem_int_dep=$3

        if [[ -n ${patch_set} ]] ; then
                if [[ -d ${ELT_PATCH_DIR}/${patch_set} ]] ; then
                        patch_dir="${ELT_PATCH_DIR}/${patch_set}"
                else
                        return "${ret}"
                fi

                # Go through the patches in reverse order (large to small)
                for x in $(ls -d "${patch_dir}"/* 2> /dev/null | grep -v 'CVS' | sort -r) ; do
                        if [[ -n ${x} && -f ${x} ]] ; then
                                # For --remove-internal-dep ...
                                if [[ -n ${rem_int_dep} ]] ; then
                                        # For replace @REM_INT_DEP@ with what was passed
                                        # to --remove-internal-dep
                                        sed -e "s|@REM_INT_DEP@|${rem_int_dep}|g" ${x} > \
                                                "${T}/$$.rem_int_deps.patch"

                                        x="${T}/$$.rem_int_deps.patch"
                                fi

                                if ELT_try_and_apply_patch "${file}" "${x}" ; then
                                        ret=0
                                        break
                                fi
                        fi
                done
        fi

        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="portage relink max_cmd_len sed test tmp"#  kde-fastinstall
        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"

        [[ ${CHOST} == *"-freebsd"* ]] && \
                elt_patches="${elt_patches} fbsd-conf fbsd-ltconf"

        if useq ppc-macos ; then
                local opts
                [[ -f Makefile.am ]] && opts="--automake"
                glibtoolize --copy --force ${opts}

                elt_patches="${elt_patches} darwin-ltconf darwin-ltmain"
        fi

        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
                                        ;;
                                "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-ltconf")
                                        # Newer libtoolize clears ltconfig, as not used anymore
                                        if [[ -s ${x}/ltconfig ]] ; then
                                                ELT_walk_patches "${x}/ltconfig" "${y}"
                                                ret=$?
                                        fi
                                        ;;
                                *)
                                        ELT_walk_patches "${x}/ltmain.sh" "${y}"
                                        ret=$?
                                        ;;
                        esac

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

                                                                echo
                                                                eerror "Portage patch failed to apply (ltmain.sh version ${version})!"
                                                                eerror "Please bug azarah or vapier to add proper patch."
                                                                die "Portage patch failed to apply!"
                                                        fi
                                                        # We do not want to run libtoolize ...
                                                        ELT_APPLIED_PATCHES="portage"
                                                fi
                                                ;;
                                        "uclibc-"*)
                                                [[ ${CHOST} == *"-uclibc" ]] && \
                                                        ewarn "  uClibc patch set '${y}' failed to apply!"
                                                ;;
                                        "fbsd-"*)
                                                if [[ ${CHOST} == *"-freebsd"* ]] ; then
                                                        if [[ -z $(grep 'Handle Gentoo/FreeBSD as it was Linux' \
                                                                "${x}/configure" "${x}/../configure" 2>/dev/null) ]]; then
                                                                eerror "  FreeBSD patch set '${y}' failed to apply!"
                                                                die "FreeBSD patch set '${y}' failed to apply!"
                                                        fi
                                                fi
                                                ;;
                                        "darwin-"*)
                                                useq ppc-macos && \
                                                        ewarn "  Darwin patch set '${y}' failed to apply!"
                                                ;;
                                        "kde-fastinstall")
                                                if [[ -n $(grep 'test "$mode" != relink && test "$fast_install" = no' ${x}/ltmain.sh) ]]; then
                                                        ewarn "Patch ${y} failed to apply. If you experience build failures, please report this."
                                                fi
                                                ;;
                                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"
                                break

                                # Sometimes ltmain.sh is in a subdirectory ...
                                if [[ ! -f ${x}/configure.in && ! -f ${x}/configure.ac ]] ; then
                                        if [[ -f ${x}/../configure.in || -f ${x}/../configure.ac ]] ; then
                                                cd "${x}"/../
                                        fi
                                fi

                                if type -p libtoolize &> /dev/null ; then
                                        ewarn "Cannot apply any patches, running libtoolize..."
                                        libtoolize --copy --force
                                fi
                                cd "${x}"
                                break
                        fi
                fi

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

                touch "${x}/.elibtoolized"
        done

        cd "${start_dir}"
}

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

darwintoolize() {
        ewarn "darwintoolize() is depreciated, 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.42	# Copyright 1999-2005 Gentoo Foundation
2	vapier	1.15	# Distributed under the terms of the GNU General Public License v2
3	flameeyes	1.70	# $Header: /var/cvsroot/gentoo-x86/eclass/libtool.eclass,v 1.69 2006/04/23 16:27:19 flameeyes Exp $
4	vapier	1.20	#
5	azarah	1.1	# Author: Martin Schlemmer <azarah@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.15
10	danarmak	1.12
11	rac	1.34	# 2004.09.25 rac
12			# i have verified that at least one package can use this eclass and
13			# build properly even without libtool installed yet, probably using
14			# the files in the distribution. eliminating this dependency fixes
15			# bug 65209, which is a showstopper for people doing installs using
16			# stageballs <3. if anybody decides to revert this, please attempt
17			# to find an alternate way of resolving that bug at the same time.
18
19	vapier	1.22	DESCRIPTION="Based on the ${ECLASS} eclass"
20	azarah	1.1
21	azarah	1.44	ELIBTOOL_VERSION="2.0.2"
22	azarah	1.1
23	azarah	1.67	ELT_PATCH_DIR="${ECLASSDIR}/ELT-patches"
24	azarah	1.24	ELT_APPLIED_PATCHES=
25	azarah	1.53	ELT_LTMAIN_SH=
26	azarah	1.24
27			#
28			# Returns all the directories containing ltmain.sh
29			#
30			ELT_find_ltmain_sh() {
31			local x=
32			local dirlist=
33
34	vapier	1.42	for x in $(find "${S}" -name 'ltmain.sh') ; do
35	mr_bones_	1.27	dirlist="${dirlist} ${x%/*}"
36			done
37	azarah	1.24
38	mr_bones_	1.27	echo "${dirlist}"
39	azarah	1.24	}
40
41			#
42			# See if we can apply $2 on $1, and if so, do it
43			#
44			ELT_try_and_apply_patch() {
45			local ret=0
46	azarah	1.57	local file=$1
47			local patch=$2
48	azarah	1.24
49			# We only support patchlevel of 0 - why worry if its static patches?
50	azarah	1.62	if patch -p0 --dry-run "${file}" "${patch}" &> "${T}/elibtool.log" ; then
51	vapier	1.37	einfo " Applying $(basename "$(dirname "${patch}")")-${patch##*/}.patch ..."
52	azarah	1.62	patch -p0 -g0 --no-backup-if-mismatch "${file}" "${patch}" \
53			&> "${T}/elibtool.log"
54	azarah	1.24	ret=$?
55			export ELT_APPLIED_PATCHES="${ELT_APPLIED_PATCHES} ${patch##*/}"
56			else
57			ret=1
58			fi
59
60	azarah	1.57	return "${ret}"
61	azarah	1.24	}
62
63			#
64	azarah	1.59	# Get string version of ltmain.sh or ltconfig (passed as $1)
65			#
66			ELT_libtool_version() {
67			local ltmain_sh=$1
68			local version=
69
70			version=$(eval $(grep -e '^[[:space:]]*VERSION=' "${ltmain_sh}"); \
71			echo "${VERSION}")
72			[[ -z ${version} ]] && version="0"
73
74			echo "${version}"
75			}
76
77			#
78	azarah	1.24	# Run through the patches in $2 and see if any
79			# apply to $1 ...
80			#
81			ELT_walk_patches() {
82			local x=
83			local y=
84			local ret=1
85	azarah	1.57	local file=$1
86			local patch_set=$2
87	azarah	1.24	local patch_dir=
88	azarah	1.57	local rem_int_dep=$3
89	azarah	1.2
90	azarah	1.57	if [[ -n ${patch_set} ]] ; then
91			if [[ -d ${ELT_PATCH_DIR}/${patch_set} ]] ; then
92			patch_dir="${ELT_PATCH_DIR}/${patch_set}"
93	azarah	1.24	else
94	azarah	1.57	return "${ret}"
95	azarah	1.4	fi
96	mr_bones_	1.27
97	azarah	1.44	# Go through the patches in reverse order (large to small)
98	azarah	1.62	for x in $(ls -d "${patch_dir}"/* 2> /dev/null \| grep -v 'CVS' \| sort -r) ; do
99	azarah	1.44	if [[ -n ${x} && -f ${x} ]] ; then
100			# For --remove-internal-dep ...
101	azarah	1.57	if [[ -n ${rem_int_dep} ]] ; then
102	azarah	1.44	# For replace @REM_INT_DEP@ with what was passed
103			# to --remove-internal-dep
104	azarah	1.57	sed -e "s\|@REM_INT_DEP@\|${rem_int_dep}\|g" ${x} > \
105			"${T}/$$.rem_int_deps.patch"
106	azarah	1.43
107	azarah	1.44	x="${T}/$$.rem_int_deps.patch"
108	azarah	1.24	fi
109	azarah	1.43
110	azarah	1.57	if ELT_try_and_apply_patch "${file}" "${x}" ; then
111	azarah	1.44	ret=0
112			break
113	azarah	1.24	fi
114	azarah	1.44	fi
115			done
116	azarah	1.24	fi
117
118	azarah	1.57	return "${ret}"
119	azarah	1.24	}
120
121			elibtoolize() {
122			local x=
123			local y=
124			local do_portage="no"
125			local do_reversedeps="no"
126			local do_only_patches="no"
127	azarah	1.56	local do_uclibc="yes"
128	azarah	1.24	local deptoremove=
129			local my_dirlist=
130	flameeyes	1.70	local elt_patches="portage relink max_cmd_len sed test tmp"# kde-fastinstall
131	azarah	1.57	local start_dir=${PWD}
132	azarah	1.24
133	azarah	1.57	my_dirlist=$(ELT_find_ltmain_sh)
134	mr_bones_	1.27
135	vapier	1.42	for x in "$@" ; do
136	azarah	1.24	case "${x}" in
137			"--portage")
138			# Only apply portage patch, and don't
139			# 'libtoolize --copy --force' if all patches fail.
140			do_portage="yes"
141			;;
142			"--reverse-deps")
143			# Apply the reverse-deps patch
144			# http://bugzilla.gnome.org/show_bug.cgi?id=75635
145			do_reversedeps="yes"
146			elt_patches="${elt_patches} fix-relink"
147			;;
148			"--patch-only")
149			# Do not run libtoolize if none of the patches apply ..
150			do_only_patches="yes"
151			;;
152			"^--remove-internal-dep="*)
153			# We will replace @REM_INT_DEP@ with what is needed
154			# in ELT_walk_patches() ...
155	azarah	1.57	deptoremove=$(echo "${x}" \| sed -e 's\|--remove-internal-dep=\|\|')
156	azarah	1.24
157			# Add the patch for this ...
158	azarah	1.57	[[ -n ${deptoremove} ]] && elt_patches="${elt_patches} rem-int-dep"
159	azarah	1.24	;;
160			"--shallow")
161			# Only patch the ltmain.sh in ${S}
162	azarah	1.57	if [[ -f ${S}/ltmain.sh ]] ; then
163			my_dirlist=${S}
164	azarah	1.24	else
165			my_dirlist=
166			fi
167			;;
168	vapier	1.40	"--no-uclibc")
169	azarah	1.56	do_uclibc="no"
170	vapier	1.40	;;
171	vapier	1.42	*)
172	azarah	1.57	eerror "Invalid elibtoolize option: ${x}"
173			die "elibtoolize called with ${x} ??"
174	azarah	1.24	esac
175	azarah	1.4	done
176	azarah	1.1
177	azarah	1.56	[[ ${do_uclibc} == "yes" ]] && \
178			elt_patches="${elt_patches} uclibc-conf uclibc-ltconf"
179
180			[[ ${CHOST} == "-freebsd" ]] && \
181	flameeyes	1.68	elt_patches="${elt_patches} fbsd-conf fbsd-ltconf"
182	azarah	1.56
183	azarah	1.60	if useq ppc-macos ; then
184	azarah	1.51	local opts
185			[[ -f Makefile.am ]] && opts="--automake"
186			glibtoolize --copy --force ${opts}
187	flameeyes	1.61
188	azarah	1.60	elt_patches="${elt_patches} darwin-ltconf darwin-ltmain"
189	usata	1.36	fi
190
191	vapier	1.42	for x in ${my_dirlist} ; do
192	azarah	1.51	local tmp=$(echo "${x}" \| sed -e "s\|${WORKDIR}\|\|")
193	azarah	1.24	export ELT_APPLIED_PATCHES=
194	azarah	1.53	export ELT_LTMAIN_SH="${x}/ltmain.sh"
195	mr_bones_	1.27
196	azarah	1.52	[[ -f ${x}/.elibtoolized ]] && continue
197
198	azarah	1.1	cd ${x}
199	azarah	1.51	einfo "Running elibtoolize in: $(echo "/${tmp}" \| sed -e 's\|//\|/\|g; s\|^/\|\|')"
200	azarah	1.2
201	vapier	1.42	for y in ${elt_patches} ; do
202	azarah	1.24	local ret=0
203
204			case "${y}" in
205	azarah	1.64	"portage")
206			# Stupid test to see if its already applied ...
207			if [[ -z $(grep 'We do not want portage' "${x}/ltmain.sh") ]] ; then
208			ELT_walk_patches "${x}/ltmain.sh" "${y}"
209			ret=$?
210			fi
211			;;
212	azarah	1.24	"rem-int-dep")
213			ELT_walk_patches "${x}/ltmain.sh" "${y}" "${deptoremove}"
214			ret=$?
215			;;
216			"fix-relink")
217			# Do not apply if we do not have the relink patch applied ...
218	vapier	1.42	if [[ -n $(grep 'inst_prefix_dir' "${x}/ltmain.sh") ]] ; then
219	azarah	1.24	ELT_walk_patches "${x}/ltmain.sh" "${y}"
220			ret=$?
221			fi
222			;;
223	azarah	1.25	"max_cmd_len")
224			# Do not apply if $max_cmd_len is not used ...
225	vapier	1.42	if [[ -n $(grep 'max_cmd_len' "${x}/ltmain.sh") ]] ; then
226	azarah	1.25	ELT_walk_patches "${x}/ltmain.sh" "${y}"
227			ret=$?
228			fi
229			;;
230	azarah	1.53	"uclibc-conf")
231	azarah	1.58	if [[ -e ${x}/configure && \
232			-n $(grep 'Transform linux' "${x}/configure") ]] ; then
233	azarah	1.53	ELT_walk_patches "${x}/configure" "${y}"
234			ret=$?
235			# ltmain.sh and co might be in a subdirectory ...
236	azarah	1.58	elif [[ ! -e ${x}/configure && -e ${x}/../configure && \
237			-n $(grep 'Transform linux' "${x}/../configure") ]] ; then
238	azarah	1.53	ELT_walk_patches "${x}/../configure" "${y}"
239			ret=$?
240			fi
241			;;
242			"uclibc-ltconf")
243	azarah	1.60	# Newer libtoolize clears ltconfig, as not used anymore
244			if [[ -s ${x}/ltconfig ]] ; then
245	azarah	1.53	ELT_walk_patches "${x}/ltconfig" "${y}"
246			ret=$?
247			fi
248			;;
249	flameeyes	1.55	"fbsd-conf")
250	azarah	1.58	if [[ -e ${x}/configure && \
251			-n $(grep 'version_type=freebsd-' "${x}/configure") ]] ; then
252	flameeyes	1.55	ELT_walk_patches "${x}/configure" "${y}"
253			ret=$?
254			# ltmain.sh and co might be in a subdirectory ...
255	azarah	1.58	elif [[ ! -e ${x}/configure && -e ${x}/../configure && \
256			-n $(grep 'version_type=freebsd-' "${x}/../configure") ]] ; then
257	flameeyes	1.55	ELT_walk_patches "${x}/../configure" "${y}"
258			ret=$?
259			fi
260			;;
261	flameeyes	1.68	"fbsd-ltconf")
262			if [[ -s ${x}/ltconfig ]] ; then
263			ELT_walk_patches "${x}/ltconfig" "${y}"
264			ret=$?
265			fi
266			;;
267	azarah	1.60	"darwin-ltconf")
268			# Newer libtoolize clears ltconfig, as not used anymore
269			if [[ -s ${x}/ltconfig ]] ; then
270			ELT_walk_patches "${x}/ltconfig" "${y}"
271			ret=$?
272			fi
273			;;
274	azarah	1.24	*)
275			ELT_walk_patches "${x}/ltmain.sh" "${y}"
276			ret=$?
277			;;
278			esac
279	mr_bones_	1.27
280	vapier	1.42	if [[ ${ret} -ne 0 ]] ; then
281	azarah	1.3	case ${y} in
282	azarah	1.24	"relink")
283	azarah	1.59	local version=$(ELT_libtool_version "${x}/ltmain.sh")
284	azarah	1.24	# Critical patch, but could be applied ...
285	azarah	1.59	# FIXME: Still need a patch for ltmain.sh > 1.4.0
286			if [[ -z $(grep 'inst_prefix_dir' "${x}/ltmain.sh") && \
287			$(VER_to_int "${version}") -ge $(VER_to_int "1.4.0") ]] ; then
288	azarah	1.24	ewarn " Could not apply relink.patch!"
289			fi
290			;;
291			"portage")
292			# Critical patch - for this one we abort, as it can really
293			# cause breakage without it applied!
294	vapier	1.42	if [[ ${do_portage} == "yes" ]] ; then
295	azarah	1.24	# Stupid test to see if its already applied ...
296	vapier	1.42	if [[ -z $(grep 'We do not want portage' "${x}/ltmain.sh") ]] ; then
297	azarah	1.24	echo
298			eerror "Portage patch requested, but failed to apply!"
299	azarah	1.63	eerror "Please bug azarah or vapier to add proper patch."
300	azarah	1.24	die "Portage patch requested, but failed to apply!"
301			fi
302			else
303	azarah	1.45	if [[ -n $(grep 'We do not want portage' "${x}/ltmain.sh") ]] ; then
304	azarah	1.51	# ewarn " Portage patch seems to be already applied."
305			# ewarn " Please verify that it is not needed."
306			:
307	azarah	1.45	else
308	azarah	1.46	local version=$( \
309			eval $(grep -e '^[[:space:]]*VERSION=' "${x}/ltmain.sh"); \
310			echo "${VERSION}")
311
312	azarah	1.45	echo
313	azarah	1.46	eerror "Portage patch failed to apply (ltmain.sh version ${version})!"
314	azarah	1.63	eerror "Please bug azarah or vapier to add proper patch."
315	azarah	1.45	die "Portage patch failed to apply!"
316			fi
317			# We do not want to run libtoolize ...
318			ELT_APPLIED_PATCHES="portage"
319	azarah	1.3	fi
320			;;
321	azarah	1.53	"uclibc-"*)
322			[[ ${CHOST} == *"-uclibc" ]] && \
323			ewarn " uClibc patch set '${y}' failed to apply!"
324			;;
325	flameeyes	1.55	"fbsd-"*)
326	azarah	1.60	if [[ ${CHOST} == "-freebsd" ]] ; then
327	flameeyes	1.65	if [[ -z $(grep 'Handle Gentoo/FreeBSD as it was Linux' \
328			"${x}/configure" "${x}/../configure" 2>/dev/null) ]]; then
329	flameeyes	1.61	eerror " FreeBSD patch set '${y}' failed to apply!"
330			die "FreeBSD patch set '${y}' failed to apply!"
331			fi
332	azarah	1.60	fi
333			;;
334			"darwin-"*)
335			useq ppc-macos && \
336			ewarn " Darwin patch set '${y}' failed to apply!"
337	flameeyes	1.55	;;
338	flameeyes	1.69	"kde-fastinstall")
339			if [[ -n $(grep 'test "$mode" != relink && test "$fast_install" = no' ${x}/ltmain.sh) ]]; then
340			ewarn "Patch ${y} failed to apply. If you experience build failures, please report this."
341			fi
342			;;
343	azarah	1.3	esac
344	azarah	1.1	fi
345	azarah	1.52	done
346	azarah	1.11
347	azarah	1.52	if [[ -z ${ELT_APPLIED_PATCHES} ]] ; then
348			if [[ ${do_portage} == "no" && \
349			${do_reversedeps} == "no" && \
350			${do_only_patches} == "no" && \
351			${deptoremove} == "" ]]
352			then
353			ewarn "Cannot apply any patches, please file a bug about this"
354			break
355
356			# Sometimes ltmain.sh is in a subdirectory ...
357			if [[ ! -f ${x}/configure.in && ! -f ${x}/configure.ac ]] ; then
358			if [[ -f ${x}/../configure.in \|\| -f ${x}/../configure.ac ]] ; then
359			cd "${x}"/../
360	azarah	1.24	fi
361	azarah	1.52	fi
362	azarah	1.24
363	azarah	1.52	if type -p libtoolize &> /dev/null ; then
364			ewarn "Cannot apply any patches, running libtoolize..."
365			libtoolize --copy --force
366	azarah	1.19	fi
367	azarah	1.52	cd "${x}"
368			break
369	azarah	1.1	fi
370	azarah	1.52	fi
371
372			[[ -f ${x}/libtool ]] && rm -f "${x}/libtool"
373
374			touch "${x}/.elibtoolized"
375	azarah	1.1	done
376	azarah	1.6
377	vapier	1.29	cd "${start_dir}"
378	vapier	1.30	}
379
380			uclibctoolize() {
381	azarah	1.60	ewarn "uclibctoolize() is depreciated, please just use elibtoolize()!"
382	azarah	1.53	elibtoolize
383	azarah	1.1	}
384	usata	1.36
385			darwintoolize() {
386	azarah	1.60	ewarn "darwintoolize() is depreciated, please just use elibtoolize()!"
387			elibtoolize
388	usata	1.36	}
389	azarah	1.44
390			# char *VER_major(string)
391			#
392			# Return the Major (X of X.Y.Z) version
393			#
394			VER_major() {
395			[[ -z $1 ]] && return 1
396
397			local VER=$@
398	azarah	1.57	echo "${VER%%[^[:digit:]]*}"
399	azarah	1.44	}
400
401			# char *VER_minor(string)
402			#
403			# Return the Minor (Y of X.Y.Z) version
404			#
405			VER_minor() {
406			[[ -z $1 ]] && return 1
407
408			local VER=$@
409			VER=${VER#*.}
410	azarah	1.57	echo "${VER%%[^[:digit:]]*}"
411	azarah	1.44	}
412
413			# char *VER_micro(string)
414			#
415			# Return the Micro (Z of X.Y.Z) version.
416			#
417			VER_micro() {
418			[[ -z $1 ]] && return 1
419
420			local VER=$@
421			VER=${VER#..}
422	azarah	1.57	echo "${VER%%[^[:digit:]]*}"
423	azarah	1.44	}
424
425			# int VER_to_int(string)
426			#
427			# Convert a string type version (2.4.0) to an int (132096)
428			# for easy compairing or versions ...
429			#
430			VER_to_int() {
431			[[ -z $1 ]] && return 1
432
433			local VER_MAJOR=$(VER_major "$1")
434			local VER_MINOR=$(VER_minor "$1")
435			local VER_MICRO=$(VER_micro "$1")
436			local VER_int=$(( VER_MAJOR * 65536 + VER_MINOR * 256 + VER_MICRO ))
437
438			# We make version 1.0.0 the minimum version we will handle as
439			# a sanity check ... if its less, we fail ...
440			if [[ ${VER_int} -ge 65536 ]] ; then
441			echo "${VER_int}"
442			return 0
443			fi
444
445			echo 1
446			return 1
447			}