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.51 2005/09/02 09:35:17 azarah 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="${PORTDIR}/eclass/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 patch="$2"

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

        return ${ret}
}

#
# Run through the patches in $2 and see if any
# apply to $1 ...
#
ELT_walk_patches() {
        local x=
        local y=
        local ret=1
        local patch_dir=
        local version=
        local ltmain_sh=$1
        
        [[ $1 == *"/configure" ]] && ltmain_sh=${ELT_LTMAIN_SH}
        version=$(eval $(grep -e '^[[:space:]]*VERSION=' "${ltmain_sh}"); \
                                        echo "${VERSION}")

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

                if [[ -z ${version} ]] ; then
                        eerror "Could not get VERSION for ${1##*/}!"
                        die "Could not get VERSION for ${1##*/}!"
                fi

                # Go through the patches in reverse order (large to small)
                for x in $(ls -d "${patch_dir}"/* 2> /dev/null | sort -r) ; do
                        if [[ -n ${x} && -f ${x} ]] ; then
                                local ltver=$(VER_to_int "${version}")
                                local ptver=$(VER_to_int "${x##*/}")

                                # If libtool version smaller than patch version, skip patch.
                                [[ ${ltver} -lt ${ptver} ]] && continue
                                # For --remove-internal-dep ...
                                if [[ -n $3 ]] ; then
                                        # For replace @REM_INT_DEP@ with what was passed
                                        # to --remove-internal-dep
                                        sed -e "s|@REM_INT_DEP@|$3|g" ${x} > \
                                                ${T}/$$.rem_int_deps.patch

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

                                if ELT_try_and_apply_patch "$1" "${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 deptoremove=
        local my_dirlist=
        local elt_patches="portage relink max_cmd_len sed test tmp \
                           uclibc-conf uclibc-ltconf"
        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")
                                NO_UCLIBCTOOLIZE=1
                                ;;
                        *)
                                eerror "Invalid elibtoolize option: $x"
                                die "elibtoolize called with $x ??"
                esac
        done

        if use ppc-macos ; then
                local opts
                [[ -f Makefile.am ]] && opts="--automake"
                glibtoolize --copy --force ${opts}
                darwintoolize
        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
                                "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 ]] && \
                                           grep 'Transform linux' "${x}/configure" > /dev/null ; then
                                                ELT_walk_patches "${x}/configure" "${y}"
                                                ret=$?
                                        # ltmain.sh and co might be in a subdirectory ...
                                        elif [[ ! -e ${x}/configure && -e ${x}/../configure ]] && \
                                           grep 'Transform linux' "${x}/../configure" > /dev/null ; then
                                                ELT_walk_patches "${x}/../configure" "${y}"
                                                ret=$?
                                        fi
                                        ;;
                                "uclibc-ltconf")
                                        if [[ -e ${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")
                                                # Critical patch, but could be applied ...
                                                if [[ -z $(grep 'inst_prefix_dir' "${x}/ltmain.sh") ]] ; 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!"
                                                                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})!"
                                                                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!"
                                                ;;
                                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 libtoolize()!"
        elibtoolize
}

darwintoolize() {
        local targets=""
        local x

        if [[ -z $* ]] ; then
                targets=$(find ${S} -name ltmain.sh -o -name ltconfig)
        fi

        einfo "Applying Darwin/libtool patches ..."
        for x in ${targets} ; do
                [[ ! -s ${x} ]] && continue
                case ${x##*/} in
                ltmain.sh|ltconfig)
                        local ver=$(grep '^VERSION=' ${x})
                        ver=${ver/VERSION=}
                        if [[ ${ver:0:3} == "1.4" || ${ver:0:3} == "1.5" ]] ; then
                                ver="1.3"   # 1.4, 1.5 and 1.3 are compat
                        fi

                        ebegin " Fixing \${S}${x/${S}}"
                        patch -p0 "${x}" "${ELT_PATCH_DIR}/darwin/${x##*/}-${ver:0:3}.patch" > /dev/null
                        eend $? "PLEASE CHECK ${x}"
                        ;;
                esac
        done
}

# 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	azarah	1.52	# $Header: /var/cvsroot/gentoo-x86/eclass/libtool.eclass,v 1.51 2005/09/02 09:35:17 azarah 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.24	ELT_PATCH_DIR="${PORTDIR}/eclass/ELT-patches"
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			local patch="$2"
47
48			# We only support patchlevel of 0 - why worry if its static patches?
49	vapier	1.42	if patch -p0 --dry-run $1 < ${patch} &> ${T}/elibtool.log ; then
50	vapier	1.37	einfo " Applying $(basename "$(dirname "${patch}")")-${patch##*/}.patch ..."
51	azarah	1.24	patch -p0 $1 < ${patch} &>${T}/elibtool.log
52			ret=$?
53			export ELT_APPLIED_PATCHES="${ELT_APPLIED_PATCHES} ${patch##*/}"
54			else
55			ret=1
56			fi
57
58			return ${ret}
59			}
60
61			#
62			# Run through the patches in $2 and see if any
63			# apply to $1 ...
64			#
65			ELT_walk_patches() {
66			local x=
67			local y=
68			local ret=1
69			local patch_dir=
70	azarah	1.53	local version=
71			local ltmain_sh=$1
72
73			[[ $1 == *"/configure" ]] && ltmain_sh=${ELT_LTMAIN_SH}
74			version=$(eval $(grep -e '^[[:space:]]*VERSION=' "${ltmain_sh}"); \
75	azarah	1.44	echo "${VERSION}")
76	azarah	1.2
77	vapier	1.42	if [[ -n $2 ]] ; then
78			if [[ -d ${ELT_PATCH_DIR}/$2 ]] ; then
79	azarah	1.24	patch_dir="${ELT_PATCH_DIR}/$2"
80			else
81			return ${ret}
82	azarah	1.4	fi
83	mr_bones_	1.27
84	azarah	1.44	if [[ -z ${version} ]] ; then
85			eerror "Could not get VERSION for ${1##*/}!"
86			die "Could not get VERSION for ${1##*/}!"
87			fi
88	mr_bones_	1.27
89	azarah	1.44	# Go through the patches in reverse order (large to small)
90			for x in $(ls -d "${patch_dir}"/* 2> /dev/null \| sort -r) ; do
91			if [[ -n ${x} && -f ${x} ]] ; then
92			local ltver=$(VER_to_int "${version}")
93			local ptver=$(VER_to_int "${x##*/}")
94	swegener	1.50
95	azarah	1.44	# If libtool version smaller than patch version, skip patch.
96			[[ ${ltver} -lt ${ptver} ]] && continue
97			# For --remove-internal-dep ...
98			if [[ -n $3 ]] ; then
99			# For replace @REM_INT_DEP@ with what was passed
100			# to --remove-internal-dep
101			sed -e "s\|@REM_INT_DEP@\|$3\|g" ${x} > \
102			${T}/$$.rem_int_deps.patch
103	azarah	1.43
104	azarah	1.44	x="${T}/$$.rem_int_deps.patch"
105	azarah	1.24	fi
106	azarah	1.43
107	azarah	1.44	if ELT_try_and_apply_patch "$1" "${x}" ; then
108			ret=0
109			break
110	azarah	1.24	fi
111	azarah	1.44	fi
112			done
113	azarah	1.24	fi
114
115			return ${ret}
116			}
117
118			elibtoolize() {
119			local x=
120			local y=
121			local do_portage="no"
122			local do_reversedeps="no"
123			local do_only_patches="no"
124			local deptoremove=
125			local my_dirlist=
126	azarah	1.53	local elt_patches="portage relink max_cmd_len sed test tmp \
127			uclibc-conf uclibc-ltconf"
128	vapier	1.29	local start_dir="${PWD}"
129	azarah	1.24
130			my_dirlist="$(ELT_find_ltmain_sh)"
131	mr_bones_	1.27
132	vapier	1.42	for x in "$@" ; do
133	azarah	1.24	case "${x}" in
134			"--portage")
135			# Only apply portage patch, and don't
136			# 'libtoolize --copy --force' if all patches fail.
137			do_portage="yes"
138			;;
139			"--reverse-deps")
140			# Apply the reverse-deps patch
141			# http://bugzilla.gnome.org/show_bug.cgi?id=75635
142			do_reversedeps="yes"
143			elt_patches="${elt_patches} fix-relink"
144			;;
145			"--patch-only")
146			# Do not run libtoolize if none of the patches apply ..
147			do_only_patches="yes"
148			;;
149			"^--remove-internal-dep="*)
150			# We will replace @REM_INT_DEP@ with what is needed
151			# in ELT_walk_patches() ...
152			deptoremove="$(echo "${x}" \| sed -e 's\|--remove-internal-dep=\|\|')"
153
154			# Add the patch for this ...
155			[ -n "${deptoremove}" ] && elt_patches="${elt_patches} rem-int-dep"
156			;;
157			"--shallow")
158			# Only patch the ltmain.sh in ${S}
159			if [ -f "${S}/ltmain.sh" ]
160			then
161			my_dirlist="${S}"
162			else
163			my_dirlist=
164			fi
165			;;
166	vapier	1.40	"--no-uclibc")
167			NO_UCLIBCTOOLIZE=1
168			;;
169	vapier	1.42	*)
170			eerror "Invalid elibtoolize option: $x"
171			die "elibtoolize called with $x ??"
172	azarah	1.24	esac
173	azarah	1.4	done
174	azarah	1.1
175	usata	1.36	if use ppc-macos ; then
176	azarah	1.51	local opts
177			[[ -f Makefile.am ]] && opts="--automake"
178			glibtoolize --copy --force ${opts}
179	usata	1.36	darwintoolize
180			fi
181
182	vapier	1.42	for x in ${my_dirlist} ; do
183	azarah	1.51	local tmp=$(echo "${x}" \| sed -e "s\|${WORKDIR}\|\|")
184	azarah	1.24	export ELT_APPLIED_PATCHES=
185	azarah	1.53	export ELT_LTMAIN_SH="${x}/ltmain.sh"
186	mr_bones_	1.27
187	azarah	1.52	[[ -f ${x}/.elibtoolized ]] && continue
188
189	azarah	1.1	cd ${x}
190	azarah	1.51	einfo "Running elibtoolize in: $(echo "/${tmp}" \| sed -e 's\|//\|/\|g; s\|^/\|\|')"
191	azarah	1.2
192	vapier	1.42	for y in ${elt_patches} ; do
193	azarah	1.24	local ret=0
194
195			case "${y}" in
196			"rem-int-dep")
197			ELT_walk_patches "${x}/ltmain.sh" "${y}" "${deptoremove}"
198			ret=$?
199			;;
200			"fix-relink")
201			# Do not apply if we do not have the relink patch applied ...
202	vapier	1.42	if [[ -n $(grep 'inst_prefix_dir' "${x}/ltmain.sh") ]] ; then
203	azarah	1.24	ELT_walk_patches "${x}/ltmain.sh" "${y}"
204			ret=$?
205			fi
206			;;
207	azarah	1.25	"max_cmd_len")
208			# Do not apply if $max_cmd_len is not used ...
209	vapier	1.42	if [[ -n $(grep 'max_cmd_len' "${x}/ltmain.sh") ]] ; then
210	azarah	1.25	ELT_walk_patches "${x}/ltmain.sh" "${y}"
211			ret=$?
212			fi
213			;;
214	azarah	1.53	"uclibc-conf")
215			if [[ -e ${x}/configure ]] && \
216			grep 'Transform linux' "${x}/configure" > /dev/null ; then
217			ELT_walk_patches "${x}/configure" "${y}"
218			ret=$?
219			# ltmain.sh and co might be in a subdirectory ...
220			elif [[ ! -e ${x}/configure && -e ${x}/../configure ]] && \
221			grep 'Transform linux' "${x}/../configure" > /dev/null ; then
222			ELT_walk_patches "${x}/../configure" "${y}"
223			ret=$?
224			fi
225			;;
226			"uclibc-ltconf")
227			if [[ -e ${x}/ltconfig ]] ; then
228			ELT_walk_patches "${x}/ltconfig" "${y}"
229			ret=$?
230			fi
231			;;
232	azarah	1.24	*)
233			ELT_walk_patches "${x}/ltmain.sh" "${y}"
234			ret=$?
235			;;
236			esac
237	mr_bones_	1.27
238	vapier	1.42	if [[ ${ret} -ne 0 ]] ; then
239	azarah	1.3	case ${y} in
240	azarah	1.24	"relink")
241			# Critical patch, but could be applied ...
242	vapier	1.42	if [[ -z $(grep 'inst_prefix_dir' "${x}/ltmain.sh") ]] ; then
243	azarah	1.24	ewarn " Could not apply relink.patch!"
244			fi
245			;;
246			"portage")
247			# Critical patch - for this one we abort, as it can really
248			# cause breakage without it applied!
249	vapier	1.42	if [[ ${do_portage} == "yes" ]] ; then
250	azarah	1.24	# Stupid test to see if its already applied ...
251	vapier	1.42	if [[ -z $(grep 'We do not want portage' "${x}/ltmain.sh") ]] ; then
252	azarah	1.24	echo
253			eerror "Portage patch requested, but failed to apply!"
254			die "Portage patch requested, but failed to apply!"
255			fi
256			else
257	azarah	1.45	if [[ -n $(grep 'We do not want portage' "${x}/ltmain.sh") ]] ; then
258	azarah	1.51	# ewarn " Portage patch seems to be already applied."
259			# ewarn " Please verify that it is not needed."
260			:
261	azarah	1.45	else
262	azarah	1.46	local version=$( \
263			eval $(grep -e '^[[:space:]]*VERSION=' "${x}/ltmain.sh"); \
264			echo "${VERSION}")
265
266	azarah	1.45	echo
267	azarah	1.46	eerror "Portage patch failed to apply (ltmain.sh version ${version})!"
268	azarah	1.45	die "Portage patch failed to apply!"
269			fi
270			# We do not want to run libtoolize ...
271			ELT_APPLIED_PATCHES="portage"
272	azarah	1.3	fi
273			;;
274	azarah	1.53	"uclibc-"*)
275			[[ ${CHOST} == *"-uclibc" ]] && \
276			ewarn " uClibc patch set '${y}' failed to apply!"
277			;;
278	azarah	1.3	esac
279	azarah	1.1	fi
280	azarah	1.52	done
281	azarah	1.11
282	azarah	1.52	if [[ -z ${ELT_APPLIED_PATCHES} ]] ; then
283			if [[ ${do_portage} == "no" && \
284			${do_reversedeps} == "no" && \
285			${do_only_patches} == "no" && \
286			${deptoremove} == "" ]]
287			then
288			ewarn "Cannot apply any patches, please file a bug about this"
289			break
290
291			# Sometimes ltmain.sh is in a subdirectory ...
292			if [[ ! -f ${x}/configure.in && ! -f ${x}/configure.ac ]] ; then
293			if [[ -f ${x}/../configure.in \|\| -f ${x}/../configure.ac ]] ; then
294			cd "${x}"/../
295	azarah	1.24	fi
296	azarah	1.52	fi
297	azarah	1.24
298	azarah	1.52	if type -p libtoolize &> /dev/null ; then
299			ewarn "Cannot apply any patches, running libtoolize..."
300			libtoolize --copy --force
301	azarah	1.19	fi
302	azarah	1.52	cd "${x}"
303			break
304	azarah	1.1	fi
305	azarah	1.52	fi
306
307			[[ -f ${x}/libtool ]] && rm -f "${x}/libtool"
308
309			touch "${x}/.elibtoolized"
310	azarah	1.1	done
311	azarah	1.6
312	vapier	1.29	cd "${start_dir}"
313	vapier	1.30	}
314
315			uclibctoolize() {
316	azarah	1.53	ewarn "uclibctoolize() is depreciated, please just use libtoolize()!"
317			elibtoolize
318	azarah	1.1	}
319	usata	1.36
320			darwintoolize() {
321			local targets=""
322			local x
323
324	vapier	1.42	if [[ -z $* ]] ; then
325			targets=$(find ${S} -name ltmain.sh -o -name ltconfig)
326	usata	1.36	fi
327
328			einfo "Applying Darwin/libtool patches ..."
329			for x in ${targets} ; do
330	vapier	1.42	[[ ! -s ${x} ]] && continue
331			case ${x##*/} in
332	usata	1.36	ltmain.sh\|ltconfig)
333	vapier	1.42	local ver=$(grep '^VERSION=' ${x})
334			ver=${ver/VERSION=}
335			if [[ ${ver:0:3} == "1.4" \|\| ${ver:0:3} == "1.5" ]] ; then
336	usata	1.36	ver="1.3" # 1.4, 1.5 and 1.3 are compat
337			fi
338
339			ebegin " Fixing \${S}${x/${S}}"
340	vapier	1.42	patch -p0 "${x}" "${ELT_PATCH_DIR}/darwin/${x##*/}-${ver:0:3}.patch" > /dev/null
341	usata	1.36	eend $? "PLEASE CHECK ${x}"
342			;;
343			esac
344			done
345			}
346	azarah	1.44
347			# char *VER_major(string)
348			#
349			# Return the Major (X of X.Y.Z) version
350			#
351			VER_major() {
352			[[ -z $1 ]] && return 1
353
354			local VER=$@
355			echo ${VER%%[^[:digit:]]*}
356			}
357
358			# char *VER_minor(string)
359			#
360			# Return the Minor (Y of X.Y.Z) version
361			#
362			VER_minor() {
363			[[ -z $1 ]] && return 1
364
365			local VER=$@
366			VER=${VER#*.}
367			echo ${VER%%[^[:digit:]]*}
368			}
369
370			# char *VER_micro(string)
371			#
372			# Return the Micro (Z of X.Y.Z) version.
373			#
374			VER_micro() {
375			[[ -z $1 ]] && return 1
376
377			local VER=$@
378			VER=${VER#..}
379			echo ${VER%%[^[:digit:]]*}
380			}
381
382			# int VER_to_int(string)
383			#
384			# Convert a string type version (2.4.0) to an int (132096)
385			# for easy compairing or versions ...
386			#
387			VER_to_int() {
388			[[ -z $1 ]] && return 1
389
390			local VER_MAJOR=$(VER_major "$1")
391			local VER_MINOR=$(VER_minor "$1")
392			local VER_MICRO=$(VER_micro "$1")
393			local VER_int=$(( VER_MAJOR * 65536 + VER_MINOR * 256 + VER_MICRO ))
394
395			# We make version 1.0.0 the minimum version we will handle as
396			# a sanity check ... if its less, we fail ...
397			if [[ ${VER_int} -ge 65536 ]] ; then
398			echo "${VER_int}"
399			return 0
400			fi
401
402			echo 1
403			return 1
404			}