From 1c7b5935d4d3910f6ef4f7b7a2788a0cecd964aa Mon Sep 17 00:00:00 2001 From: Mike Frysinger Date: Mon, 21 Nov 2011 15:22:03 -0500 Subject: [PATCH] scons-utils.eclass: sync with upstream Gentoo Upstream Gentoo has added a dedicated eclass for working with scons projects. Nothing in the tree uses this yet, but some packages down the line will. BUG=None TEST=None Change-Id: Ibdfe1b7386e4cdbecc7c1cdc981092cda4993332 Reviewed-on: https://gerrit.chromium.org/gerrit/11994 Reviewed-by: David James Commit-Ready: Mike Frysinger Tested-by: Mike Frysinger --- .../portage-stable/eclass/scons-utils.eclass | 235 ++++++++++++++++++ 1 file changed, 235 insertions(+) create mode 100644 sdk_container/src/third_party/portage-stable/eclass/scons-utils.eclass diff --git a/sdk_container/src/third_party/portage-stable/eclass/scons-utils.eclass b/sdk_container/src/third_party/portage-stable/eclass/scons-utils.eclass new file mode 100644 index 0000000000..3654d1a39e --- /dev/null +++ b/sdk_container/src/third_party/portage-stable/eclass/scons-utils.eclass @@ -0,0 +1,235 @@ +# Copyright 1999-2011 Gentoo Foundation +# Distributed under the terms of the GNU General Public License v2 +# $Header: /var/cvsroot/gentoo-x86/eclass/scons-utils.eclass,v 1.9 2011/11/18 20:51:10 mgorny Exp $ + +# @ECLASS: scons-utils.eclass +# @MAINTAINER: +# mgorny@gentoo.org +# @BLURB: helper functions to deal with SCons buildsystem +# @DESCRIPTION: +# This eclass provides a set of function to help developers sanely call +# dev-util/scons and pass parameters to it. +# @EXAMPLE: +# +# @CODE +# inherit scons-utils toolchain-funcs +# +# EAPI=4 +# +# src_configure() { +# myesconsargs=( +# CC="$(tc-getCC)" +# $(use_scons nls ENABLE_NLS) +# ) +# } +# +# src_compile() { +# escons +# } +# +# src_install() { +# # note: this can be DESTDIR, INSTALL_ROOT, ... depending on package +# escons DESTDIR="${D}" install +# } +# @CODE + +# -- public variables -- + +# @ECLASS-VARIABLE: SCONS_MIN_VERSION +# @DEFAULT_UNSET +# @DESCRIPTION: +# The minimal version of SCons required for the build to work. + +# @VARIABLE: myesconsargs +# @DEFAULT_UNSET +# @DESCRIPTION: +# List of package-specific options to pass to all SCons calls. Supposed to be +# set in src_configure(). + +# @ECLASS-VARIABLE: SCONSOPTS +# @DEFAULT_UNSET +# @DESCRIPTION: +# The default set of options to pass to scons. Similar to MAKEOPTS, +# supposed to be set in make.conf. If unset, escons() will use cleaned +# up MAKEOPTS instead. + +# @ECLASS-VARIABLE: EXTRA_ESCONS +# @DEFAULT_UNSET +# @DESCRIPTION: +# The additional parameters to pass to SCons whenever escons() is used. +# Much like EXTRA_EMAKE, this is not supposed to be used in make.conf +# and not in ebuilds! + +# @ECLASS-VARIABLE: USE_SCONS_TRUE +# @DESCRIPTION: +# The default value for truth in scons-use() (1 by default). +: ${USE_SCONS_TRUE:=1} + +# @ECLASS-VARIABLE: USE_SCONS_FALSE +# @DESCRIPTION: +# The default value for false in scons-use() (0 by default). +: ${USE_SCONS_FALSE:=0} + +# -- EAPI support check -- + +case ${EAPI:-0} in + 0|1|2|3|4) ;; + *) die "EAPI ${EAPI} unsupported." +esac + +# -- ebuild variables setup -- + +if [[ -n ${SCONS_MIN_VERSION} ]]; then + DEPEND=">=dev-util/scons-${SCONS_MIN_VERSION}" +else + DEPEND="dev-util/scons" +fi + +# -- public functions -- + +# @FUNCTION: escons +# @USAGE: [scons-arg] ... +# @DESCRIPTION: +# Call scons, passing the supplied arguments, ${myesconsargs[@]}, +# filtered ${MAKEOPTS}, ${EXTRA_ESCONS}. Similar to emake. Like emake, +# this function does die on failure in EAPI 4 (unless called nonfatal). +escons() { + local ret + + debug-print-function ${FUNCNAME} "${@}" + + # if SCONSOPTS are _unset_, use cleaned MAKEOPTS + set -- scons ${SCONSOPTS-$(scons_clean_makeopts)} ${EXTRA_ESCONS} \ + "${myesconsargs[@]}" "${@}" + echo "${@}" >&2 + "${@}" + ret=${?} + + [[ ${ret} -ne 0 && ${EAPI:-0} -ge 4 ]] && die "escons failed." + return ${ret} +} + +# @FUNCTION: scons_clean_makeopts +# @USAGE: [makeflags] [...] +# @DESCRIPTION: +# Strip the supplied makeflags (or ${MAKEOPTS} if called without +# an argument) of options not supported by SCons and make sure --jobs +# gets an argument. Output the resulting flag list (suitable +# for an assignment to SCONSOPTS). +scons_clean_makeopts() { + local new_makeopts + + debug-print-function ${FUNCNAME} "${@}" + + if [[ ${#} -eq 0 ]]; then + debug-print "Using MAKEOPTS: [${MAKEOPTS}]" + set -- ${MAKEOPTS} + else + # unquote if necessary + set -- ${*} + fi + + # empty MAKEOPTS give out empty SCONSOPTS + # thus, we do need to worry about the initial setup + if [[ ${*} = ${_SCONS_CACHE_MAKEOPTS} ]]; then + set -- ${_SCONS_CACHE_SCONSOPTS} + debug-print "Cache hit: [${*}]" + echo ${*} + return + fi + export _SCONS_CACHE_MAKEOPTS=${*} + + while [[ ${#} -gt 0 ]]; do + case ${1} in + # clean, simple to check -- we like that + --jobs=*|--keep-going) + new_makeopts=${new_makeopts+${new_makeopts} }${1} + ;; + # need to take a look at the next arg and guess + --jobs) + if [[ ${#} -gt 1 && ${2} =~ ^[0-9]+$ ]]; then + new_makeopts="${new_makeopts+${new_makeopts} }${1} ${2}" + shift + else + # no value means no limit, let's pass a random int + new_makeopts=${new_makeopts+${new_makeopts} }${1}=5 + fi + ;; + # strip other long options + --*) + ;; + # short option hell + -*) + local str new_optstr + new_optstr= + str=${1#-} + + while [[ -n ${str} ]]; do + case ${str} in + k*) + new_optstr=${new_optstr}k + ;; + # -j needs to come last + j) + if [[ ${#} -gt 1 && ${2} =~ ^[0-9]+$ ]]; then + new_optstr="${new_optstr}j ${2}" + shift + else + new_optstr="${new_optstr}j 5" + fi + ;; + # otherwise, everything after -j is treated as an arg + j*) + new_optstr=${new_optstr}${str} + break + ;; + esac + str=${str#?} + done + + if [[ -n ${new_optstr} ]]; then + new_makeopts=${new_makeopts+${new_makeopts} }-${new_optstr} + fi + ;; + esac + shift + done + + set -- ${new_makeopts} + export _SCONS_CACHE_SCONSOPTS=${*} + debug-print "New SCONSOPTS: [${*}]" + echo ${*} +} + +# @FUNCTION: use_scons +# @USAGE: [var-name] [var-opt-true] [var-opt-false] +# @DESCRIPTION: +# Output a SCons parameter with value depending on the USE flag state. +# If the USE flag is set, output =; otherwise +# =. +# +# If is omitted, will be used instead. However, +# if starts with an exclamation mark (!flag), 'no' will be +# prepended to the name (e.g. noflag). +# +# If and/or are omitted, +# ${USE_SCONS_TRUE} and/or ${USE_SCONS_FALSE} will be used instead. +use_scons() { + local flag=${1} + local varname=${2:-${flag/\!/no}} + local vartrue=${3:-${USE_SCONS_TRUE}} + local varfalse=${4:-${USE_SCONS_FALSE}} + + debug-print-function ${FUNCNAME} "${@}" + + if [[ ${#} -eq 0 ]]; then + eerror "Usage: scons-use [var-name] [var-opt-true] [var-opt-false]" + die 'scons-use(): not enough arguments' + fi + + if use "${flag}"; then + echo "${varname}=${vartrue}" + else + echo "${varname}=${varfalse}" + fi +}