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.46 2005/05/11 15:15:03 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

ECLASS="libtool"
INHERITED="${INHERITED} ${ECLASS}"

# 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=

#
# 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=$(eval $(grep -e '^[[:space:]]*VERSION=' $1); \
                                        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"
        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
                glibtoolize --copy --force
                darwintoolize
        fi

        for x in ${my_dirlist} ; do
                local tmp=$(echo "${x}" | sed -e "s|${S}||")
                export ELT_APPLIED_PATCHES=

                cd ${x}
                einfo "Patching \${S}$(echo "/${tmp}/ltmain.sh" | sed -e 's|//|/|g') ..."

                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
                                        ;;
                                *)
                                        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
                                                ;;
                                esac
                        fi

                        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
                done
        done

        if [[ -f libtool ]] ; then
                rm -f libtool
        fi

        cd "${start_dir}"

        uclibctoolize
}

uclibctoolize() {
        [[ -n ${NO_UCLIBCTOOLIZE} ]] && return 0

        local errmsg=""
        [[ ${CTARGET:-${CHOST}} == *-uclibc ]] \
                && errmsg="PLEASE CHECK" \
                || errmsg="Already patched"
        local targets=""
        local x

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

        einfo "Applying uClibc/libtool patches ..."
        for x in ${targets} ; do
                [[ ! -s ${x} ]] && continue
                case ${x##*/} in
                configure)
                        if grep 'Transform linux' "${x}" > /dev/null ; then
                                ebegin " Fixing \${S}${x/${S}}"
                                patch -p0 "${x}" "${ELT_PATCH_DIR}/uclibc/configure.patch" > /dev/null
                                eend $? "${errmsg} ${x}"
                        fi
                        ;;

                ltconfig)
                        local ver=$(grep '^VERSION=' ${x})
                        ver=${ver/VERSION=}
                        [[ ${ver:0:3} == "1.4" ]] && ver="1.3"   # 1.4 and 1.3 are compat
                        ebegin " Fixing \${S}${x/${S}}"
                        patch -p0 "${x}" "${ELT_PATCH_DIR}/uclibc/ltconfig-${ver:0:3}.patch" > /dev/null
                        eend $? "${errmsg} ${x}"
                        ;;
                esac
        done
}

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