[gentoo-commits] gentoo-x86 commit in app-admin/eselect-gnat/files: gnat.eselect-1.1 gnat-common.bash digest-eselect-gnat-1.1

[George Shapovalov (george)]

george      07/09/19 20:24:05

  Added:                gnat.eselect-1.1 gnat-common.bash
                        digest-eselect-gnat-1.1
  Log:
  split off code common with gnat.eclass (##192505 and 167000)
  (Portage version: 2.1.3.9)

Revision  Changes    Path
1.1                  app-admin/eselect-gnat/files/gnat.eselect-1.1

file : http://sources.gentoo.org/viewcvs.py/gentoo-x86/app-admin/eselect-gnat/files/gnat.eselect-1.1?rev=1.1&view=markup
plain: http://sources.gentoo.org/viewcvs.py/gentoo-x86/app-admin/eselect-gnat/files/gnat.eselect-1.1?rev=1.1&content-type=text/plain

Index: gnat.eselect-1.1
===================================================================
# Copyright 1999-2005 Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2
# $Id: gnat.eselect-1.1,v 1.1 2007/09/19 20:24:05 george Exp $

DESCRIPTION="Manage the talled gnat compilers"
MAINTAINER="ada@g.o"
SVN_DATE='$Date: 2007/09/19 20:24:05 $'
VERSION=$(svn_date_to_version "${SVN_DATE}" )

# "inheriting" common stuff
# this crude sourcing should be replaced by a call to function in
# libs/package-manager.bash eventually
. /usr/share/gnat/lib/gnat-common.bash


### Phylosophy
# Each gnat installs a "specs" file named ${ARCH}-${PN}-${SLOT} under ${SPECSDIR}
# Each lib creates a dir with its name under ${SPECSDIR} and populates it with
# similar specs files (same name scheme)
# Recognizing gnat specs from lib specs is then eazy - test entry for being a
# dir, then just check what gnat profiles are installed for each lib..
# doset then creates env file that combines settings for gnat and for the
# corresponding profile of each installed lib..


### Helpers

# return *the* name of the active profile, checking that we do not have multiple
# env files.
# There can be only one!
get_current_gnat() {
	local profiles=( $(get_env_list) ) 

	if [ ${profiles[@]} == "${MARKER}*" ]; then exit; fi

	if (( 1 == ${#profiles[@]} )); then
		local active=${profiles[0]#${MARKER}}
	else
		die -q "${ENVDIR} contains multiple gnat profiles, please cleanup!"
	fi

	if [ -f ${SPECSDIR}/${active} ]; then
		echo ${active}
	else
		die -q "the active env.d profile does not correspond to any installed gnat!"
	fi
}

# check if the passed arg represents the installed gnat and return it or
# not_found
# takes args:
# $1 - list ID to check
get_name_from_list() {
    compiler=$1

    compilers=( $(find_compilers) )
    for (( i = 0 ; i < ${#compilers[@]} ; i = i + 1 )) ; do
        if [[ ${compilers[$i]} == ${compiler} ]] ; then
            echo ${compiler}
            return
        fi
    done

    echo "(not-found)"
}


# removes env files (for compiler and libs)
# params:
# $1: the name of profile for which to remove env file
unset_env() {
	rm -f ${ENVDIR}/${MARKER}$1 &> /dev/null
}


### show action ###

describe_show() {
	echo "Show the active gnat compiler/profile and installed libs"
}

do_show() {
	write_list_start "Current gnat version:"
	active=$(get_current_gnat)
	if [ ! -z ${active} ] ; then # not sure why [ -n ] does not do the same
		write_kv_list_entry "$active" ""
		libs=( $(find_libs4profile ${active}) )
		write_list_start "Active libs:"
		write_numbered_list "${libs[@]}"
	else
		write_kv_list_entry "(none set)" ""
	fi
}

### list action ###

describe_list() {
	echo "List installed gnat compilers and libs"
}

do_list() {
	compilers=( $(find_compilers ) )
	active=$(get_current_gnat)

	write_list_start "Available gnat compilers:"

	if [[ -n ${compilers[@]} ]] ; then
		local i
		for (( i = 0 ; i < ${#compilers[@]} ; i = i + 1 )) ; do
			linkversion=${compilers[${i}]}

			[[ $linkversion == $active ]] && \
				compilers[${i}]="${compilers[${i}]} $(highlight '*' )"
		done
		write_numbered_list "${compilers[@]}"

		# now the libs
		libs=( $(find_all_libs) )
		write_list_start "Installed libs:"
		for (( i = 0 ; i < ${#libs[@]} ; i = i + 1 )) ; do
			[ -f ${SPECSDIR}/${libs[$i]}/${active} ] && \
				libs[${i}]="${libs[${i}]} $(highlight '*' )"
		done
		write_numbered_list "${libs[@]}"
	else
		write_kv_list_entry "(none found)" ""
	fi
}


### set action ###

describe_set() {
	echo "Set active gnat compiler"
}

# The set action. Parameters:
# $1 - name of profile to set, obligatory, passed by eselect
# $2 - optional, name of env file to generate. Used from gnat.eclass.
do_set() {
	if [[ -z ${1} ]] ; then
		# no parameter
		die -q "You didn't tell me which gnat to use"
	fi

	local toset=$(get_name_from_list $1)
	if [[ ${toset} == "(not-found)" ]] ; then
		die -q "I don't recognise the selection"
	fi

	# the action!
	# in this implementation simply create an appropriate env file
	local active=$(get_current_gnat)
	if [[ -z ${2} ]] ; then
		local envfile="${ENVDIR}/${MARKER}${toset}"

		# now we need to remove an old env file, which is guaranteed to 
		# be unique by get_current_gnat above
		if [[ -n ${active} ]] ; then
			unset_env ${active}
		fi
		# just for a good measure remove the one we are going to write
		unset_env ${toset}
	else
		local envfile="$2"
	fi

	generate_envFile ${toset} ${envfile}

	# force update environment
	# should be replaced with "do_action env update" when #172472 gets resolved
	env-update &> /dev/null
}



### update action ###
#
# This action regenerates the /etc/env.d file for the current profile. Basically
# the same as set, only it does not take any parameters. It should be called from ebuilds
# installing Ada libs

describe_update() {
	echo "Update active gnat profile picking up new libs."
}

do_update() {
	local toset=$(get_current_gnat)
	local envfile="${ENVDIR}/${MARKER}${toset}"
	generate_envFile ${toset} ${envfile}
	env-update &> /dev/null
}

### unset action ###

describe_unset() {
	echo "Remove settings for currently active gnat"
}

do_unset() {
	local active=$(get_current_gnat)
	# check whether we have any profile set before removing anything..
	if [[ -n ${active} ]] ; then
		unset_env ${active}
		env-update &> /dev/null
	fi
}



1.1                  app-admin/eselect-gnat/files/gnat-common.bash

file : http://sources.gentoo.org/viewcvs.py/gentoo-x86/app-admin/eselect-gnat/files/gnat-common.bash?rev=1.1&view=markup
plain: http://sources.gentoo.org/viewcvs.py/gentoo-x86/app-admin/eselect-gnat/files/gnat-common.bash?rev=1.1&content-type=text/plain

Index: gnat-common.bash
===================================================================
# Copyright 1999-2007 Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2
# $Header: /var/cvsroot/gentoo-x86/app-admin/eselect-gnat/files/gnat-common.bash,v 1.1 2007/09/19 20:24:05 george Exp $

#
# Original Author: George Shapovalov <george@g.o>
# Purpose: Contains common vars/locations and functions for use by gnat.eclass,
# gnat.eselect and gnatbuild.eclass.
#
# NOTE!!!
# This eclass should just define vars (tyr to limit these!) and simple functions.
# No bash extensions!!
# That is, no portage or eclass internals are allowed!
#



# ----------------------------------
# Globals

# Environmantal stuff (for env update)
SPECSDIR="/usr/share/gnat/eselect"
ENVDIR="/etc/env.d"
MARKER="55gnat-"


# ------------------------------------
# Helpers
#
# may be moved to a seperate eclass, if enough accumulated in this one and in
# gnatbuild.eclass..

# get_all_profile_components splits gnat profile and returns pace separated list of its components:
# x86_64-pc-linux-gnu-gnat-gcc-4.1  -> x86_64-pc-linux-gnu gcc 4.1
# args:
#  $1 - the string to split
get_all_profile_components() {
	local GnatSLOT=${1##*-}
	local remainder=${1%-*}
	local GnatPkg=${remainder##*-}
	remainder=${remainder%-gnat-*}
	echo "${remainder} ${GnatPkg} ${GnatSLOT}"
}

# similar to above, returns only SLOT component:
# x86_64-pc-linux-gnu-gnat-gcc-4.1  -> 4.1
# args:
#  $1 - the string to extract the slot from
get_gnat_SLOT() {
	echo "${1##*-}"
}

# returns only Pkg component:
# x86_64-pc-linux-gnu-gnat-gcc-4.1  -> gcc
# args:
#  $1 - the string to extract the slot from
get_gnat_Pkg() {
	local remainder=${1%-*}
	echo "${remainder##*-}"
}

# returns only Arch component:
# x86_64-pc-linux-gnu-gnat-gcc-4.1  -> x86_64-pc-linux-gnu
# args:
#  $1 - the string to extract the slot from
get_gnat_Arch() {
	echo ${1%-gnat-*}
}



## -------------------------------------------
#  gnat profile and lib detection functions


# create a list of all gnat env.d files
# for now use trivial implementation - store name of active profile in the
# env file name, so it gets called 55gnat-${ARCH}-${PN}-${SLOT}
get_env_list() {
	for fn in ${ENVDIR}/${MARKER}*; do
		echo $(basename ${fn})
	done
}



# find installed compilers and return a list
find_compilers() {
	[ ! -d ${SPECSDIR} ] && exit
	for fn in ${SPECSDIR}/*; do
		[ ! -d ${fn} ] && echo $(basename ${fn});
	done
}

# find installed libs and return a list
find_all_libs() {
	[ ! -d ${SPECSDIR} ] && exit
	for fn in ${SPECSDIR}/*; do
		[ -d ${fn} ] && echo $(basename ${fn});
	done
}

# find libs that have been built for a given profile
# Arguments:
#  $1 - gnat profile for which to detect active libs
find_libs4profile() {
	libs=( $(find_all_libs) )

	for (( i = 0 ; i < ${#libs[@]} ; i = i + 1 )) ; do
		[ -f ${SPECSDIR}/${libs[$i]}/$1 ] && echo "${libs[$i]}"
	done
}




## -----------------------
#  princial action - central part of do_set and helpers


# extracts values of the passed var definition from given spec file
# params:
# $1: spec file (as generated by gnabuild.eclass)
# $2: variable name
get_var_from_spec() {
	local var=$(grep -e "^ *$2=" $1|cut -d= -f2)
	echo ${var}
}


# Cycle through given libs and form a ':' separated list of settings for the given
# var. Returned string starts with ':' if there is any non-empty setting,
# otherwise returns empty string
# params:
#   $1 - name of env var to process
#   $2 - name of gnat profile
#   $3.. - list of libs to check (to avoid its composition every time)
#        - the list is expanded to lest of args at the point of call
get_lib_var_settings() {
	local envVar=$1
	local toset=$2
	#echo "get_lib_var_settings params:$@" >> /tmp/eselect-gnat.rep
	if  [[ "none" != ${3} ]]; then
		local envString
		local specLine
		while [[ -n $3 ]]; do
			specLine=$(get_var_from_spec ${SPECSDIR}/$3/${toset} ${envVar})
			#echo "$3:${specLine}." >> /tmp/eselect-gnat.rep
			[[ -n ${specLine} ]] && envString="${envString}:${specLine}"
			shift
		done
		echo "${envString}"
	fi
}



# The action!
# Part common for do_set and do_update of gnat.eselect, also used in gnat.eclass
# to set environment during lib build and installation
#
# params:
#  $1 - profile to set (toset param inside)
#  $2 - envfile

generate_envFile() {
	local toset=$1
	local envfile=$2

	local binpath="$(get_var_from_spec ${SPECSDIR}/${toset} binpath)"
	local libexecpath="$(get_var_from_spec ${SPECSDIR}/${toset} libexecpath)"
	local libs=( $(find_libs4profile ${toset}) )
	#echo "generate_envFile: ${libs[@]}" >> /tmp/eselect-gnat.rep
	if (( 0 == ${#libs[@]} )); then
		libs="none"
	fi

	local MyPath="${binpath}:${libexecpath}$(get_lib_var_settings PATH ${toset} ${libs[@]})"
	echo "PATH=${MyPath}" > "${envfile}"
	echo "ROOTPATH=${MyPath}" >> "${envfile}"
	echo "MANPATH=$(get_var_from_spec ${SPECSDIR}/${toset} manpath)$(get_lib_var_settings MANPATH ${toset} ${libs[@]})" >> "${envfile}"
	echo "INFOPATH=$(get_var_from_spec ${SPECSDIR}/${toset} infopath)$(get_lib_var_settings INFOPATH ${toset} ${libs[@]})" >> "${envfile}"
	# the next three use the common base
	local libBase=$(get_var_from_spec ${SPECSDIR}/${toset} ldpath)
	echo "LDPATH=${libBase}:${libBase}/adalib$(get_lib_var_settings LDPATH ${toset} ${libs[@]})" >> "${envfile}"
	echo "ADA_INCLUDE_PATH=${libBase}/adainclude$(get_lib_var_settings ADA_INCLUDE_PATH ${toset} ${libs[@]})" >> "${envfile}"
	echo "ADA_OBJECTS_PATH=${libBase}/adalib$(get_lib_var_settings ADA_OBJECTS_PATH ${toset} ${libs[@]})" >> "${envfile}"
}




1.1                  app-admin/eselect-gnat/files/digest-eselect-gnat-1.1

	<<Binary file>>


-- 
gentoo-commits@g.o mailing list