ohnobinki_overlay Changeset - 9b3f094be47a

Changeset - 9b3f094be47a

Parent rev.

Child rev.

[Not reviewed]

default

0 0 7

Nathan Brink (binki) - 15 years ago 2011-01-11 14:14:06
ohnobinki@ohnopublishing.net

sys-devel/gcc-config: Import gcc-config-1.4.1 and gcc-config-1.5 for fixing bug 351384.

(Portage version: 2.2.0_alpha11-r1/hg/Linux x86_64, RepoMan options: --force, signed Manifest commit with key 6BA81050)

7 files changed with 2049 insertions and 0 deletions:

sys-devel/gcc-config/Manifest

sys-devel/gcc-config/files/gcc-config-1.4.1

801

sys-devel/gcc-config/files/gcc-config-1.5

725

sys-devel/gcc-config/files/wrapper-1.5.1.c

372

sys-devel/gcc-config/gcc-config-1.4.1.ebuild

sys-devel/gcc-config/gcc-config-1.5.ebuild

sys-devel/gcc-config/metadata.xml

0 comments (0 inline, 0 general)

sys-devel/gcc-config/Manifest

➞

Show inline comments

@@ new file 100644 @@
 -----BEGIN PGP SIGNED MESSAGE-----
 Hash: SHA256
 AUX gcc-config-1.4.1 21711 RMD160 3879aab908d8aad237e8740e4ec63134453de623 SHA1 3ee0e58a1be0b75e03c4a153ede9350b4ba13859 SHA256 3050608f6cedb3c5d2b59f5dd3fd74411fd6398b5d89c4df4410d3d3e0f115dc
 AUX gcc-config-1.5 19397 RMD160 262d92b5466d0b70a6d0f17d47c3080ec2bb57e0 SHA1 89c532b361a083f45b5bfd505c9187ae5ae1fffd SHA256 f908c572da16959caefbe3e411845820180dcba34040584f49098939611d480b
 AUX wrapper-1.5.1.c 9788 RMD160 b628944ee01dd772eb917cd08d13dc41bf58409f SHA1 51ac1f9419bc2230a9ce2196e70b5ee4ba61be18 SHA256 991981059fdcd0a9c76d73ff2ce576e553f37ae7d3b378b92ead553963f7339a
 EBUILD gcc-config-1.4.1.ebuild 1642 RMD160 b6af302e3654e7dbf5aa808e0c037c66df810ae8 SHA1 b5853c35cf17285d852ef424f12bb1eb0f1b19ab SHA256 5ad070e899901f17a57a515829d83a243ae79ffe5dbe46999328139e13cc9d23
 EBUILD gcc-config-1.5.ebuild 1643 RMD160 e67c71ef5b9824e7d1394dad39a09312992e19e8 SHA1 051ff48881a19aec0b635ec4413c89116e4cb8c0 SHA256 4972b0ce2511fe468e0772801214c3e90c2b53bc54b42dda119a666f285875ae
 MISC metadata.xml 162 RMD160 d002486a43522f2116b1d9d59828c484956d66e2 SHA1 d6b4923897f6ae673b4f93646f5b4ba61d5a2c3c SHA256 65a915d44de1f01d4b7f72d313b4192c38374a9835d24988c00c1e73dca5805a
 -----BEGIN PGP SIGNATURE-----
 Version: GnuPG v2.0.14 (GNU/Linux)
 iQIcBAEBCAAGBQJNLKv9AAoJEHQ6UuhrqBBQfmgP/A9eeYn7JjPobjPug8PAvIc0
 pocNFMiu+EHhPFJvKFAXUe0Hjwn+LJ/OrCgnSMvdRiKdrkowqIXSVDQdSK1mu3C9
 Lw40xMX0ntnTTGwRe3Dt45UJ14ddhLFhkqx01qyKDeanVdRFe5f5ipp6OVopvjZ9
 FR5JlQk2+f5KiUBfPFArFtgSP6Fl18gm3BclaN2qLSBONAK0b2OOoFn8SseZnYjY
 EO4SITB1kivyATsbjB1E61FlvYnAmpMw4zO5tT6r1U+vu3bnmSqLWaKASp3n+Esl
 ri3OEyH35FhVwrjnPqvn+T+BxzChKCa2uHm5oE/y1d3OxAoW2pNBlWa/XuVThTEZ
 gM1HPlbRo1zmEVnEXR6wSFrW9G1o5ygkSkgNTpuxOOKpgsap5MH5nMPosbuNMYN
 NhzgUSqmhYRQeUnwi0ltYAYw8wA9vGAae7EdtzwmEqkuOrojlRJwKZV5t9BaHTqY
 m/f6Kimn4udiN6+HCm3CWw5XUpunTlOga4F/HMe/wn60EnFR782IHOvCLvkVSuXT
 GVotWt+/nq+LAUZ+Svsc6eMkoyPHm2cDn3MsFkIagS+7TP8TPpVDHcuxfxsMDe9e
 STxLupwKzzAnezhQ54qzH/CZahJ6vwvL71i+ePu6q9139iClxIBpGjBwOXDMME6o
 MmnRtpjOsYv4Q1s0ED4X
 =BnU4
 -----END PGP SIGNATURE-----

sys-devel/gcc-config/files/gcc-config-1.4.1

➞

Show inline comments

@@ new file 100644 @@
 #!/bin/bash
 # Copyright 1999-2009 Gentoo Foundation
 # Distributed under the terms of the GNU General Public License v2
 # $Header: /var/cvsroot/gentoo-x86/sys-devel/gcc-config/files/gcc-config-1.4.1,v 1.10 2009/12/27 16:03:52 grobian Exp $
 trap ":" INT QUIT TSTP
 argv0=${0##*/}
 source /etc/init.d/functions.sh || {
 	echo "${argv0}: Could not source /etc/init.d/functions.sh!"
 	exit 1
+}
 esyslog() { :; }
 umask 022
 # *BSD are plain stupid ... copy a GNU extension but don't just copy it,
 # change it so it works differently.  Wish Darwin did selective evolution
 # on software developers.
 SED=$(type -P gsed)
 SED=${SED:-$(type -P sed)}
 GENTOO_LIBDIR="lib"
 [[ ${GENTOO_LIBDIR} == @*@ ]] && GENTOO_LIBDIR="lib"
 usage() {
 cat << "USAGE_END"
 Usage: gcc-config [options] [CC Profile]
 Change the current cc/gcc profile, or give info about profiles.
 Options:
   -C, --nocolor              Disable color output
   -O, --use-old              Use the old profile if one was selected.
   -f, --force                Make sure all config files are regenerated.
   -P, --use-portage-chost    Only set to given profile if its CHOST is the
                              same as that set for portage in /etc/make.conf
                              (or one of other portage config files...).
   -c, --get-current-profile  Print current used gcc profile.
   -l, --list-profiles        Print a list of available profiles.
   -S, --split-profile        Split profiles into their components
   -E, --print-environ        Print environment that can be used to setup the
                              current gcc profile, or a specified one.
   -B, --get-bin-path         Print path where binaries of the given/current
                              profile are located.
   -L, --get-lib-path         Print path where libraries of the given/current
                              profile are located.
   -X, --get-stdcxx-incdir    Print path where g++ include files of the
                              given/current profile are located.
 Profile names are of the form:  <CHOST>-<gcc version>
 For example:                    i686-pc-linux-gnu-3.2.1
 USAGE_END
 	exit $1
+}
 [[ $# -lt 1 ]] && usage 1
 try_real_hard_to_find_CHOST() {
+	#
 	# First we read make.conf
+	#
 	local varname=${1:-CHOST}
 	local conf=${ROOT}/etc/make.conf
 	local ret=$(source "${conf}" 2>/dev/null ; echo ${!varname})
 	if [[ -z ${ret} ]] ; then
 		# newer portage supports spaces between the var and =
 		# CHOST     =  "this-is-retarded"
 		ret=$(eval $(
 			sed -n \
 				-e 's:[[:space:]]::g' \
 				-e "/^${varname}=/p" \
 				"${conf}"
 			) ; echo ${!varname}
+		)
 	fi
 	if [[ -n ${ret} ]] ; then
 		echo ${ret}
 		return 0
 	fi
+	#
 	# Then we try /etc/env.d/gcc/config-${CTARGET}
+	#
 	if [[ -s ${ROOT}/etc/env.d/gcc/config-${CTARGET} ]] ; then
 		ret=$(split_gcc_ver $(eval $(<"${ROOT}"/etc/env.d/gcc/config-${CTARGET}) ; echo ${CURRENT}))
 		echo ${ret% *}
 	fi
+}
 get_real_chost() {
 	[[ -n ${REAL_CHOST} ]] && return 0
 	# shortcut for switching compilers in a cross chroot
 	if [[ -n ${CHOST} && ${ROOT} != "/" ]] ; then
 		REAL_CHOST=${CHOST}
 		return 0
 	fi
 	# make sure portage isnt broken
 	if python -V &>/dev/null ; then
 		export REAL_CHOST=$(env -i portageq envvar CHOST 2>/dev/null)
 	else
 		ewarn "Python seems to be broken, attempting to locate CHOST ourselves ..."
 		export REAL_CHOST=$(try_real_hard_to_find_CHOST)
 	fi
 	if [[ -z ${REAL_CHOST} ]] ; then
 		eerror "${argv0}: Could not get portage CHOST!"
 		eerror "${argv0}: You should verify that CHOST is set in one of these places:"
 		eerror "${argv0}:  - ${ROOT}/etc/make.conf"
 		eerror "${argv0}:  - active environment"
 		exit 1
 	fi
+}
 is_cross_compiler() {
 	get_real_chost
 	[[ ${CC_COMP/${REAL_CHOST}} == ${CC_COMP} ]]
+}
 # bool files_exists(search_path, files)
 #	Return shell true if the specified files exist.
 #	Files with relative paths are searched for in search_path.
 #	Both lists are : delimited.
 files_exist() {
 	local p f ret old_IFS
 	local paths=$1 files=$2
 	old_IFS=${IFS}
 	export IFS=":"
 	ret=0
 	for f in ${files} ; do
 		if [[ ${f} == /* ]] ; then
 			[[ ! -f ${f} ]] && ret=1 && break
 		else
 			# make sure the file exists in at least
 			# one of the specified paths
 			ret=1
 			for p in ${paths} ; do
 				[[ -f ${p}/${f} ]] && ret=0 && break
 			done
 			[[ ${ret} == 1 ]] && break
 		fi
 	done
 	export IFS=${old_IFS}
 	if [[ ${ret} == 1 ]] ; then
 		ewarn "Could not locate '${f}' in '${paths}'"
 	fi
 	return ${ret}
+}
 switch_profile() {
 	local MY_LDPATH=
 	local GCC_PROFILES=
 	local OLD_CC_COMP=
 	local GCC_PATH=
 	if [[ $(id -u) != "0" ]] ; then
 		eerror "${argv0}: Must be root."
 		exit 1
 	fi
 	if is_cross_compiler ; then
 		ebegin "Switching cross-compiler to ${CC_COMP}"
 	else
 		ebegin "Switching native-compiler to ${CC_COMP}"
 	fi
 	if ! is_cross_compiler ; then
 		# Order our profiles to have the default first ...
 		# We do this so that we can have them ordered with default
 		# first in /etc/ld.so.conf, as the logical is that all
 		# compilers for default CHOST will be used to compile stuff,
 		# and thus we want all their lib paths in /etc/ld.so.conf ...
 		get_real_chost
 		GCC_PROFILES=$(LC_ALL="C" ls -r ${GCC_ENV_D}/${REAL_CHOST}-*)
 		GCC_PROFILES="${GCC_ENV_D}/${CC_COMP} ${GCC_PROFILES}"
 		# Extract all LDPATH's for our CHOST
 		MY_LDPATH=""
 		for x in ${GCC_PROFILES} ; do
 			if [[ -f ${x} ]] ; then
 				LDPATH=$(source "${x}"; echo ${LDPATH})
 				# Handle LDPATH's that have multiple directories
 				local old_IFS=${IFS}
 				export IFS=":"
 				local sub_ldpath=
 				for sub_ldpath in ${LDPATH} ; do
 					if [[ -d ${sub_ldpath} ]] ; then
 						if [[ ${MY_LDPATH/:${sub_ldpath}} == ${MY_LDPATH} ]] ; then
 							MY_LDPATH="${MY_LDPATH}:${sub_ldpath}"
 						fi
 					fi
 				done
 				export IFS=${old_IFS}
 			fi
 		done
 		MY_LDPATH="${MY_LDPATH:1}" # trim leading :
 	fi
 	# Translate old PATH/ROOTPATH to GCC_PATH
 	cp -p "${GCC_ENV_D}/${CC_COMP}" "${GCC_ENV_D}/${CC_COMP}.gcc-config-ref" || return 1
 	GCC_PATH=$(
 		unset GCC_PATH PATH ROOTPATH
 		source "${GCC_ENV_D}/${CC_COMP}"
 		echo ${GCC_PATH:-${PATH:-${ROOTPATH}}}
+	)
 	${SED} -i \
 		-e '/^PATH=/d' \
 		-e '/^ROOTPATH=/d' \
 		-e '/^GCC_PATH=/d' \
 		"${GCC_ENV_D}/${CC_COMP}" || return 1
 	echo "GCC_PATH=\"${GCC_PATH}\"" >> "${GCC_ENV_D}/${CC_COMP}" || return 1
 	touch -r "${GCC_ENV_D}/${CC_COMP}.gcc-config-ref" "${GCC_ENV_D}/${CC_COMP}" || return 1
 	rm -f "${GCC_ENV_D}/${CC_COMP}.gcc-config-ref" || return 1
 	# Setup things properly again for this profile
 	unset GCC_SPECS LDPATH
 	source "${GCC_ENV_D}/${CC_COMP}"
 	OLD_CC_COMP=$(get_current_profile)
 	# What kind of env.d entry are we going to generate ?
 	if is_cross_compiler ; then
 		echo "PATH=\"${GCC_PATH}\"" > "${ENV_D}/05gcc-${CTARGET}"
 		echo "ROOTPATH=\"${GCC_PATH}\"" >> "${ENV_D}/05gcc-${CTARGET}"
 		echo "CURRENT=${CC_COMP}" > "${GCC_ENV_D}/config-${CTARGET}"
 	else
 		# Pass all by default
 		awk '!/^(STDCXX_INCDIR|LDPATH|CC|CXX|CTARGET|GCCBITS|GCC_SPECS|GCC_PATH)=/ {print $0}' \
 			"${GCC_ENV_D}/${CC_COMP}" > "${ENV_D}/05gcc-${CTARGET}"
 		echo "LDPATH=\"${MY_LDPATH}\"" >> "${ENV_D}/05gcc-${CTARGET}"
 		echo "PATH=\"${GCC_PATH}\"" >> "${ENV_D}/05gcc-${CTARGET}"
 		echo "ROOTPATH=\"${GCC_PATH}\"" >> "${ENV_D}/05gcc-${CTARGET}"
 		if [[ -n ${GCC_SPECS} ]] ; then
 			if files_exist ${MY_LDPATH} ${GCC_SPECS} ; then
 				echo "GCC_SPECS=\"${GCC_SPECS}\"" >> "${ENV_D}/05gcc-${CTARGET}"
 			else
 				echo
 				ewarn "Your GCC spec configurations are broken."
 				ewarn "Please re-emerge gcc."
 				echo
 			fi
 		else
 			# People need to rebuild their gcc or setting GCC_SPECS to
 			# "" will cause issues again :(
 			if [[ ${ROOT} != "/" ]] ; then
 				echo "GCC_SPECS=\"\"" >> "${ENV_D}/05gcc-${CTARGET}"
 			else
 				if ! GCC_SPECS="" /usr/bin/gcc -v &>/dev/null ; then
 					echo
 					ewarn "Your gcc has a bug with GCC_SPECS."
 					ewarn "Please re-emerge gcc."
 					ewarn "http://bugs.gentoo.org/68395"
 					echo
 				else
 					echo "GCC_SPECS=\"\"" >> "${ENV_D}/05gcc-${CTARGET}"
 				fi
 			fi
 		fi
 		echo "CURRENT=${CC_COMP}" > "${GCC_ENV_D}/config-${CTARGET}"
 		# Help out the gcc wrapper
 		rm -f "${GCC_ENV_D}/NATIVE" "${GCC_ENV_D}/.NATIVE"
 		ln -sf ${CC_COMP} "${GCC_ENV_D}/.NATIVE"
 		# Punt old files
 		rm -f "${ENV_D}/05gcc"
 		rm -f "${ENV_D}/05gcc-${CTARGET}"-*
 		rm -f "${GCC_ENV_D}/config"
 		rm -f "${GCC_ENV_D}/config-${CTARGET}"-*
 	fi
 	# Find the bin wrapper
 	local wrapper
 	for wrapper in ${GENTOO_LIBDIR} lib lib64 lib32 lib ; do
 		wrapper="${ROOT}usr/${wrapper}/misc/gcc-config"
 		[[ -e ${wrapper} ]] && break
 	done
 	# Update the wrappers for this profile
 	for x in {,${CTARGET}-}{cpp,cc,gcc,c++,g++,f77,g77,gcj,gcjh,gcov,gdc,gdmd,gfortran} ; do
 		# Obviously don't want to touch native stuff for cross-compilers
 		[[ ${x} != ${CTARGET}-* ]] && is_cross_compiler && continue
 		# Make sure we have no stale wrappers
 		rm -f "${ROOT}/usr/bin/${x}"
 		[[ ${x:${#x}-3} == "gcc" || ${x:${#x}-3} == "g++" ]] \
 			&& rm -f "${ROOT}/usr/bin/${x}"{32,64}
 		# Only install a wrapper if the binary exists ...
 		# We want to figure out the 'reference file' for each
 		# wrapper (the binary we're 'wrapping') so that we can
 		# sync mtimes together.  This makes things like ccache
 		# happy.  See Bug #70548 for more info.
 		local ref
 		case ${x} in
 			cc)  ref=${ROOT}/${GCC_PATH}/gcc;;
 			f77) ref=${ROOT}/${GCC_PATH}/g77;;
 			*)   ref=${ROOT}/${GCC_PATH}/${x};;
 		esac
 		if [[ -x ${ref} ]] ; then
 			cp -f "${wrapper}" "${ROOT}/usr/bin/${x}"
 			touch -r "${ref}" "${ROOT}/usr/bin/${x}"
 			# Install 32bit and 64bit wrappers if need be
 			# This should probably get folded back into the wrapper ...
 			if [[ ${x:${#x}-3} == "gcc" ]] || [[ ${x:${#x}-3} == "g++" ]] ; then
 				for bits in ${GCCBITS} ; do
 					cp -f "${wrapper}" "${ROOT}/usr/bin/${x}${bits}"
 				done
 			fi
 		fi
 	done
 	# legacy cruft, make sure we dont leave it laying around #143205
 	rm -f "${ROOT}/usr/bin/${CTARGET}-cc"
 	# Only install cpp if switching to a native one
 	if ! is_cross_compiler && [[ ${CTARGET} != *-solaris* ]] ; then
 		rm -f "${ROOT}/lib/cpp"
 		cp -f "${wrapper}" "${ROOT}/lib/cpp"
 	fi
 	# Relocate random crap
 	if ! is_cross_compiler ; then
 		if [[ -e ${ROOT}/usr/${GENTOO_LIBDIR}/pkgconfig/libgcj-${CC_COMP_VERSION}.pc ]] ; then
 			local mver=${CC_COMP_VERSION:0:3}
 			for x in "" "-${mver}" ; do
 				x="${ROOT}/usr/lib/pkgconfig/libgcj${x}.pc"
 				rm -f "${x}"
 				ln -s libgcj-${CC_COMP_VERSION}.pc "${x}"
 			done
 		fi
 	fi
 	# We need to make sure that libgcc_s.so / libunwind.so make it into /lib.
 	# On many systems (x86/amd64/etc...), this will probably never matter,
 	# but on other systems (arm/mips/etc...), this is quite critical.
 	# http://bugs.gentoo.org/60190
+	#
 	# The funky move magic is required for proper updating of in-use files.
 	if ! is_cross_compiler ; then
 		# Need to cut out extra paths in multilib case and pray the first path
 		# is the "root" multilib path ... maybe some day change this to use
 		# `gcc -print-file-name` ...
 		LDPATH=${LDPATH%%:*}
 		for multilib in $("${ROOT}/${GCC_PATH}"/gcc -print-multi-lib); do
 			multiarg=${multilib#*;}
 			multiarg=${multiarg/@/-}
 			multilibdir=${multilib%;*}
 			libdir="lib/"$("${ROOT}/${GCC_PATH}"/gcc ${multiarg} -print-multi-os-directory)
 			if mkdir -p "${ROOT}/${libdir}"/.gcc.config.new ; then
 				for gcclib in gcc_s unwind ; do
 					if [[ -n $(ls "${ROOT}/${LDPATH}/${multilibdir}"/lib${gcclib}.so.* 2>/dev/null) ]]; then
 						cp -pP "${ROOT}/${LDPATH}/${multilibdir}"/lib${gcclib}.so.* "${ROOT}/${libdir}"/.gcc.config.new/
 						# no need to sanity remove this as the `mv` should take
 						# care of it.  we also need this step to be completly atomic
 						# for systems that have even `mv` linked against libgcc_s.so.
 						# http://bugs.gentoo.org/150257
 						#rm -f "${ROOT}/${libdir}"/lib${gcclib}.so*
 						mv -f "${ROOT}/${libdir}"/.gcc.config.new/* "${ROOT}/${libdir}"/
 					fi
 				done
 				rmdir "${ROOT}/${libdir}"/.gcc.config.new
 			fi
 		done
 		unset multilib
 		unset multilibdir
 		unset multiarg
 		unset libdir
 	fi
 	if [[ ${ROOT} == "/" ]] && [[ ${OLD_CC_COMP} != ${CC_COMP} || ${FORCE} == "yes" ]] ; then
 		# in case python is broken ...
 		if ! env-update ; then
 			echo ""
 			ewarn "env-update failed to work properly; making sure ld.so.conf paths"
 			ewarn "are setup properly.  Please rerun gcc-config with the -f option."
 			echo ""
 			grep -h ^LDPATH= "${ROOT}"/etc/env.d/05gcc-${CTARGET} \
 				| sed -e 's:^LDPATH=::' -e 's:"::g' -e 's|:|\n|g' \
 				>> /etc/ld.so.conf
 			ldconfig
 		fi
 	fi
 	eend 0
 	if [[ ${ROOT} == "/" ]] && [[ ${OLD_CC_COMP} != ${CC_COMP} ]] ; then
 		echo
 		ewarn "If you intend to use the gcc from the new profile in an already"
 		ewarn "running shell, please remember to do:"
 		echo
 		ewarn "  # source /etc/profile"
 		echo
 	fi
 	return 0
+}
 get_current_profile() {
 	local conf="${GCC_ENV_D}/config"
 	if [[ ! -f ${conf} ]] ; then
 		conf="${GCC_ENV_D}/config-${CTARGET}"
 	elif [[ -n ${CC_COMP} ]] && is_cross_compiler ; then
 		conf="${conf}-${CC_COMP}"
 	fi
 	if [[ ! -f ${conf} ]] ; then
 		eerror "${argv0}: No gcc profile is active!"
 		return 1
 	fi
 	CURRENT=$(source "${conf}"; echo ${CURRENT})
 	if [[ -z ${CURRENT} ]] ; then
 		eerror "${argv0}: No gcc profile is active!"
 		return 1
 	elif [[ ! -f ${GCC_ENV_D}/${CURRENT} ]] ; then
 		eerror "${argv0}: Active gcc profile is invalid!"
 		return 1
 	fi
 	echo "${CURRENT}"
 	return 0
+}
 list_profiles() {
 	local i=0
 	local filter=
 	if [[ ${ROOT} != "/" ]] ; then
 		echo "Using gcc-config info in ${ROOT}"
 	fi
 	if [[ ! -f ${GCC_ENV_D}/config-${CTARGET} ]] ; then
 		if ! is_cross_compiler && [[ -e ${GCC_ENV_D}/config ]] ; then
 			[[ -w ${GCC_ENV_D}/config ]] && mv ${GCC_ENV_D}/config ${GCC_ENV_D}/config-${CTARGET}
 		else
 			eerror "${argv0}: No gcc profile is active; please select one!"
 			filter=${CTARGET}
 		fi
 	fi
 	eval $(grep -s ^CURRENT= "${GCC_ENV_D}"/config-${CTARGET})
 	CURRENT_NATIVE=${CURRENT}
 	local target=
 	for x in "${GCC_ENV_D}"/* ; do
 		if [[ -f ${x} ]] && [[ ${x/\/config} == ${x} ]] ; then
 			CTARGET=$(unset CTARGET; source "${x}"; echo ${CTARGET})
 			((++i))
 			[[ -n ${filter} ]] && [[ ${filter} != ${CTARGET:-${REAL_CHOST}} ]] && continue
 			if [[ ${target} != ${CTARGET} ]] ; then
 				[[ -n ${target} ]] && echo
 				target=${CTARGET}
 				CTARGET=""
 			fi
 			x=${x##*/}
 			if [[ ${x} == ${CURRENT_NATIVE} ]] ; then
 				x="${x} ${GOOD}*${NORMAL}"
 			elif [[ -e ${GCC_ENV_D}/config-${target} ]] ; then
 				source "${GCC_ENV_D}/config-${target}"
 				[[ ${x} == ${CURRENT} ]] && x="${x} ${HILITE}*${NORMAL}"
 			fi
 			echo " [${i}] ${x}"
 		fi
 	done
+}
 print_environ() {
 	local GCC_PATH=
 	local ENV_CMD=
 	local SET_ELEMENT=
 	GCC_PATH=$(source "${GCC_ENV_D}/${CC_COMP}"; echo ${GCC_PATH:-${PATH}})
 	case ${SHELL} in
 		*/csh|*/tcsh)
 			ENV_CMD="setenv"
 			SET_ELEMENT=" "
 			;;
 		*)
 			ENV_CMD="export"
 			SET_ELEMENT="="
 			;;
 	esac
+	(
 	PATH=${GCC_PATH}:${PATH}
 	for var in PATH GCC_SPECS ; do
 		echo "${ENV_CMD} ${var}${SET_ELEMENT}\"${!var}\""
 	done
+	)
+}
 get_bin_path() {
 	if [[ -e ${GCC_ENV_D}/${CC_COMP} ]] ; then
+		(
 			unset PATH GCC_PATH
 			source "${GCC_ENV_D}/${CC_COMP}"
 			echo "${GCC_PATH:-${PATH}}"
+		)
 	else
 		echo "no-config"
 		echo "${GCC_ENV_D}/${CC_COMP} doesnt exist" 1>&2
 	fi
 	return 0
+}
 get_lib_path() {
 	if [[ -e ${GCC_ENV_D}/${CC_COMP} ]] ; then
+		(
 			unset LDPATH
 			source "${GCC_ENV_D}/${CC_COMP}"
 			echo "${LDPATH}"
+		)
 	else
 		echo "no-config"
 		echo "${GCC_ENV_D}/${CC_COMP} doesnt exist" 1>&2
 	fi
 	return 0
+}
 get_stdcxx_incdir() {
 	# XXX: we should prob scrub this ...
 	if [[ -e ${GCC_ENV_D}/${CC_COMP} ]] ; then
+		(
 			unset LDPATH STDCXX_INCDIR
 			source "${GCC_ENV_D}/${CC_COMP}"
 			echo "${LDPATH}/include/${STDCXX_INCDIR}"
+		)
 	else
 		echo "no-config"
 		echo "${GCC_ENV_D}/${CC_COMP} doesnt exist" 1>&2
 	fi
 	return 0
+}
 split_gcc_ver() {
 	# Split up the gcc profile into components:
 	# TARGET-VER[-specs] -> TARGET VER [specs]
 	# arm-linux-3.3.6 -> arm-linux 3.3.6
 	# x86_64-linux-4.0.1-pre1234 -> x86_64-linux 4.0.1-pre1234
 	# sh-linux-3.4.4-hardened -> sh-linux 3.4.4 hardened
+	#
 	# So below we will start at the end and run a small state machine ...
 	# specs [3]
 	#    accept everything
 	# specs -> version transition [3->2]
 	#    when we find a version component
 	# version [2]
 	#    accept only version components (see the regex)
 	# version -> target transition [2->1]
 	#    when we hit a non version component
 	# target [1]
 	#    accept everything we have left
+	#
 	echo "$@" | awk -F- '
 	function pushit(onme, pushee) {
 		return (onme == "" ? pushee : pushee"-"onme);
+	}
+	{
 		state=3
 		targ=""
 		ver=""
 		spec=""
 		for (i=NF; i > 0; --i) {
 			if (state >= 2) {
 				if ($i ~ /^(alpha|beta|pre|rc|p)?[[:digit:].]+$/) {
 					ver=pushit(ver, $i)
 					state=2
 				} else if (state == 3)
 					spec=pushit(spec, $i)
 				else
 					state=1
+			}
 			if (state == 1)
 				targ = pushit(targ, $i)
+		}
 		if (targ == "") {
 			if (ver == "") {
 				ver=spec
 				spec=""
+			}
 			targ=ver
 			ver=""
+		}
 		print targ " " ver (spec != "" ? " " spec : "")
 	}'
+}
 chop_gcc_ver_spec() {
 	local splitTED=$(split_gcc_ver $@) # target ver spec
 	splitTED=${splitTED#* }            # ver spec
 	echo ${splitTED/ /-}               # ver-spec
+}
 SET_X=false
 NEED_ACTION="yes"
 DOIT="switch_profile"
 CHECK_CHOST="no"
 FORCE="no"
 CC_COMP=
 [[ -z ${ROOT} ]] && ROOT="/"
 [[ ${ROOT:0-1} != "/" ]] && ROOT="${ROOT}/"
 ENV_D="${ROOT}etc/env.d"
 GCC_ENV_D="${ENV_D}/gcc"
 for x in "$@" ; do
 	case "${x}" in
 		# Only use specified compiler if one is not already selected.
 		-O|--use-old)
 			CTARGET=${CTARGET:-$(try_real_hard_to_find_CHOST)}
 			if get_current_profile &>/dev/null ; then
 				CC_COMP=$(get_current_profile)
 			else
 				eerror "No profile selected, unable to utilize --use-old"
 				exit 1
 			fi
 			;;
 		-f|--force)
 			FORCE="yes"
 			;;
 		-P|--use-portage-chost)
 			CHECK_CHOST="yes"
 			;;
 		-c|--get-current-profile)
 			if [[ ${NEED_ACTION} == "yes" ]] ; then
 				NEED_ACTION="no"
 				DOIT="get_current_profile"
 			fi
 			;;
 		-l|--list-profiles)
 			if [[ ${NEED_ACTION} == "yes" ]] ; then
 				NEED_ACTION="no"
 				DOIT="list_profiles"
 			fi
 			;;
 		-S|--split-profile)
 			if [[ ( $1 != "-S" && $1 != "--split-profile" ) || $# -eq 1 ]] ; then
 				usage 1
 			fi
 			shift # push -S out
 			for x in "$@" ; do
 				split_gcc_ver ${x}
 			done
 			exit 0
 			;;
 		-E|--print-environ)
 			if [[ ${NEED_ACTION} == "yes" ]] ; then
 				NEED_ACTION="no"
 				DOIT="print_environ"
 			fi
 			;;
 		-B|--get-bin-path)
 			if [[ ${NEED_ACTION} == "yes" ]] ; then
 				NEED_ACTION="no"
 				DOIT="get_bin_path"
 			fi
 			;;
 		-L|--get-lib-path)
 			if [[ ${NEED_ACTION} == "yes" ]] ; then
 				NEED_ACTION="no"
 				DOIT="get_lib_path"
 			fi
 			;;
 		-X|--get-stdcxx-incdir)
 			if [[ ${NEED_ACTION} == "yes" ]] ; then
 				NEED_ACTION="no"
 				DOIT="get_stdcxx_incdir"
 			fi
 			;;
 		-x|--debug)
 			SET_X=true
 			;;
 		-C|--nocolor)
 			# nothing to do; functions.sh parsed this for us
 			;;
 		-h|--help)
 			usage 0
 			;;
 		-V|--version)
 			rcsfile="$RCSfile: gcc-config-1.4.1,v $"
 			rcsfile=${rcsfile#: }
 			rcsfile=${rcsfile%,v*}
 			cvsrev="$Revision: 1.10 $"
 			cvsrev=${cvsrev#: }
 			cvsdate="$Date: 2009/12/27 16:03:52 $"
 			cvsdate=${cvsdate#: }
 			echo "${rcsfile} (r${cvsrev% *} @ ${cvsdate% *})"
 			exit 0
 			;;
 		-*)
 			eerror "${argv0}: Invalid switch!  Run ${argv0} without parameters for help."
 			exit 1
 			;;
 		*)
 			${SET_X} && set -x
 			if [[ -z ${CC_COMP} ]] ; then
 				if [[ -z $(echo ${x} | tr -d '[:digit:]') ]] ; then
 					# User gave us a # representing the profile
 					i=1
 					for y in "${GCC_ENV_D}"/* ; do
 						[[ -f ${y} ]] || continue
 						[[ ${y/\/config} != ${y} ]] && continue
 						if [[ -f ${y} ]] && [[ ${x} == ${i} ]] ; then
 							CC_COMP=${y##*/}
 							break
 						fi
 						((++i))
 					done
 				else
 					# User gave us a full HOST-gccver
 					x=${x##*/}
 					if [[ ${DOIT} == "get_current_profile" && -z $(ls "${GCC_ENV_D}"/${x}-* 2>/dev/null) ]] || \
 					   [[ ${DOIT} != "get_current_profile" && ! -f ${GCC_ENV_D}/${x} ]]
 					then
 						# Maybe they just gave us a gccver ...
 						get_real_chost
 						if [[ -f ${GCC_ENV_D}/${REAL_CHOST}-${x} ]] ; then
 							x=${REAL_CHOST}-${x}
 						else
 							eerror "${argv0}: Could not locate '$x' in '${GCC_ENV_D}/' !"
 							exit 1
 						fi
 					fi
 					CC_COMP=${x}
 				fi
 			else
 				eerror "${argv0}: Too many arguments!  Run ${argv0} without parameters for help."
 				exit 1
 			fi
 			;;
 	esac
 done
 ${SET_X} && set -x
 get_real_chost
 [[ ${DOIT} == "get_current_profile" ]] \
 	&& CTARGET=${CTARGET:-${CC_COMP:-${REAL_CHOST}}} \
 	|| CTARGET=${CTARGET:-${REAL_CHOST}}
 if [[ ${DOIT} == "switch_profile" ]] && [[ -z ${CC_COMP} ]] ; then
 	usage 1
 fi
 if [[ -z ${CC_COMP} ]] ; then
 	CC_COMP=$(get_current_profile)
 	if [[ $? -ne 0 ]] ; then
 		echo "${CC_COMP}"
 		list_profiles
 		exit 1
 	fi
 fi
 if [[ ${DOIT} != "get_current_profile" ]] ; then
 	GCC_LIB=$(
 		LDPATH=$(source "${GCC_ENV_D}/${CC_COMP}"; echo ${LDPATH})
 		echo ${LDPATH} | awk -F/ '{ print  "/"$2"/"$3"/"$4"/" }'
+	)
 	CC_COMP_VERSION=$(chop_gcc_ver_spec ${CC_COMP})
 	CC_COMP_TARGET=${CC_COMP%-${CC_COMP_VERSION}*}
 	if [[ ! -d ${ROOT}/${GCC_LIB}/${CC_COMP_TARGET}/${CC_COMP_VERSION} ]]; then
 		CC_COMP_VERSION=${CC_COMP_VERSION%-*}
 	fi
 	if [[ ! -d ${ROOT}/${GCC_LIB}/${CC_COMP_TARGET}/${CC_COMP_VERSION} ]] || \
 	   [[ ! -f ${GCC_ENV_D}/${CC_COMP} ]]
 	then
 		eerror "${argv0}: Profile does not exist or invalid setting for ${GCC_ENV_D}/${CC_COMP}" 1>&2
 		#exit 1
 	fi
 fi
 if [[ ${CHECK_CHOST} == "yes" ]] ; then
 	# Chosen CHOST are not the same as the real CHOST according to
 	# make.conf, and --use-portage-chost option was given, so do nothing
 	get_real_chost
 	CC_COMP_VERSION=$(chop_gcc_ver_spec ${CC_COMP})
 	CC_COMP_TARGET=${CC_COMP:0:${#CC_COMP}-${#CC_COMP_VERSION}-1}
 	[[ ${CC_COMP_TARGET} != ${REAL_CHOST} ]] && exit 0
 fi
 eval ${DOIT}
 # vim:ts=4

sys-devel/gcc-config/files/gcc-config-1.5

➞

Show inline comments

@@ new file 100755 @@
 #!/bin/bash
 # Copyright 1999-2009 Gentoo Foundation
 # Distributed under the terms of the GNU General Public License v2
 # $Header: /var/cvsroot/gentoo-x86/sys-devel/gcc-config/files/gcc-config-1.5,v 1.2 2009/12/27 16:03:52 grobian Exp $
 # Format of /etc/env.d/gcc/:
 #  config-TARGET:	CURRENT=version for TARGET
 #  TARGET-VER:		has a TARGET and VER variable
 : ${ROOT:=/}
 [[ ${ROOT} != */ ]] && ROOT="${ROOT}/"
 [[ ${ROOT} != /* ]] && ROOT="${PWD}${ROOT}"
 cd /
 trap ":" INT QUIT TSTP
 argv0=${0##*/}
 source /etc/init.d/functions.sh || {
 	echo "${argv0}: Could not source /etc/init.d/functions.sh!" 1>&2
 	exit 1
+}
 esyslog() { :; }
 umask 022
 die_eerror() {
 	eerror "${argv0}: $*"
 	exit 1
+}
 # *BSD are plain stupid ... copy a GNU extension but don't just copy it,
 # change it so it works differently.  Wish Darwin did selective evolution
 # on software developers.
 SED=$(type -P gsed)
 : ${SED:=$(type -P sed)}
 GENTOO_LIBDIR="lib"
 [[ ${GENTOO_LIBDIR} == @*@ ]] && GENTOO_LIBDIR="lib"
 usage() {
 cat << "USAGE_END"
 Usage: gcc-config [options] [CC Profile]
 Change the current cc/gcc profile, or give info about profiles.
 Options:
   -C, --nocolor              Disable color output
   -O, --use-old              Use the old profile if one was selected.
   -f, --force                Make sure all config files are regenerated.
   -P, --use-portage-chost    Only set to given profile if its CHOST is the
                              same as that set for portage in /etc/make.conf
                              (or one of other portage config files...).
   -c, --get-current-profile  Print current used gcc profile.
   -l, --list-profiles        Print a list of available profiles.
   -S, --split-profile        Split profiles into their components
   -E, --print-environ        Print environment that can be used to setup the
                              current gcc profile, or a specified one.
   -B, --get-bin-path         Print path where binaries of the given/current
                              profile are located.
   -L, --get-lib-path         Print path where libraries of the given/current
                              profile are located.
 Profile names are of the form:  <CHOST>-<gcc version>
 For example:                    i686-pc-linux-gnu-3.2.1
 USAGE_END
 	exit ${1:-1}
+}
 [[ $# -lt 1 ]] && usage 1
 # Usage: source_var <var> <file> [default value]
 source_var() {
 	unset $1
 	local val=$(source "$2"; echo ${!1})
 	: ${val:=$3}
 	eval $1=\"${val}\"
+}
 show_var() {
 	source_var "$@"
 	echo "${!1}"
+}
 try_real_hard_to_find_CHOST() {
+	#
 	# First we read make.conf
+	#
 	local varname=${1:-CHOST}
 	local conf=${ROOT}/etc/make.conf
 	local ret=$(source "${conf}" 2>/dev/null ; echo ${!varname})
 	if [[ -z ${ret} ]] ; then
 		# newer portage supports spaces between the var and =
 		# CHOST     =  "this-is-retarded"
 		ret=$(eval $(
 			sed -n \
 				-e 's:[[:space:]]::g' \
 				-e "/^${varname}=/p" \
 				"${conf}"
 			) ; echo ${!varname}
+		)
 	fi
 	if [[ -n ${ret} ]] ; then
 		echo ${ret}
 		return 0
 	fi
+	#
 	# Then we try /etc/env.d/gcc/config-${CTARGET}
+	#
 	if [[ -s ${ROOT}/etc/env.d/gcc/config-${CTARGET} ]] ; then
 		ret=$(split_gcc_ver $(show_var CURRENT "${ROOT}"/etc/env.d/gcc/config-${CTARGET}))
 		echo ${ret% *}
 	fi
+}
 get_real_chost() {
 	[[ -n ${REAL_CHOST} ]] && return 0
 	# shortcut for switching compilers in a cross chroot
 	if [[ -n ${CHOST} && ${ROOT} != "/" ]] ; then
 		REAL_CHOST=${CHOST}
 		return 0
 	fi
 	# make sure portage isnt broken
 	if python -V &>/dev/null ; then
 		export REAL_CHOST=$(env -i portageq envvar CHOST 2>/dev/null)
 	else
 		ewarn "Python seems to be broken, attempting to locate CHOST ourselves ..."
 		export REAL_CHOST=$(try_real_hard_to_find_CHOST)
 	fi
 	if [[ -z ${REAL_CHOST} ]] ; then
 		eerror "${argv0}: Could not get portage CHOST!"
 		eerror "${argv0}: You should verify that CHOST is set in one of these places:"
 		eerror "${argv0}:  - ${ROOT}/etc/make.conf"
 		eerror "${argv0}:  - active environment"
 		exit 1
 	fi
+}
 is_cross_compiler() {
 	get_real_chost
 	[[ ${CC_COMP/${REAL_CHOST}} == ${CC_COMP} ]]
+}
 convert_profile_paths() {
 	# Older gcc's used PATH= and ROOTPATH= in the env.d files.
 	# Newer one's only use GCC_PATH=.  Convert old to new here.
 	cp -p "${GCC_ENV_D}/${CC_COMP}" "${GCC_ENV_D}/${CC_COMP}.gcc-config-ref" || return 1
 	GCC_PATH=$(
 		unset GCC_PATH PATH ROOTPATH
 		source "${GCC_ENV_D}/${CC_COMP}"
 		echo ${GCC_PATH:-${PATH:-${ROOTPATH}}}
+	)
 	${SED} -i \
 		-e '/^PATH=/d' \
 		-e '/^ROOTPATH=/d' \
 		-e '/^GCC_PATH=/d' \
 		"${GCC_ENV_D}/${CC_COMP}" || return 1
 	echo "GCC_PATH=\"${GCC_PATH}\"" >> "${GCC_ENV_D}/${CC_COMP}" || return 1
 	touch -r "${GCC_ENV_D}/${CC_COMP}.gcc-config-ref" "${GCC_ENV_D}/${CC_COMP}" || return 1
 	rm -f "${GCC_ENV_D}/${CC_COMP}.gcc-config-ref" || return 1
 	return 0
+}
 update_wrappers() {
 	local CTARGET=$1
 	# Find the bin wrapper
 	local wrapper
 	for wrapper in ${GENTOO_LIBDIR} lib lib64 lib32 lib ; do
 		wrapper="${ROOT}usr/${wrapper}/misc/gcc-config"
 		[[ -e ${wrapper} ]] && break
 	done
 	# Update the wrappers for this profile
 	for x in {,${CTARGET}-}{cpp,cc,gcc,c++,g++,f77,g77,gcj,gcjh,gcov,gdc,gdmd,gfortran} ; do
 		# Obviously don't want to touch native stuff for cross-compilers
 		[[ ${x} != ${CTARGET}-* ]] && is_cross_compiler && continue
 		# Make sure we have no stale wrappers
 		rm -f "${ROOT}/usr/bin/${x}"
 		[[ ${x:${#x}-3} == "gcc" || ${x:${#x}-3} == "g++" ]] \
 			&& rm -f "${ROOT}/usr/bin/${x}"{32,64}
 		# Only install a wrapper if the binary exists ...
 		# We want to figure out the 'reference file' for each
 		# wrapper (the binary we're 'wrapping') so that we can
 		# sync mtimes together.  This makes things like ccache
 		# happy.  See Bug #70548 for more info.
 		local ref
 		case ${x} in
 			cc)  ref=gcc;;
 			f77) ref=g77;;
 			*)   ref=${x};;
 		esac
 		ref="${ROOT}/${GCC_PATH}/${ref}"
 		if [[ -x ${ref} ]] ; then
 			cp -f "${wrapper}" "${ROOT}/usr/bin/${x}"
 			touch -r "${ref}" "${ROOT}/usr/bin/${x}"
 		fi
 	done
 	# legacy cruft, make sure we dont leave it laying around #143205
 	rm -f "${ROOT}/usr/bin/${CTARGET}-cc"
 	# install the canonical cpp wrapper
 	[[ ${CTARGET} == *-solaris* ]] && return 0
 	if ! is_cross_compiler ; then
 		cp -f "${wrapper}" "${ROOT}/lib/cpp"
 		touch -r "${ROOT}/usr/bin/${CTARGET}-cpp" "${ROOT}/lib/cpp"
 	fi
+}
 mv_if_diff() {
 	if cmp -s "$1" "$2" ; then
 		rm -f "$1"
 		return 0
 	else
 		mv -f "$1" "$2"
 		return 1
 	fi
+}
 switch_profile() {
 	local MY_LDPATH=
 	local GCC_PROFILES=
 	local OLD_CC_COMP=
 	local GCC_PATH=
 	[[ $(id -u) != "0" ]] && die_eerror "Must be root"
 	if is_cross_compiler ; then
 		ebegin "Switching cross-compiler to ${CC_COMP}"
 	else
 		ebegin "Switching native-compiler to ${CC_COMP}"
 	fi
 	if egrep -q '^(PATH|ROOTPATH)=' "${GCC_ENV_D}/${CC_COMP}" ; then
 		convert_profile_paths "${GCC_ENV_D}/${CC_COMP}" || return 1
 	fi
 	source_var GCC_PATH "${GCC_ENV_D}/${CC_COMP}"
 	# Setup things properly again for this profile
 	unset GCC_SPECS LDPATH
 	source "${GCC_ENV_D}/${CC_COMP}"
 	# Ignore active profile errors here since we're switching away
 	OLD_CC_COMP=$(get_current_profile 2>/dev/null)
 	# GCC_SPECS have long been stable, and people messing with
 	# them know better than to install bad paths, so don't bother
 	# with sanity checks.
 	local envd="${ENV_D}/05gcc-${CTARGET}"
 	cat <<-EOF > "${envd}.tmp"
 	PATH="${GCC_PATH}"
 	ROOTPATH="${GCC_PATH}"
 	GCC_SPECS="${GCC_SPECS}"
 	EOF
 	echo "CURRENT=${CC_COMP}" > "${GCC_ENV_D}/config-${CTARGET}"
 	if ! is_cross_compiler ; then
 		# Order our profiles to have the default first ...
 		# We do this so that we can have them ordered with default
 		# first in /etc/ld.so.conf, as the logical is that all
 		# compilers for default CHOST will be used to compile stuff,
 		# and thus we want all their lib paths in /etc/ld.so.conf ...
 		get_real_chost
 		MY_LDPATH=$(${SED} -n \
 			-e '/^LDPATH=/{s|LDPATH=||;s|"||g;s|:|\n|g;p}' \
 			"${GCC_ENV_D}"/${REAL_CHOST}-* \
 			"${GCC_ENV_D}"/${CC_COMP} | tac
+		)
 		# Pass all by default
 		awk '!/^(STDCXX_INCDIR|LDPATH|CC|CXX|CTARGET|GCCBITS|GCC_SPECS|GCC_PATH)=/ {print $0}' \
 			"${GCC_ENV_D}/${CC_COMP}" >> "${envd}.tmp"
 		if [[ -d ${ROOT}/etc/ld.so.conf.d ]] ; then
 			echo "${MY_LDPATH}" > "${ROOT}"/etc/ld.so.conf.d/05gcc-${CTARGET}.conf
 		else
 			echo "LDPATH=\"${MY_LDPATH}\"" >> "${envd}.tmp"
 		fi
 		# Punt old files; maybe globs too much, but oh well
 		rm -f \
 			"${GCC_ENV_D}/NATIVE" "${GCC_ENV_D}/.NATIVE" \
 			"${ENV_D}/05gcc" "${GCC_ENV_D}/config" \
 			"${ENV_D}/05gcc-${CTARGET}"-* "${GCC_ENV_D}/config-${CTARGET}"-*
 		# Help out the gcc wrapper
 		ln -sf ${CC_COMP} "${GCC_ENV_D}/.NATIVE"
 		# Relocate random crap
 		if [[ -e ${ROOT}/usr/${GENTOO_LIBDIR}/pkgconfig/libgcj-${CC_COMP_VERSION}.pc ]] ; then
 			local mver=${CC_COMP_VERSION:0:3}
 			for x in "" "-${mver}" ; do
 				x="${ROOT}/usr/lib/pkgconfig/libgcj${x}.pc"
 				rm -f "${x}"
 				ln -s libgcj-${CC_COMP_VERSION}.pc "${x}"
 			done
 		fi
 		# We need to make sure that libgcc_s.so / libunwind.so make it into /lib.
 		# On many systems (x86/amd64/etc...), this will probably never matter,
 		# but on other systems (arm/mips/etc...), this is quite critical.
 		# http://bugs.gentoo.org/60190
+		#
 		# The funky move magic is required for proper updating of in-use files.
+		#
 		# Need to cut out extra paths in multilib case and pray the first path
 		# is the "root" multilib path ... maybe some day change this to use
 		# `gcc -print-file-name` ...
 		LDPATH=${LDPATH%%:*}
 		for multilib in $("${ROOT}/${GCC_PATH}"/gcc -print-multi-lib); do
 			multiarg=${multilib#*;}
 			multiarg=${multiarg/@/-}
 			multilibdir=${multilib%;*}
 			libdir="lib/"$("${ROOT}/${GCC_PATH}"/gcc ${multiarg} -print-multi-os-directory)
 			if mkdir -p "${ROOT}/${libdir}"/.gcc.config.new ; then
 				for gcclib in gcc_s unwind ; do
 					if [[ -n $(ls "${ROOT}/${LDPATH}/${multilibdir}"/lib${gcclib}.so.* 2>/dev/null) ]]; then
 						cp -pP "${ROOT}/${LDPATH}/${multilibdir}"/lib${gcclib}.so.* "${ROOT}/${libdir}"/.gcc.config.new/
 						# no need to sanity remove this as the `mv` should take
 						# care of it.  we also need this step to be completly atomic
 						# for systems that have even `mv` linked against libgcc_s.so.
 						# http://bugs.gentoo.org/150257
 						#rm -f "${ROOT}/${libdir}"/lib${gcclib}.so*
 						mv -f "${ROOT}/${libdir}"/.gcc.config.new/* "${ROOT}/${libdir}"/
 					fi
 				done
 				rmdir "${ROOT}/${libdir}"/.gcc.config.new
 			fi
 		done
 		unset multilib
 		unset multilibdir
 		unset multiarg
 		unset libdir
 	fi
 	mv_if_diff "${envd}.tmp" "${envd}"
 	local envd_changed=$?
 	update_wrappers ${CTARGET}
 	if [[ ${ROOT} == "/" ]] && \
 	   [[ ${OLD_CC_COMP} != ${CC_COMP} || ${FORCE} == "yes" ]] && \
 	   [[ ${envd_changed} -eq 1 ]]
 	then
 		# in case python is broken ...
 		if ! env-update ; then
 			echo ""
 			ewarn "env-update failed to work properly; making sure ld.so.conf paths"
 			ewarn "are setup properly.  Please rerun gcc-config with the -f option."
 			echo ""
 			if [[ ! -d /etc/ld.so.conf.d ]] ; then
 				show_var LDPATH "${ROOT}"/etc/env.d/05gcc-${CTARGET} \
 					| sed -e 's|:|\n|g' >> /etc/ld.so.conf
 			fi
 			ldconfig
 		fi
 	else
 		envd_changed=0
 	fi
 	eend 0
 	if [[ ${envd_changed} -ne 0 ]] ; then
 		echo
 		ewarn "If you intend to use the gcc from the new profile in an already"
 		ewarn "running shell, please remember to do:"
 		echo
 		ewarn "  # source /etc/profile"
 		echo
 	fi
 	return 0
+}
 get_current_profile() {
 	local conf="${GCC_ENV_D}/config-${CTARGET}"
 	if [[ ! -f ${conf} ]] ; then
 		conf="${GCC_ENV_D}/config" # old name
 	elif [[ -n ${CC_COMP} ]] && is_cross_compiler ; then
 		conf="${conf}-${CC_COMP}"
 	fi
 	if [[ ! -f ${conf} ]] ; then
 		eerror "${argv0}: No gcc profile is active!"
 		return 1
 	fi
 	source_var CURRENT "${conf}"
 	if [[ -z ${CURRENT} ]] ; then
 		eerror "${argv0}: No gcc profile is active!"
 		return 1
 	elif [[ ! -f ${GCC_ENV_D}/${CURRENT} ]] ; then
 		eerror "${argv0}: Active gcc profile is invalid!"
 		return 1
 	fi
 	echo "${CURRENT}"
 	return 0
+}
 list_profiles() {
 	local i=0
 	local filter=
 	if [[ ${ROOT} != "/" ]] ; then
 		echo "Using gcc-config info in ${ROOT}"
 	fi
 	if [[ ! -f ${GCC_ENV_D}/config-${CTARGET} ]] ; then
 		if ! is_cross_compiler && [[ -e ${GCC_ENV_D}/config ]] ; then
 			[[ -w ${GCC_ENV_D}/config ]] && mv ${GCC_ENV_D}/config ${GCC_ENV_D}/config-${CTARGET}
 		else
 			# get_current_profile already warns
 			#eerror "${argv0}: No gcc profile is active; please select one!"
 			filter=${CTARGET}
 		fi
 	fi
 	source_var CURRENT "${GCC_ENV_D}"/config-${CTARGET}
 	CURRENT_NATIVE=${CURRENT}
 	local target=
 	for x in "${GCC_ENV_D}"/* ; do
 		[[ -f ${x} ]] || continue
 		[[ ${x} == */config* ]] && continue
 		source_var CTARGET "${x}"
 		((++i))
 		[[ -n ${filter} ]] && [[ ${filter} != ${CTARGET} ]] && continue
 		if [[ ${target} != ${CTARGET} ]] ; then
 			[[ ${i} -gt 1 ]] && echo
 			target=${CTARGET}
 			CTARGET=""
 		fi
 		x=${x##*/}
 		if [[ ${x} == ${CURRENT_NATIVE} ]] ; then
 			x="${x} ${GOOD}*${NORMAL}"
 		elif [[ -e ${GCC_ENV_D}/config-${target} ]] ; then
 			source "${GCC_ENV_D}/config-${target}"
 			[[ ${x} == ${CURRENT} ]] && x="${x} ${HILITE}*${NORMAL}"
 		fi
 		echo " [${i}] ${x}"
 	done
+}
 print_environ() {
 	local GCC_PATH=
 	local ENV_CMD=
 	local SET_ELEMENT=
 	source_var GCC_PATH "${GCC_ENV_D}/${CC_COMP}" "${PATH}"
 	case ${SHELL} in
 		*/csh|*/tcsh)
 			ENV_CMD="setenv"
 			SET_ELEMENT=" "
 			;;
 		*)
 			ENV_CMD="export"
 			SET_ELEMENT="="
 			;;
 	esac
+	(
 	PATH=${GCC_PATH}:${PATH}
 	for var in PATH GCC_SPECS ; do
 		echo "${ENV_CMD} ${var}${SET_ELEMENT}\"${!var}\""
 	done
+	)
+}
 get_bin_path() { show_var GCC_PATH "${GCC_ENV_D}/${CC_COMP}" ; }
 get_lib_path() { show_var LDPATH "${GCC_ENV_D}/${CC_COMP}" ; }
 split_gcc_ver() {
 	# Split up the gcc profile into components:
 	# TARGET-VER[-specs] -> TARGET VER [specs]
 	# arm-linux-3.3.6 -> arm-linux 3.3.6
 	# x86_64-linux-4.0.1-pre1234 -> x86_64-linux 4.0.1-pre1234
 	# sh-linux-3.4.4-hardened -> sh-linux 3.4.4 hardened
+	#
 	# So below we will start at the end and run a small state machine ...
 	# specs [3]
 	#    accept everything
 	# specs -> version transition [3->2]
 	#    when we find a version component
 	# version [2]
 	#    accept only version components (see the regex)
 	# version -> target transition [2->1]
 	#    when we hit a non version component
 	# target [1]
 	#    accept everything we have left
+	#
 	echo "$@" | awk -F- '
 	function pushit(onme, pushee) {
 		return (onme == "" ? pushee : pushee"-"onme);
+	}
+	{
 		state=3
 		targ=""
 		ver=""
 		spec=""
 		for (i=NF; i > 0; --i) {
 			if (state >= 2) {
 				if ($i ~ /^(alpha|beta|pre|rc|p)?[[:digit:].]+$/) {
 					ver=pushit(ver, $i)
 					state=2
 				} else if (state == 3)
 					spec=pushit(spec, $i)
 				else
 					state=1
+			}
 			if (state == 1)
 				targ = pushit(targ, $i)
+		}
 		if (targ == "") {
 			if (ver == "") {
 				ver=spec
 				spec=""
+			}
 			targ=ver
 			ver=""
+		}
 		print targ " " ver (spec != "" ? " " spec : "")
 	}'
+}
 chop_gcc_ver_spec() {
 	local splitTED=$(split_gcc_ver $@) # target ver spec
 	splitTED=${splitTED#* }            # ver spec
 	echo ${splitTED/ /-}               # ver-spec
+}
 SET_X=false
 NEED_ACTION="yes"
 DOIT="switch_profile"
 CHECK_CHOST="no"
 FORCE="no"
 CC_COMP=
 ENV_D="${ROOT}etc/env.d"
 GCC_ENV_D="${ENV_D}/gcc"
 for x in "$@" ; do
 	case "${x}" in
 		# Only use specified compiler if one is not already selected.
 		-O|--use-old)
 			: ${CTARGET:=$(try_real_hard_to_find_CHOST)}
 			if get_current_profile &>/dev/null ; then
 				CC_COMP=$(get_current_profile)
 			else
 				die_eerror "No profile selected, unable to utilize --use-old"
 			fi
 			;;
 		-f|--force)
 			FORCE="yes"
 			;;
 		-P|--use-portage-chost)
 			CHECK_CHOST="yes"
 			;;
 		-c|--get-current-profile)
 			if [[ ${NEED_ACTION} == "yes" ]] ; then
 				NEED_ACTION="no"
 				DOIT="get_current_profile"
 			fi
 			;;
 		-l|--list-profiles)
 			if [[ ${NEED_ACTION} == "yes" ]] ; then
 				NEED_ACTION="no"
 				DOIT="list_profiles"
 			fi
 			;;
 		-S|--split-profile)
 			if [[ ( $1 != "-S" && $1 != "--split-profile" ) || $# -eq 1 ]] ; then
 				usage 1
 			fi
 			shift # push -S out
 			for x in "$@" ; do
 				split_gcc_ver ${x}
 			done
 			exit 0
 			;;
 		-E|--print-environ)
 			if [[ ${NEED_ACTION} == "yes" ]] ; then
 				NEED_ACTION="no"
 				DOIT="print_environ"
 			fi
 			;;
 		-B|--get-bin-path)
 			if [[ ${NEED_ACTION} == "yes" ]] ; then
 				NEED_ACTION="no"
 				DOIT="get_bin_path"
 			fi
 			;;
 		-L|--get-lib-path)
 			if [[ ${NEED_ACTION} == "yes" ]] ; then
 				NEED_ACTION="no"
 				DOIT="get_lib_path"
 			fi
 			;;
 		-x|--debug)
 			SET_X=true
 			;;
 		-C|--nocolor)
 			# nothing to do; functions.sh parsed this for us
 			;;
 		-h|--help)
 			usage 0
 			;;
 		-V|--version)
 			unset RCSfile Revision Date
 			rcsfile="$RCSfile: gcc-config-1.5,v $"
 			rcsfile=${rcsfile#: }
 			rcsfile=${rcsfile%,v*}
 			cvsrev="$Revision: 1.2 $"
 			cvsrev=${cvsrev#: }
 			cvsdate="$Date: 2009/12/27 16:03:52 $"
 			cvsdate=${cvsdate#: }
 			echo "${rcsfile} (r${cvsrev% *} @ ${cvsdate% *})"
 			exit 0
 			;;
 		-*)
 			die_eerror "Invalid switch!  Run ${argv0} without parameters for help."
 			;;
 		*)
 			${SET_X} && set -x
 			if [[ -z ${CC_COMP} ]] ; then
 				if [[ -z $(echo ${x} | tr -d '[:digit:]') ]] ; then
 					# User gave us a # representing the profile
 					i=1
 					for y in "${GCC_ENV_D}"/* ; do
 						[[ -f ${y} ]] || continue
 						[[ ${y} == */config* ]] && continue
 						if [[ -f ${y} ]] && [[ ${x} == ${i} ]] ; then
 							CC_COMP=${y##*/}
 							break
 						fi
 						((++i))
 					done
 					if [[ -z ${CC_COMP} ]] ; then
 						die_eerror "Could not locate profile #$x !"
 					fi
 				else
 					# User gave us a full HOST-gccver
 					x=${x##*/}
 					if [[ ${DOIT} == "get_current_profile" && -z $(ls "${GCC_ENV_D}"/${x}-* 2>/dev/null) ]] || \
 					   [[ ${DOIT} != "get_current_profile" && ! -f ${GCC_ENV_D}/${x} ]]
 					then
 						# Maybe they just gave us a gccver ...
 						get_real_chost
 						if [[ -f ${GCC_ENV_D}/${REAL_CHOST}-${x} ]] ; then
 							x=${REAL_CHOST}-${x}
 						else
 							die_eerror "Could not locate '$x' in '${GCC_ENV_D}/' !"
 						fi
 					fi
 					CC_COMP=${x}
 				fi
 			else
 				die_eerror "Too many arguments!  Run ${argv0} without parameters for help."
 			fi
 			;;
 	esac
 done
 ${SET_X} && set -x
 if [[ ${DOIT} == "switch_profile" ]] && [[ -z ${CC_COMP} ]] ; then
 	usage 1
 fi
 get_real_chost
 [[ ${DOIT} == "get_current_profile" ]] \
 	&& : ${CTARGET:=${CC_COMP:-${REAL_CHOST}}} \
 	|| : ${CTARGET:=${REAL_CHOST}}
 if [[ -z ${CC_COMP} ]] ; then
 	CC_COMP=$(get_current_profile)
 	if [[ $? -ne 0 ]] ; then
 		echo "${CC_COMP}"
 		list_profiles
 		exit 1
 	fi
 fi
 if [[ ${DOIT} != "get_current_profile" ]] ; then
 	GCC_LIB=$(
 		show_var LDPATH "${GCC_ENV_D}/${CC_COMP}" | \
 			awk -F/ '{ print  "/"$2"/"$3"/"$4"/" }'
+	)
 	CC_COMP_VERSION=$(chop_gcc_ver_spec ${CC_COMP})
 	CC_COMP_TARGET=${CC_COMP%-${CC_COMP_VERSION}*}
 	if [[ ! -d ${ROOT}/${GCC_LIB}/${CC_COMP_TARGET}/${CC_COMP_VERSION} ]]; then
 		CC_COMP_VERSION=${CC_COMP_VERSION%-*}
 	fi
 	if [[ ! -d ${ROOT}/${GCC_LIB}/${CC_COMP_TARGET}/${CC_COMP_VERSION} ]] || \
 	   [[ ! -f ${GCC_ENV_D}/${CC_COMP} ]]
 	then
 		eerror "${argv0}: Profile does not exist or invalid setting for ${GCC_ENV_D}/${CC_COMP}" 1>&2
 		#exit 1
 	fi
 fi
 if [[ ${CHECK_CHOST} == "yes" ]] ; then
 	# Chosen CHOST are not the same as the real CHOST according to
 	# make.conf, and --use-portage-chost option was given, so do nothing
 	get_real_chost
 	CC_COMP_VERSION=$(chop_gcc_ver_spec ${CC_COMP})
 	CC_COMP_TARGET=${CC_COMP:0:${#CC_COMP}-${#CC_COMP_VERSION}-1}
 	[[ ${CC_COMP_TARGET} != ${REAL_CHOST} ]] && exit 0
 fi
 ${DOIT}
 # vim:ts=4

sys-devel/gcc-config/files/wrapper-1.5.1.c

➞

Show inline comments

@@ new file 100644 @@
 /*
  * Copyright 1999-2008 Gentoo Foundation
  * Distributed under the terms of the GNU General Public License v2
  * $Header: /var/cvsroot/gentoo-x86/sys-devel/gcc-config/files/wrapper-1.5.1.c,v 1.2 2009/01/02 00:43:32 vapier Exp $
  * Author: Martin Schlemmer <azarah@gentoo.org>
  * az's lackey: Mike Frysinger <vapier@gentoo.org>
  */
 #ifdef DEBUG
 # define USE_DEBUG 1
 #else
 # define USE_DEBUG 0
 #endif
 #include <errno.h>
 #include <libgen.h>
 #include <limits.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #define GCC_CONFIG "/usr/bin/gcc-config"
 #define ENVD_BASE  "/etc/env.d/05gcc"
 #define ARRAY_SIZE(arr) (sizeof(arr)/sizeof(arr[0]))
 /* basename(3) is allowed to modify memory */
 #undef basename
 #define basename(path) \
 ({ \
 	char *__path = path; \
 	char *__ret = strrchr(__path, '/'); \
 	__ret ? __ret + 1 : __path; \
 })
 struct wrapper_data {
 	char *name, *fullname, *bin, *path;
 };
 static const struct {
 	char *alias;
 	char *target;
 } wrapper_aliases[] = {
 	{ "cc",  "gcc" },
 	{ "f77", "g77" },
 };
 #define wrapper_warn(fmt, ...) fprintf(stderr, "%s" fmt "\n", "gcc-config: ", ## __VA_ARGS__)
 #define wrapper_err(fmt, ...) ({ wrapper_warn("%s" fmt, "error: ", ## __VA_ARGS__); exit(1); })
 #define wrapper_errp(fmt, ...) wrapper_err(fmt ": %s", ## __VA_ARGS__, strerror(errno))
 #define wrapper_dbg(fmt, ...) ({ if (USE_DEBUG) wrapper_warn(fmt, ## __VA_ARGS__); })
 #define xmemwrap(func, proto, use) \
 static void *x ## func proto \
 { \
 	void *ret = func use; \
 	if (!ret) \
 		wrapper_err(#func "%s", ": out of memory"); \
 	return ret; \
+}
 xmemwrap(malloc, (size_t size), (size))
 xmemwrap(calloc, (size_t nemb, size_t size), (nemb, size))
 xmemwrap(strdup, (const char *s), (s))
 /* check_for_target checks in path for the file we are seeking
  * it returns 1 if found (with data->bin setup), 0 if not and
  * negative on error
  */
 static int check_for_target(char *path, struct wrapper_data *data)
+{
 	struct stat sbuf;
 	char str[PATH_MAX + 1];
 	size_t path_len = strlen(path);
 	size_t len = path_len + strlen(data->name) + 2;
 	if (sizeof(str) < len)
 		wrapper_warn("path too long: %s", path);
 	strcpy(str, path);
 	str[path_len] = '/';
 	str[path_len+1] = '\0';
 	strcat(str, data->name);
 	/* Stat possible file to check that
 	 * 1) it exist and is a regular file, and
 	 * 2) it is not the wrapper itself, and
 	 * 3) it is in a /gcc-bin/ directory tree
 	 */
 	if (strcmp(str, data->fullname) != 0 &&
 	    strstr(str, "/gcc-bin/") != NULL &&
 	    stat(str, &sbuf) == 0 &&
 	    (S_ISREG(sbuf.st_mode) || S_ISLNK(sbuf.st_mode)))
+	{
 		wrapper_dbg("%s: found in %s", data->name, path);
 		data->bin = xstrdup(str);
 		return 1;
+	}
 	wrapper_dbg("%s: did not find in %s", data->name, path);
 	return 0;
+}
 static int find_target_in_path(struct wrapper_data *data)
+{
 	char *token = NULL, *state;
 	char *str;
 	if (data->path == NULL)
 		return 0;
 	/* Make a copy since strtok_r will modify path */
 	str = xstrdup(data->path);
 	/* Find the first file with suitable name in PATH.  The idea here is
 	 * that we do not want to bind ourselfs to something static like the
 	 * default profile, or some odd environment variable, but want to be
 	 * able to build something with a non default gcc by just tweaking
 	 * the PATH ... */
 	token = strtok_r(str, ":", &state);
 	while (token != NULL) {
 		if (check_for_target(token, data))
 			return 1;
 		token = strtok_r(NULL, ":", &state);
+	}
 	wrapper_dbg("%s: did not find in PATH", data->name);
 	return 0;
+}
 /* find_target_in_envd parses /etc/env.d/05gcc, and tries to
  * extract PATH, which is set to the current profile's bin
  * directory ...
  */
 static int find_target_in_envd(struct wrapper_data *data, int cross_compile)
+{
 	FILE *envfile = NULL;
 	char *token = NULL, *state;
 	char str[PATH_MAX + 1];
 	char *strp = str;
 	char envd_file[PATH_MAX + 1];
 	if (!cross_compile) {
 		/* for the sake of speed, we'll keep a symlink around for
 		 * the native compiler.  #190260
 		 */
 		snprintf(envd_file, sizeof(envd_file)-1, "/etc/env.d/gcc/.NATIVE");
 	} else {
 		char *ctarget, *end = strrchr(data->name, '-');
 		if (end == NULL)
 			return 0;
 		ctarget = xstrdup(data->name);
 		ctarget[end - data->name] = '\0';
 		snprintf(envd_file, PATH_MAX, "%s-%s", ENVD_BASE, ctarget);
 		free(ctarget);
+	}
 	envfile = fopen(envd_file, "r");
 	if (envfile == NULL)
 		return 0;
 	while (fgets(strp, PATH_MAX, envfile) != NULL) {
 		/* Keep reading ENVD_FILE until we get a line that
 		 * starts with 'GCC_PATH=' ... keep 'PATH=' around
 		 * for older gcc versions.
 		 */
 		if (strncmp(strp, "GCC_PATH=", strlen("GCC_PATH=")) &&
 		    strncmp(strp, "PATH=", strlen("PATH=")))
 			continue;
 		token = strtok_r(strp, "=", &state);
 		if ((token != NULL) && token[0])
 			/* The second token should be the value of PATH .. */
 			token = strtok_r(NULL, "=", &state);
 		else
 			goto bail;
 		if ((token != NULL) && token[0]) {
 			strp = token;
 			/* A bash variable may be unquoted, quoted with " or
 			 * quoted with ', so extract the value without those ..
 			 */
 			token = strtok(strp, "\n\"\'");
 			while (token != NULL) {
 				if (check_for_target(token, data)) {
 					fclose(envfile);
 					return 1;
+				}
 				token = strtok(NULL, "\n\"\'");
+			}
+		}
 		strp = str;
+	}
  bail:
 	fclose(envfile);
 	return (cross_compile ? 0 : find_target_in_envd(data, 1));
+}
 static void find_wrapper_target(struct wrapper_data *data)
+{
 	if (find_target_in_path(data))
 		return;
 	if (find_target_in_envd(data, 0))
 		return;
 	/* Only our wrapper is in PATH, so get the CC path using
 	 * gcc-config and execute the real binary in there ...
 	 */
 	FILE *inpipe = popen(GCC_CONFIG " --get-bin-path", "r");
 	if (inpipe == NULL)
 		wrapper_errp("could not open pipe");
 	char str[PATH_MAX + 1];
 	if (fgets(str, PATH_MAX, inpipe) == 0)
 		wrapper_errp("could not get compiler binary path");
 	/* chomp! */
 	size_t plen = strlen(str);
 	if (str[plen-1] == '\n')
 		str[plen-1] = '\0';
 	data->bin = xmalloc(plen + 1 + strlen(data->name) + 1);
 	sprintf(data->bin, "%s/%s", str, data->name);
 	pclose(inpipe);
+}
 /* This function modifies PATH to have gcc's bin path appended */
 static void modify_path(struct wrapper_data *data)
+{
 	char *newpath = NULL, *token = NULL, *state;
 	char dname_data[PATH_MAX + 1], str[PATH_MAX + 1];
 	char *str2 = dname_data, *dname = dname_data;
 	size_t len = 0;
 	if (data->bin == NULL)
 		return;
 	if (data->path == NULL)
 		return;
 	snprintf(str2, PATH_MAX + 1, "%s", data->bin);
 	if ((dname = dirname(str2)) == NULL)
 		return;
 	/* Make a copy since strtok_r will modify path */
 	snprintf(str, PATH_MAX + 1, "%s", data->path);
 	token = strtok_r(str, ":", &state);
 	/* Check if we already appended our bin location to PATH */
 	if ((token != NULL) && token[0])
 		if (!strcmp(token, dname))
 			return;
 	len = strlen(dname) + strlen(data->path) + 2 + strlen("PATH") + 1;
 	newpath = xmalloc(len);
 	memset(newpath, 0, len);
 	snprintf(newpath, len, "PATH=%s:%s", dname, data->path);
 	putenv(newpath);
+}
 static char *abi_flags[] = {
 	"-m32", "-m64", "-mabi",
 };
 static char **build_new_argv(char **argv, const char *newflags_str)
+{
 #define MAX_NEWFLAGS 32
 	char *newflags[MAX_NEWFLAGS];
 	char **retargv;
 	unsigned int argc, i;
 	char *state, *flags_tokenized;
 	retargv = argv;
 	/* make sure user hasn't specified any ABI flags already ...
 	 * if they have, lets just get out of here ... this of course
 	 * is by no means complete, it's merely a hack that works most
 	 * of the time ...
 	 */
 	for (argc = 0; argv[argc]; ++argc)
 		for (i = 0; i < ARRAY_SIZE(abi_flags); ++i)
 			if (!strncmp(argv[argc], abi_flags[i], strlen(abi_flags[i])))
 				return retargv;
 	/* Tokenize the flag list and put it into newflags array */
 	flags_tokenized = xstrdup(newflags_str);
 	i = 0;
 	newflags[i] = strtok_r(flags_tokenized, " \t\n", &state);
 	while (newflags[i] != NULL && i < MAX_NEWFLAGS-1)
 		newflags[++i] = strtok_r(NULL, " \t\n", &state);
 	/* allocate memory for our spiffy new argv */
 	retargv = xcalloc(argc + i + 1, sizeof(char*));
 	/* start building retargv */
 	retargv[0] = argv[0];
 	/* insert the ABI flags first so cmdline always overrides ABI flags */
 	memcpy(retargv+1, newflags, i * sizeof(char*));
 	/* copy over the old argv */
 	if (argc > 1)
 		memcpy(retargv+1+i, argv+1, (argc-1) * sizeof(char*));
 	return retargv;
+}
 int main(int argc, char *argv[])
+{
 	struct wrapper_data data;
 	memset(&data, 0, sizeof(data));
 	if (getenv("PATH"))
 		data.path = xstrdup(getenv("PATH"));
 	/* What should we find ? */
 	data.name = basename(argv[0]);
 	/* Allow for common compiler names like cc->gcc */
 	size_t i;
 	for (i = 0; i < ARRAY_SIZE(wrapper_aliases); ++i)
 		if (!strcmp(data.name, wrapper_aliases[i].alias))
 			data.name = wrapper_aliases[i].target;
 	/* What is the full name of our wrapper? */
 	data.fullname = xmalloc(strlen(data.name) + sizeof("/usr/bin/") + 1);
 	sprintf(data.fullname, "/usr/bin/%s", data.name);
 	find_wrapper_target(&data);
 	modify_path(&data);
 	free(data.path);
 	data.path = NULL;
 	/* Set argv[0] to the correct binary, else gcc can't find internal headers
 	 * http://bugs.gentoo.org/8132
 	 */
 	argv[0] = data.bin;
 	/* If $ABI is in env, add appropriate env flags */
 	char **newargv = argv;
 	if (getenv("ABI")) {
 		char envvar[50];
 		/* We use CFLAGS_${ABI} for gcc, g++, g77, etc as the flags that would
 		 * be in there are the same no matter which compiler we are using.
 		 */
 		snprintf(envvar, sizeof(envvar), "CFLAGS_%s", getenv("ABI"));
 		envvar[sizeof(envvar)-1] = '\0';
 		if (getenv(envvar))
 			newargv = build_new_argv(argv, getenv(envvar));
+	}
 	/* Ok, lets do it one more time ... */
 	execv(data.bin, newargv);
 	/* shouldn't have made it here if things worked ... */
 	wrapper_err("could not run/locate '%s'", data.name);
 	return 123;
+}

sys-devel/gcc-config/gcc-config-1.4.1.ebuild

➞

Show inline comments

@@ new file 100644 @@
 # Copyright 1999-2009 Gentoo Foundation
 # Distributed under the terms of the GNU General Public License v2
 # $Header: /var/cvsroot/gentoo-x86/sys-devel/gcc-config/gcc-config-1.4.1.ebuild,v 1.9 2009/05/20 17:43:36 armin76 Exp $
 inherit flag-o-matic toolchain-funcs multilib
 # Version of .c wrapper to use
 W_VER="1.5.1"
 DESCRIPTION="Utility to change the gcc compiler being used"
 HOMEPAGE="http://www.gentoo.org/"
 SRC_URI=""
 LICENSE="GPL-2"
 SLOT="0"
 KEYWORDS="alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc ~sparc-fbsd x86 ~x86-fbsd"
 IUSE=""
 RDEPEND="!app-admin/eselect-compiler"
 S=${WORKDIR}
 src_unpack() {
 	cp "${FILESDIR}"/wrapper-${W_VER}.c "${S}"/wrapper.c || die
+}
 src_compile() {
 	strip-flags
 	emake CC="$(tc-getCC)" wrapper || die "compile wrapper"
+}
 src_install() {
 	newbin "${FILESDIR}"/${PN}-${PV} ${PN} || die "install gcc-config"
 	sed -i \
 		-e "s:@GENTOO_LIBDIR@:$(get_libdir):g" \
 		"${D}"/usr/bin/${PN}
 	exeinto /usr/$(get_libdir)/misc
 	newexe wrapper gcc-config || die "install wrapper"
+}
 pkg_postinst() {
 	# Scrub eselect-compiler remains
 	if [[ -e ${ROOT}/etc/env.d/05compiler ]] ; then
 		rm -f "${ROOT}"/etc/env.d/05compiler
 	fi
 	# Make sure old versions dont exist #79062
 	rm -f "${ROOT}"/usr/sbin/gcc-config
 	# Do we have a valid multi ver setup ?
 	if gcc-config --get-current-profile &>/dev/null ; then
 		# We not longer use the /usr/include/g++-v3 hacks, as
 		# it is not needed ...
 		[[ -L ${ROOT}/usr/include/g++ ]] && rm -f "${ROOT}"/usr/include/g++
 		[[ -L ${ROOT}/usr/include/g++-v3 ]] && rm -f "${ROOT}"/usr/include/g++-v3
 		gcc-config $(/usr/bin/gcc-config --get-current-profile)
 	fi
+}

sys-devel/gcc-config/gcc-config-1.5.ebuild

➞

Show inline comments

@@ new file 100644 @@
 # Copyright 1999-2009 Gentoo Foundation
 # Distributed under the terms of the GNU General Public License v2
 # $Header: /var/cvsroot/gentoo-x86/sys-devel/gcc-config/gcc-config-1.5.ebuild,v 1.1 2009/12/20 19:55:21 vapier Exp $
 inherit flag-o-matic toolchain-funcs multilib
 # Version of .c wrapper to use
 W_VER="1.5.1"
 DESCRIPTION="Utility to change the gcc compiler being used"
 HOMEPAGE="http://www.gentoo.org/"
 SRC_URI=""
 LICENSE="GPL-2"
 SLOT="0"
 #KEYWORDS="~alpha ~amd64 ~arm ~hppa ~ia64 ~m68k ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc ~x86 ~sparc-fbsd ~x86-fbsd"
 IUSE=""
 RDEPEND="!app-admin/eselect-compiler"
 S=${WORKDIR}
 src_unpack() {
 	cp "${FILESDIR}"/wrapper-${W_VER}.c "${S}"/wrapper.c || die
+}
 src_compile() {
 	strip-flags
 	emake CC="$(tc-getCC)" wrapper || die "compile wrapper"
+}
 src_install() {
 	newbin "${FILESDIR}"/${PN}-${PV} ${PN} || die "install gcc-config"
 	sed -i \
 		-e "s:@GENTOO_LIBDIR@:$(get_libdir):g" \
 		"${D}"/usr/bin/${PN}
 	exeinto /usr/$(get_libdir)/misc
 	newexe wrapper gcc-config || die "install wrapper"
+}
 pkg_postinst() {
 	# Scrub eselect-compiler remains
 	if [[ -e ${ROOT}/etc/env.d/05compiler ]] ; then
 		rm -f "${ROOT}"/etc/env.d/05compiler
 	fi
 	# Make sure old versions dont exist #79062
 	rm -f "${ROOT}"/usr/sbin/gcc-config
 	# We not longer use the /usr/include/g++-v3 hacks, as
 	# it is not needed ...
 	[[ -L ${ROOT}/usr/include/g++ ]] && rm -f "${ROOT}"/usr/include/g++
 	[[ -L ${ROOT}/usr/include/g++-v3 ]] && rm -f "${ROOT}"/usr/include/g++-v3
 	# Do we have a valid multi ver setup ?
 	local x
 	for x in $(gcc-config -C -l 2>/dev/null | awk '$NF == "*" { print $2 }') ; do
 		gcc-config ${x}
 	done
+}

sys-devel/gcc-config/metadata.xml

➞

Show inline comments

@@ new file 100644 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
 <pkgmetadata>
 <herd>toolchain</herd>
 </pkgmetadata>

0 comments (0 inline, 0 general)