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.49 2005/07/06 20:23:20 agriffis 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=

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