mirrors/flatcar-scripts
1
0
Fork 0
mirror of https://github.com/flatcar/scripts.git synced 2025-12-06 09:52:14 +01:00
Code Issues Packages Projects Releases Wiki Activity

eclass: Add the eclasses required for the LUA suite

Browse Source 
Signed-off-by: Sayan Chowdhury <sayan@kinvolk.io>
This commit is contained in:
Sayan Chowdhury 2021-04-09 16:36:37 +05:30
parent ec5a1a7d7d
commit 6cef7c175f
3 changed files with 1453 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

540
sdk_container/src/third_party/portage-stable/eclass/lua-single.eclass vendored Normal file
View File

@ -0,0 +1,540 @@
# Copyright 1999-2020 Gentoo Authors
# Distributed under the terms of the GNU General Public License v2
# @ECLASS: lua-single.eclass
# @MAINTAINER:
# William Hubbs <williamh@gentoo.org>
# Marek Szuba <marecki@gentoo.org>
# @AUTHOR:
# Marek Szuba <marecki@gentoo.org>
# Based on python-single-r1.eclass by Michał Górny <mgorny@gentoo.org> et al.
# @SUPPORTED_EAPIS: 7
# @BLURB: An eclass for Lua packages not installed for multiple implementations.
# @DESCRIPTION:
# An extension of lua.eclass suite for packages which don't support being
# installed for multiple Lua implementations. This mostly includes software
# embedding Lua.
#
# This eclass sets correct IUSE. It also provides LUA_DEPS
# and LUA_REQUIRED_USE that need to be added to appropriate ebuild
# metadata variables.
#
# The eclass exports LUA_SINGLE_USEDEP that is suitable for depending
# on other packages using the eclass. Dependencies on packages using
# lua.eclass should be created via lua_gen_cond_dep() function, using
# LUA_USEDEP placeholder.
#
# Please note that packages support multiple Lua implementations
# (using lua.eclass) cannot depend on packages not supporting
# them (using this eclass).
#
# Note that since this eclass always inherits lua-utils as well, in ebuilds
# using the former there is no need to explicitly inherit the latter in order
# to use helper functions such as lua_get_CFLAGS.
#
# @EXAMPLE:
# @CODE
# EAPI=7
#
# LUA_COMPAT=( lua5-{1..3} )
#
# inherit lua-single
#
# [...]
#
# REQUIRED_USE="${LUA_REQUIRED_USE}"
# DEPEND="${LUA_DEPS}"
# RDEPEND="${DEPEND}
# $(lua_gen_cond_dep '
# dev-lua/foo[${LUA_USEDEP}]
# ')
# "
# BDEPEND="virtual/pkgconfig"
#
# # Only neeed if the setup phase has to do more than just call lua-single_pkg_setup
# pkg_setup() {
# lua-single_pkg_setup
# [...]
# }
#
# src_install() {
# emake LUA_VERSION="$(lua_get_version)" install
# }
# @CODE
case ${EAPI:-0} in
0|1|2|3|4|5|6)
die "Unsupported EAPI=${EAPI} (too old) for ${ECLASS}"
;;
7)
;;
*)
die "Unsupported EAPI=${EAPI} (unknown) for ${ECLASS}"
;;
esac
if [[ ! ${_LUA_SINGLE_R0} ]]; then
if [[ ${_LUA_R0} ]]; then
die 'lua-single.eclass cannot be used with lua.eclass.'
fi
inherit lua-utils
fi
EXPORT_FUNCTIONS pkg_setup
# @ECLASS-VARIABLE: LUA_COMPAT
# @REQUIRED
# @PRE_INHERIT
# @DESCRIPTION:
# This variable contains a list of Lua implementations the package
# supports. It must be set before the `inherit' call. It has to be
# an array.
#
# Example:
# @CODE
# LUA_COMPAT=( lua5-1 lua5-2 lua5-3 )
# @CODE
#
# Please note that you can also use bash brace expansion if you like:
# @CODE
# LUA_COMPAT=( lua5-{1..3} )
# @CODE
# @ECLASS-VARIABLE: LUA_COMPAT_OVERRIDE
# @USER_VARIABLE
# @DEFAULT_UNSET
# @DESCRIPTION:
# This variable can be used when working with ebuilds to override
# the in-ebuild LUA_COMPAT. It is a string listing all
# the implementations which package will be built for. It need be
# specified in the calling environment, and not in ebuilds.
#
# It should be noted that in order to preserve metadata immutability,
# LUA_COMPAT_OVERRIDE does not affect IUSE nor dependencies.
# The state of LUA_TARGETS is ignored, and all the implementations
# in LUA_COMPAT_OVERRIDE are built. Dependencies need to be satisfied
# manually.
#
# Example:
# @CODE
# LUA_COMPAT_OVERRIDE='lua5-2' emerge -1v dev-lua/foo
# @CODE
# @ECLASS-VARIABLE: LUA_REQ_USE
# @DEFAULT_UNSET
# @PRE_INHERIT
# @DESCRIPTION:
# The list of USE flags required to be enabled on the chosen Lua
# implementations, formed as a USE-dependency string. It should be valid
# for all implementations in LUA_COMPAT, so it may be necessary to
# use USE defaults.
# This must be set before calling `inherit'.
#
# Example:
# @CODE
# LUA_REQ_USE="deprecated"
# @CODE
#
# It will cause the Lua dependencies to look like:
# @CODE
# lua_targets_luaX-Y? ( dev-lang/lua:X.Y[deprecated] )
# @CODE
# @ECLASS-VARIABLE: LUA_DEPS
# @OUTPUT_VARIABLE
# @DESCRIPTION:
# This is an eclass-generated Lua dependency string for all
# implementations listed in LUA_COMPAT.
#
# Example use:
# @CODE
# RDEPEND="${LUA_DEPS}
# dev-foo/mydep"
# DEPEND="${RDEPEND}"
# @CODE
#
# Example value:
# @CODE
# lua_targets_lua5-1? ( dev-lang/lua:5.1 )
# lua_targets_lua5-2? ( dev-lang/lua:5.2 )
# @CODE
# @ECLASS-VARIABLE: LUA_REQUIRED_USE
# @OUTPUT_VARIABLE
# @DESCRIPTION:
# This is an eclass-generated required-use expression which ensures at
# least one Lua implementation has been enabled.
#
# This expression should be utilized in an ebuild by including it in
# REQUIRED_USE, optionally behind a use flag.
#
# Example use:
# @CODE
# REQUIRED_USE="lua? ( ${LUA_REQUIRED_USE} )"
# @CODE
#
# Example value:
# @CODE
# || ( lua_targets_lua5-1 lua_targets_lua5-2 )
# @CODE
# @ECLASS-VARIABLE: LUA_SINGLE_USEDEP
# @OUTPUT_VARIABLE
# @DESCRIPTION:
# This is an eclass-generated USE-dependency string which can be used
# to depend on another lua-single package being built for the same
# Lua implementations.
#
# If you need to depend on a multi-impl (lua.eclass) package, use
# lua_gen_cond_dep with LUA_USEDEP placeholder instead.
#
# Example use:
# @CODE
# RDEPEND="dev-lua/foo[${LUA_SINGLE_USEDEP}]"
# @CODE
#
# Example value:
# @CODE
# lua_single_target_lua5-1(-)?
# @CODE
# @ECLASS-VARIABLE: LUA_USEDEP
# @OUTPUT_VARIABLE
# @DESCRIPTION:
# This is an eclass-generated USE-dependency string which can be used to
# depend on another Lua package being built for the same Lua
# implementations.
#
# Example use:
# @CODE
# RDEPEND="dev-lua/foo[${LUA_USEDEP}]"
# @CODE
#
# Example value:
# @CODE
# lua_targets_lua5-1(-)?,lua_targets_lua5-2(-)?
# @CODE
# @FUNCTION: _lua_single_set_globals
# @INTERNAL
# @DESCRIPTION:
# Sets all the global output variables provided by this eclass.
# This function must be called once, in global scope.
_lua_single_set_globals() {
_lua_set_impls
local flags=( "${_LUA_SUPPORTED_IMPLS[@]/#/lua_single_target_}" )
if [[ ${#_LUA_SUPPORTED_IMPLS[@]} -eq 1 ]]; then
# if only one implementation is supported, use IUSE defaults
# to avoid requesting the user to enable it
IUSE="+${flags[0]}"
else
IUSE="${flags[*]}"
fi
local requse="^^ ( ${flags[*]} )"
local single_flags="${flags[@]/%/(-)?}"
local single_usedep=${single_flags// /,}
local deps= i LUA_PKG_DEP
for i in "${_LUA_SUPPORTED_IMPLS[@]}"; do
_lua_export "${i}" LUA_PKG_DEP
deps+="lua_single_target_${i}? ( ${LUA_PKG_DEP} ) "
done
if [[ ${LUA_DEPS+1} ]]; then
if [[ ${LUA_DEPS} != "${deps}" ]]; then
eerror "LUA_DEPS have changed between inherits (LUA_REQ_USE?)!"
eerror "Before: ${LUA_DEPS}"
eerror "Now : ${deps}"
die "LUA_DEPS integrity check failed"
fi
# these two are formality -- they depend on LUA_COMPAT only
if [[ ${LUA_REQUIRED_USE} != ${requse} ]]; then
eerror "LUA_REQUIRED_USE have changed between inherits!"
eerror "Before: ${LUA_REQUIRED_USE}"
eerror "Now : ${requse}"
die "LUA_REQUIRED_USE integrity check failed"
fi
if [[ ${LUA_SINGLE_USEDEP} != "${single_usedep}" ]]; then
eerror "LUA_SINGLE_USEDEP have changed between inherits!"
eerror "Before: ${LUA_SINGLE_USEDEP}"
eerror "Now : ${single_usedep}"
die "LUA_SINGLE_USEDEP integrity check failed"
fi
else
LUA_DEPS=${deps}
LUA_REQUIRED_USE=${requse}
LUA_SINGLE_USEDEP=${single_usedep}
LUA_USEDEP='%LUA_USEDEP-NEEDS-TO-BE-USED-IN-LUA_GEN_COND_DEP%'
readonly LUA_DEPS LUA_REQUIRED_USE LUA_SINGLE_USEDEP LUA_USEDEP
fi
}
_lua_single_set_globals
unset -f _lua_single_set_globals
if [[ ! ${_LUA_SINGLE_R0} ]]; then
# @FUNCTION: _lua_gen_usedep
# @USAGE: [<pattern>...]
# @INTERNAL
# @DESCRIPTION:
# Output a USE dependency string for Lua implementations which
# are both in LUA_COMPAT and match any of the patterns passed
# as parameters to the function.
#
# The patterns can be fnmatch-style patterns (matched via bash == operator
# against LUA_COMPAT values). Remember to escape or quote the fnmatch
# patterns to prevent accidental shell filename expansion.
#
# This is an internal function used to implement lua_gen_cond_dep.
_lua_gen_usedep() {
debug-print-function ${FUNCNAME} "${@}"
local impl matches=()
_lua_verify_patterns "${@}"
for impl in "${_LUA_SUPPORTED_IMPLS[@]}"; do
if _lua_impl_matches "${impl}" "${@}"; then
matches+=(
"lua_single_target_${impl}(-)?"
)
fi
done
[[ ${matches[@]} ]] || die "No supported implementations match lua_gen_usedep patterns: ${@}"
local out=${matches[@]}
echo "${out// /,}"
}
# @FUNCTION: _lua_impl_matches
# @USAGE: <impl> [<pattern>...]
# @INTERNAL
# @DESCRIPTION:
# Check whether the specified <impl> matches at least one
# of the patterns following it. Return 0 if it does, 1 otherwise.
# Matches if no patterns are provided.
#
# <impl> can be in LUA_COMPAT or ELUA form. The patterns can be
# fnmatch-style patterns, e.g. 'lua5*', '..
_lua_impl_matches() {
[[ ${#} -ge 1 ]] || die "${FUNCNAME}: takes at least 1 parameter"
[[ ${#} -eq 1 ]] && return 0
local impl=${1} pattern
shift
for pattern; do
# unify value style to allow lax matching
if [[ ${impl/./-} == ${pattern/./-} ]]; then
return 0
fi
done
return 1
}
# @FUNCTION: _lua_verify_patterns
# @USAGE: <pattern>...
# @INTERNAL
# @DESCRIPTION:
# Verify whether the patterns passed to the eclass function are correct
# (i.e. can match any valid implementation). Dies on wrong pattern.
_lua_verify_patterns() {
debug-print-function ${FUNCNAME} "${@}"
local impl pattern
for pattern; do
for impl in "${_LUA_ALL_IMPLS[@]}"; do
[[ ${impl} == ${pattern/./-} ]] && continue 2
done
die "Invalid implementation pattern: ${pattern}"
done
}
# @FUNCTION: lua_gen_cond_dep
# @USAGE: <dependency> [<pattern>...]
# @DESCRIPTION:
# Output a list of <dependency>-ies made conditional to USE flags
# of Lua implementations which are both in LUA_COMPAT and match
# any of the patterns passed as the remaining parameters.
#
# The patterns can be fnmatch-style patterns (matched via bash == operator
# against LUA_COMPAT values). Remember to escape or quote the fnmatch
# patterns to prevent accidental shell filename expansion.
#
# In order to enforce USE constraints on the packages, verbatim
# '${LUA_SINGLE_USEDEP}' and '${LUA_USEDEP}' (quoted!) may
# be placed in the dependency specification. It will get expanded within
# the function into a proper USE dependency string.
#
# Example:
# @CODE
# LUA_COMPAT=( lua5-{1..3} )
# RDEPEND="$(lua_gen_cond_dep \
# 'dev-lua/backported_core_module[${LUA_USEDEP}]' lua5-1 lua5-2 )"
# @CODE
#
# It will cause the variable to look like:
# @CODE
# RDEPEND="lua_single_target_lua5-1? (
# dev-lua/backported_core_module[lua_targets_lua5-1(-)?,...] )
# lua_single_target_lua5-2? (
# dev-lua/backported_core_module[lua_targets_lua5-2(-)?,...] )"
# @CODE
lua_gen_cond_dep() {
debug-print-function ${FUNCNAME} "${@}"
local impl matches=()
local dep=${1}
shift
_lua_verify_patterns "${@}"
for impl in "${_LUA_SUPPORTED_IMPLS[@]}"; do
if _lua_impl_matches "${impl}" "${@}"; then
# substitute ${LUA_SINGLE_USEDEP} if used
# (since lua_gen_usedep() will not return
# ${LUA_SINGLE_USEDEP}, the code is run at most once)
if [[ ${dep} == *'${LUA_SINGLE_USEDEP}'* ]]; then
local usedep=$(_lua_gen_usedep "${@}")
dep=${dep//\$\{LUA_SINGLE_USEDEP\}/${usedep}}
fi
local multi_usedep="lua_targets_${impl}(-)"
local subdep=${dep//\$\{LUA_MULTI_USEDEP\}/${multi_usedep}}
matches+=( "lua_single_target_${impl}? (
${subdep//\$\{LUA_USEDEP\}/${multi_usedep}} )" )
fi
done
echo "${matches[@]}"
}
# @FUNCTION: lua_gen_impl_dep
# @USAGE: [<requested-use-flags> [<impl-pattern>...]]
# @DESCRIPTION:
# Output a dependency on Lua implementations with the specified USE
# dependency string appended, or no USE dependency string if called
# without the argument (or with empty argument). If any implementation
# patterns are passed, the output dependencies will be generated only
# for the implementations matching them.
#
# The patterns can be fnmatch-style patterns (matched via bash == operator
# against LUA_COMPAT values). Remember to escape or quote the fnmatch
# patterns to prevent accidental shell filename expansion.
#
# Use this function when you need to request different USE flags
# on the Lua interpreter depending on package's USE flags. If you
# only need a single set of interpreter USE flags, just set
# LUA_REQ_USE and use ${LUA_DEPS} globally.
#
# Example:
# @CODE
# LUA_COMPAT=( lua5-{1..3} )
# RDEPEND="foo? ( $(lua_gen_impl_dep 'deprecated(+)' lua5-3 ) )"
# @CODE
#
# It will cause the variable to look like:
# @CODE
# RDEPEND="foo? (
# lua_single_target_lua5-3? ( dev-lang/lua:5.3[deprecated(+)] )
# )"
# @CODE
lua_gen_impl_dep() {
debug-print-function ${FUNCNAME} "${@}"
local impl
local matches=()
local LUA_REQ_USE=${1}
shift
_lua_verify_patterns "${@}"
for impl in "${_LUA_SUPPORTED_IMPLS[@]}"; do
if _lua_impl_matches "${impl}" "${@}"; then
local LUA_PKG_DEP
_lua_export "${impl}" LUA_PKG_DEP
matches+=( "lua_single_target_${impl}? ( ${LUA_PKG_DEP} )" )
fi
done
echo "${matches[@]}"
}
# @FUNCTION: lua_setup
# @DESCRIPTION:
# Determine what the selected Lua implementation is and set
# the Lua build environment up for it.
lua_setup() {
debug-print-function ${FUNCNAME} "${@}"
unset ELUA
# support developer override
if [[ ${LUA_COMPAT_OVERRIDE} ]]; then
local impls=( ${LUA_COMPAT_OVERRIDE} )
[[ ${#impls[@]} -eq 1 ]] || die "LUA_COMPAT_OVERRIDE must name exactly one implementation for lua-single"
ewarn "WARNING: LUA_COMPAT_OVERRIDE in effect. The following Lua"
ewarn "implementation will be used:"
ewarn
ewarn " ${LUA_COMPAT_OVERRIDE}"
ewarn
ewarn "Dependencies won't be satisfied, and LUA_SINGLE_TARGET flags will be ignored."
_lua_export "${impls[0]}" ELUA LUA
_lua_wrapper_setup
einfo "Using ${ELUA} to build"
return
fi
local impl
for impl in "${_LUA_SUPPORTED_IMPLS[@]}"; do
if use "lua_single_target_${impl}"; then
if [[ ${ELUA} ]]; then
eerror "Your LUA_SINGLE_TARGET setting lists more than a single Lua"
eerror "implementation. Please set it to just one value. If you need"
eerror "to override the value for a single package, please use package.env"
eerror "or an equivalent solution (man 5 portage)."
echo
die "More than one implementation in LUA_SINGLE_TARGET."
fi
_lua_export "${impl}" ELUA LUA
_lua_wrapper_setup
einfo "Using ${ELUA} to build"
fi
done
if [[ ! ${ELUA} ]]; then
eerror "No Lua implementation selected for the build. Please set"
eerror "the LUA_SINGLE_TARGET variable in your make.conf to one"
eerror "of the following values:"
eerror
eerror "${_LUA_SUPPORTED_IMPLS[@]}"
echo
die "No supported Lua implementation in LUA_SINGLE_TARGET."
fi
}
# @FUNCTION: lua-single_pkg_setup
# @DESCRIPTION:
# Runs lua_setup.
lua-single_pkg_setup() {
debug-print-function ${FUNCNAME} "${@}"
[[ ${MERGE_TYPE} != binary ]] && lua_setup
}
_LUA_SINGLE_R0=1
fi

532
sdk_container/src/third_party/portage-stable/eclass/lua-utils.eclass vendored Normal file
View File

@ -0,0 +1,532 @@
# Copyright 1999-2020 Gentoo Authors
# Distributed under the terms of the GNU General Public License v2
# @ECLASS: lua-utils.eclass
# @MAINTAINER:
# William Hubbs <williamh@gentoo.org>
# Marek Szuba <marecki@gentoo.org>
# @AUTHOR:
# Marek Szuba <marecki@gentoo.org>
# Based on python-utils-r1.eclass by Michał Górny <mgorny@gentoo.org> et al.
# @SUPPORTED_EAPIS: 7
# @BLURB: Utility functions for packages with Lua parts
# @DESCRIPTION:
# A utility eclass providing functions to query Lua implementations,
# install Lua modules and scripts.
#
# This eclass neither sets any metadata variables nor exports any phase
# functions. It can be inherited safely.
case ${EAPI:-0} in
0|1|2|3|4|5|6)
die "Unsupported EAPI=${EAPI} (too old) for ${ECLASS}"
;;
7)
;;
*)
die "Unsupported EAPI=${EAPI} (unknown) for ${ECLASS}"
;;
esac
if [[ ! ${_LUA_UTILS_R0} ]]; then
inherit toolchain-funcs
# @ECLASS-VARIABLE: _LUA_ALL_IMPLS
# @INTERNAL
# @DESCRIPTION:
# All supported Lua implementations, most preferred last
_LUA_ALL_IMPLS=(
luajit
lua5-1
lua5-2
lua5-3
lua5-4
)
readonly _LUA_ALL_IMPLS
# @FUNCTION: _lua_set_impls
# @INTERNAL
# @DESCRIPTION:
# Check LUA_COMPAT for well-formedness and validity, then set
# two global variables:
#
# - _LUA_SUPPORTED_IMPLS containing valid implementations supported
# by the ebuild (LUA_COMPAT minus dead implementations),
#
# - and _LUA_UNSUPPORTED_IMPLS containing valid implementations that
# are not supported by the ebuild.
#
# Implementations in both variables are ordered using the pre-defined
# eclass implementation ordering.
#
# This function must only be called once.
_lua_set_impls() {
local i
if ! declare -p LUA_COMPAT &>/dev/null; then
die 'LUA_COMPAT not declared.'
fi
if [[ $(declare -p LUA_COMPAT) != "declare -a"* ]]; then
die 'LUA_COMPAT must be an array.'
fi
local supp=() unsupp=()
for i in "${_LUA_ALL_IMPLS[@]}"; do
if has "${i}" "${LUA_COMPAT[@]}"; then
supp+=( "${i}" )
else
unsupp+=( "${i}" )
fi
done
if [[ ! ${supp[@]} ]]; then
die "No supported implementation in LUA_COMPAT."
fi
if [[ ${_LUA_SUPPORTED_IMPLS[@]} ]]; then
# set once already, verify integrity
if [[ ${_LUA_SUPPORTED_IMPLS[@]} != ${supp[@]} ]]; then
eerror "Supported impls (LUA_COMPAT) changed between inherits!"
eerror "Before: ${_LUA_SUPPORTED_IMPLS[*]}"
eerror "Now : ${supp[*]}"
die "_LUA_SUPPORTED_IMPLS integrity check failed"
fi
if [[ ${_LUA_UNSUPPORTED_IMPLS[@]} != ${unsupp[@]} ]]; then
eerror "Unsupported impls changed between inherits!"
eerror "Before: ${_LUA_UNSUPPORTED_IMPLS[*]}"
eerror "Now : ${unsupp[*]}"
die "_LUA_UNSUPPORTED_IMPLS integrity check failed"
fi
else
_LUA_SUPPORTED_IMPLS=( "${supp[@]}" )
_LUA_UNSUPPORTED_IMPLS=( "${unsupp[@]}" )
readonly _LUA_SUPPORTED_IMPLS _LUA_UNSUPPORTED_IMPLS
fi
}
# @FUNCTION: _lua_wrapper_setup
# @USAGE: [<path> [<impl>]]
# @INTERNAL
# @DESCRIPTION:
# Create proper Lua executables and pkg-config wrappers
# (if available) in the directory named by <path>. Set up PATH
# and PKG_CONFIG_PATH appropriately. <path> defaults to ${T}/${ELUA}.
#
# The wrappers will be created for implementation named by <impl>,
# or for one named by ${ELUA} if no <impl> passed.
#
# If the named directory contains a lua symlink already, it will
# be assumed to contain proper wrappers already and only environment
# setup will be done. If wrapper update is requested, the directory
# shall be removed first.
_lua_wrapper_setup() {
debug-print-function ${FUNCNAME} "${@}"
local workdir=${1:-${T}/${ELUA}}
local impl=${2:-${ELUA}}
[[ ${workdir} ]] || die "${FUNCNAME}: no workdir specified."
[[ ${impl} ]] || die "${FUNCNAME}: no impl nor ELUA specified."
if [[ ! -x ${workdir}/bin/lua ]]; then
mkdir -p "${workdir}"/{bin,pkgconfig} || die
# Clean up, in case we were supposed to do a cheap update
rm -f "${workdir}"/bin/lua{,c} || die
rm -f "${workdir}"/pkgconfig/lua.pc || die
local ELUA LUA
_lua_export "${impl}" ELUA LUA
# Lua interpreter
ln -s "${EPREFIX}"/usr/bin/${ELUA} "${workdir}"/bin/lua || die
# Lua compiler, or a stub for it in case of luajit
if [[ ${ELUA} == luajit ]]; then
# Just in case
ln -s "${EPREFIX}"/bin/true "${workdir}"/bin/luac || die
else
ln -s "${EPREFIX}"/usr/bin/${ELUA/a/ac} "${workdir}"/bin/luac || die
fi
# pkg-config
ln -s "${EPREFIX}"/usr/$(get_libdir)/pkgconfig/${ELUA}.pc \
"${workdir}"/pkgconfig/lua.pc || die
fi
# Now, set the environment.
# But note that ${workdir} may be shared with something else,
# and thus already on top of PATH.
if [[ ${PATH##:*} != ${workdir}/bin ]]; then
PATH=${workdir}/bin${PATH:+:${PATH}}
fi
if [[ ${PKG_CONFIG_PATH##:*} != ${workdir}/pkgconfig ]]; then
PKG_CONFIG_PATH=${workdir}/pkgconfig${PKG_CONFIG_PATH:+:${PKG_CONFIG_PATH}}
fi
export PATH PKG_CONFIG_PATH
}
# @ECLASS-VARIABLE: ELUA
# @DEFAULT_UNSET
# @DESCRIPTION:
# The executable name of the current Lua interpreter. This variable is set
# automatically in functions called by lua_foreach_impl().
#
# Example value:
# @CODE
# lua5.1
# @CODE
# @ECLASS-VARIABLE: LUA
# @DEFAULT_UNSET
# @DESCRIPTION:
# The absolute path to the current Lua interpreter. This variable is set
# automatically in functions called by lua_foreach_impl().
#
# Example value:
# @CODE
# /usr/bin/lua5.1
# @CODE
# @FUNCTION: _lua_get_library_file
# @USAGE: <impl>
# @INTERNAL
# @DESCRIPTION:
# Get the core part (i.e. without the extension) of the library name,
# with path, of the given Lua implementation.
# Used internally by _lua_export().
_lua_get_library_file() {
local impl="${1}"
local libdir libname
case ${impl} in
luajit)
libname=lib$($(tc-getPKG_CONFIG) --variable libname ${impl}) || die
;;
lua*)
libname=lib${impl}
;;
*)
die "Invalid implementation: ${impl}"
;;
esac
libdir=$($(tc-getPKG_CONFIG) --variable libdir ${impl}) || die
debug-print "${FUNCNAME}: libdir = ${libdir}, libname = ${libname}"
echo "${libdir}/${libname}"
}
# @FUNCTION: _lua_export
# @USAGE: [<impl>] <variables>...
# @INTERNAL
# @DESCRIPTION:
# Set and export the Lua implementation-relevant variables passed
# as parameters.
#
# The optional first parameter may specify the requested Lua
# implementation (either as LUA_TARGETS value, e.g. lua5-2,
# or an ELUA one, e.g. lua5.2). If no implementation passed,
# the current one will be obtained from ${ELUA}.
_lua_export() {
debug-print-function ${FUNCNAME} "${@}"
local impl var
case "${1}" in
luajit)
impl=${1}
shift
;;
lua*)
impl=${1/-/.}
shift
;;
*)
impl=${ELUA}
if [[ -z ${impl} ]]; then
die "_lua_export called without a Lua implementation and ELUA is unset"
fi
;;
esac
debug-print "${FUNCNAME}: implementation: ${impl}"
for var; do
case "${var}" in
ELUA)
export ELUA=${impl}
debug-print "${FUNCNAME}: ELUA = ${ELUA}"
;;
LUA)
export LUA="${EPREFIX}"/usr/bin/${impl}
debug-print "${FUNCNAME}: LUA = ${LUA}"
;;
LUA_CFLAGS)
local val
val=$($(tc-getPKG_CONFIG) --cflags ${impl}) || die
export LUA_CFLAGS=${val}
debug-print "${FUNCNAME}: LUA_CFLAGS = ${LUA_CFLAGS}"
;;
LUA_CMOD_DIR)
local val
val=$($(tc-getPKG_CONFIG) --variable INSTALL_CMOD ${impl}) || die
export LUA_CMOD_DIR=${val}
debug-print "${FUNCNAME}: LUA_CMOD_DIR = ${LUA_CMOD_DIR}"
;;
LUA_INCLUDE_DIR)
local val
val=$($(tc-getPKG_CONFIG) --variable includedir ${impl}) || die
export LUA_INCLUDE_DIR=${val}
debug-print "${FUNCNAME}: LUA_INCLUDE_DIR = ${LUA_INCLUDE_DIR}"
;;
LUA_LIBS)
local val
val=$($(tc-getPKG_CONFIG) --libs ${impl}) || die
export LUA_LIBS=${val}
debug-print "${FUNCNAME}: LUA_LIBS = ${LUA_LIBS}"
;;
LUA_LMOD_DIR)
local val
val=$($(tc-getPKG_CONFIG) --variable INSTALL_LMOD ${impl}) || die
export LUA_LMOD_DIR=${val}
debug-print "${FUNCNAME}: LUA_LMOD_DIR = ${LUA_LMOD_DIR}"
;;
LUA_PKG_DEP)
local d
case ${impl} in
luajit)
LUA_PKG_DEP="dev-lang/luajit:="
;;
lua*)
LUA_PKG_DEP="dev-lang/lua:${impl#lua}"
;;
*)
die "Invalid implementation: ${impl}"
;;
esac
# use-dep
if [[ ${LUA_REQ_USE} ]]; then
LUA_PKG_DEP+=[${LUA_REQ_USE}]
fi
export LUA_PKG_DEP
debug-print "${FUNCNAME}: LUA_PKG_DEP = ${LUA_PKG_DEP}"
;;
LUA_SHARED_LIB)
local val=$(_lua_get_library_file ${impl})
export LUA_SHARED_LIB="${val}".so
debug-print "${FUNCNAME}: LUA_SHARED_LIB = ${LUA_SHARED_LIB}"
;;
LUA_VERSION)
local val
val=$($(tc-getPKG_CONFIG) --modversion ${impl}) || die
export LUA_VERSION=${val}
debug-print "${FUNCNAME}: LUA_VERSION = ${LUA_VERSION}"
;;
*)
die "_lua_export: unknown variable ${var}"
;;
esac
done
}
# @FUNCTION: lua_enable_tests
# @USAGE: <test-runner> <test-directory>
# @DESCRIPTION:
# Set up IUSE, RESTRICT, BDEPEND and src_test() for running tests
# with the specified test runner. Also copies the current value
# of RDEPEND to test?-BDEPEND. The test-runner argument must be one of:
#
# - busted: dev-lua/busted
#
# Additionally, a second argument can be passed after <test-runner>,
# so <test-runner> will use that directory to search for tests.
# If not passed, a default directory of <test-runner> will be used.
#
# - busted: spec
#
# This function is meant as a helper for common use cases, and it only
# takes care of basic setup. You still need to list additional test
# dependencies manually. If you have uncommon use case, you should
# not use it and instead enable tests manually.
#
# This function must be called in global scope, after RDEPEND has been
# declared. Take care not to overwrite the variables set by it.
lua_enable_tests() {
debug-print-function ${FUNCNAME} "${@}"
[[ ${#} -ge 1 ]] || die "${FUNCNAME} takes at least one argument: test-runner (test-directory)"
local test_directory
local test_pkg
case ${1} in
busted)
test_directory="${2:-spec}"
test_pkg="dev-lua/busted"
if [[ ! ${_LUA_SINGLE_R0} ]]; then
eval "lua_src_test() {
busted --lua=\"\${ELUA}\" --output=\"plainTerminal\" \"${test_directory}\" || die \"Tests fail with \${ELUA}\"
}"
src_test() {
lua_foreach_impl lua_src_test
}
else
eval "src_test() {
busted --lua=\"\${ELUA}\" --output=\"plainTerminal\" \"${test_directory}\" || die \"Tests fail with \${ELUA}\"
}"
fi
;;
*)
die "${FUNCNAME}: unsupported argument: ${1}"
esac
local test_deps=${RDEPEND}
if [[ -n ${test_pkg} ]]; then
if [[ ! ${_LUA_SINGLE_R0} ]]; then
test_deps+=" ${test_pkg}[${LUA_USEDEP}]"
else
test_deps+=" $(lua_gen_cond_dep "
${test_pkg}[\${LUA_USEDEP}]
")"
fi
fi
if [[ -n ${test_deps} ]]; then
IUSE+=" test"
RESTRICT+=" !test? ( test )"
BDEPEND+=" test? ( ${test_deps} )"
fi
# we need to ensure successful return in case we're called last,
# otherwise Portage may wrongly assume sourcing failed
return 0
}
# @FUNCTION: lua_get_CFLAGS
# @USAGE: [<impl>]
# @DESCRIPTION:
# Obtain and print the compiler flags for building against Lua,
# for the given implementation. If no implementation is provided,
# ${ELUA} will be used.
#
# Please note that this function requires Lua and pkg-config installed,
# and therefore proper build-time dependencies need be added to the ebuild.
lua_get_CFLAGS() {
debug-print-function ${FUNCNAME} "${@}"
_lua_export "${@}" LUA_CFLAGS
echo "${LUA_CFLAGS}"
}
# @FUNCTION: lua_get_cmod_dir
# @USAGE: [<impl>]
# @DESCRIPTION:
# Obtain and print the name of the directory into which compiled Lua
# modules are installed, for the given implementation. If no implementation
# is provided, ${ELUA} will be used.
#
# Please note that this function requires Lua and pkg-config installed,
# and therefore proper build-time dependencies need be added to the ebuild.
lua_get_cmod_dir() {
debug-print-function ${FUNCNAME} "${@}"
_lua_export "${@}" LUA_CMOD_DIR
echo "${LUA_CMOD_DIR}"
}
# @FUNCTION: lua_get_include_dir
# @USAGE: [<impl>]
# @DESCRIPTION:
# Obtain and print the name of the directory containing header files
# of the given Lua implementation. If no implementation is provided,
# ${ELUA} will be used.
#
# Please note that this function requires Lua and pkg-config installed,
# and therefore proper build-time dependencies need be added to the ebuild.
lua_get_include_dir() {
debug-print-function ${FUNCNAME} "${@}"
_lua_export "${@}" LUA_INCLUDE_DIR
echo "${LUA_INCLUDE_DIR}"
}
# @FUNCTION: lua_get_LIBS
# @USAGE: [<impl>]
# @DESCRIPTION:
# Obtain and print the compiler flags for linking against Lua,
# for the given implementation. If no implementation is provided,
# ${ELUA} will be used.
#
# Please note that this function requires Lua and pkg-config installed,
# and therefore proper build-time dependencies need be added to the ebuild.
lua_get_LIBS() {
debug-print-function ${FUNCNAME} "${@}"
_lua_export "${@}" LUA_LIBS
echo "${LUA_LIBS}"
}
# @FUNCTION: lua_get_lmod_dir
# @USAGE: [<impl>]
# @DESCRIPTION:
# Obtain and print the name of the directory into which native-Lua
# modules are installed, for the given implementation. If no implementation
# is provided, ${ELUA} will be used.
#
# Please note that this function requires Lua and pkg-config installed,
# and therefore proper build-time dependencies need be added to the ebuild.
lua_get_lmod_dir() {
debug-print-function ${FUNCNAME} "${@}"
_lua_export "${@}" LUA_LMOD_DIR
echo "${LUA_LMOD_DIR}"
}
# @FUNCTION: lua_get_shared_lib
# @USAGE: [<impl>]
# @DESCRIPTION:
# Obtain and print the expected name, with path, of the main shared library
# of the given Lua implementation. If no implementation is provided,
# ${ELUA} will be used.
#
# Note that it is up to the ebuild maintainer to ensure Lua actually
# provides a shared library.
#
# Please note that this function requires Lua and pkg-config installed,
# and therefore proper build-time dependencies need be added to the ebuild.
lua_get_shared_lib() {
debug-print-function ${FUNCNAME} "${@}"
_lua_export "${@}" LUA_SHARED_LIB
echo "${LUA_SHARED_LIB}"
}
# @FUNCTION: lua_get_version
# @USAGE: [<impl>]
# @DESCRIPTION:
# Obtain and print the full version number of the given Lua implementation.
# If no implementation is provided, ${ELUA} will be used.
#
# Please note that this function requires Lua and pkg-config installed,
# and therefore proper build-time dependencies need be added to the ebuild.
lua_get_version() {
debug-print-function ${FUNCNAME} "${@}"
_lua_export "${@}" LUA_VERSION
echo "${LUA_VERSION}"
}
_LUA_UTILS_R0=1
fi

381
sdk_container/src/third_party/portage-stable/eclass/lua.eclass vendored Normal file
View File

@ -0,0 +1,381 @@
# Copyright 1999-2020 Gentoo Authors
# Distributed under the terms of the GNU General Public License v2
# @ECLASS: lua.eclass
# @MAINTAINER:
# William Hubbs <williamh@gentoo.org>
# Marek Szuba <marecki@gentoo.org>
# @AUTHOR:
# Marek Szuba <marecki@gentoo.org>
# Based on python-r1.eclass by Michał Górny <mgorny@gentoo.org> et al.
# @SUPPORTED_EAPIS: 7
# @BLURB: A common eclass for Lua packages
# @DESCRIPTION:
# A common eclass providing helper functions to build and install
# packages supporting being installed for multiple Lua implementations.
#
# This eclass sets correct IUSE. Modification of REQUIRED_USE has to
# be done by the author of the ebuild (but LUA_REQUIRED_USE is
# provided for convenience, see below). The eclass exports LUA_DEPS
# and LUA_USEDEP so you can create correct dependencies for your
# package easily. It also provides methods to easily run a command for
# each enabled Lua implementation and duplicate the sources for them.
#
# Note that since this eclass always inherits lua-utils as well, in ebuilds
# using the former there is no need to explicitly inherit the latter in order
# to use helper functions such as lua_get_CFLAGS.
#
# @EXAMPLE:
# @CODE
# EAPI=7
#
# LUA_COMPAT=( lua5-{1..3} )
#
# inherit lua
#
# [...]
#
# REQUIRED_USE="${LUA_REQUIRED_USE}"
# DEPEND="${LUA_DEPS}"
# RDEPEND="${DEPEND}
# dev-lua/foo[${LUA_USEDEP}]"
# BDEPEND="virtual/pkgconfig"
#
# lua_src_install() {
# emake LUA_VERSION="$(lua_get_version)" install
# }
#
# src_install() {
# lua_foreach_impl lua_src_install
# }
# @CODE
case ${EAPI:-0} in
0|1|2|3|4|5|6)
die "Unsupported EAPI=${EAPI} (too old) for ${ECLASS}"
;;
7)
;;
*)
die "Unsupported EAPI=${EAPI} (unknown) for ${ECLASS}"
;;
esac
if [[ ! ${_LUA_R0} ]]; then
if [[ ${_LUA_SINGLE_R0} ]]; then
die 'lua.eclass cannot be used with lua-single.eclass.'
fi
inherit multibuild lua-utils
fi
# @ECLASS-VARIABLE: LUA_COMPAT
# @REQUIRED
# @PRE_INHERIT
# @DESCRIPTION:
# This variable contains a list of Lua implementations the package
# supports. It must be set before the `inherit' call. It has to be
# an array.
#
# Example:
# @CODE
# LUA_COMPAT=( lua5-1 lua5-2 lua5-3 )
# @CODE
#
# Please note that you can also use bash brace expansion if you like:
# @CODE
# LUA_COMPAT=( lua5-{1..3} )
# @CODE
# @ECLASS-VARIABLE: LUA_COMPAT_OVERRIDE
# @USER_VARIABLE
# @DEFAULT_UNSET
# @DESCRIPTION:
# This variable can be used when working with ebuilds to override
# the in-ebuild LUA_COMPAT. It is a string listing all
# the implementations which package will be built for. It need be
# specified in the calling environment, and not in ebuilds.
#
# It should be noted that in order to preserve metadata immutability,
# LUA_COMPAT_OVERRIDE does not affect IUSE nor dependencies.
# The state of LUA_TARGETS is ignored, and all the implementations
# in LUA_COMPAT_OVERRIDE are built. Dependencies need to be satisfied
# manually.
#
# Example:
# @CODE
# LUA_COMPAT_OVERRIDE='lua5-2' emerge -1v dev-lua/foo
# @CODE
# @ECLASS-VARIABLE: LUA_REQ_USE
# @DEFAULT_UNSET
# @PRE_INHERIT
# @DESCRIPTION:
# The list of USE flags required to be enabled on the chosen Lua
# implementations, formed as a USE-dependency string. It should be valid
# for all implementations in LUA_COMPAT, so it may be necessary to
# use USE defaults.
# This must be set before calling `inherit'.
#
# Example:
# @CODE
# LUA_REQ_USE="deprecated"
# @CODE
#
# It will cause the Lua dependencies to look like:
# @CODE
# lua_targets_luaX-Y? ( dev-lang/lua:X.Y[deprecated] )
# @CODE
# @ECLASS-VARIABLE: BUILD_DIR
# @OUTPUT_VARIABLE
# @DEFAULT_UNSET
# @DESCRIPTION:
# The current build directory. In global scope, it is supposed to
# contain an initial build directory; if unset, it defaults to ${S}.
#
# In functions run by lua_foreach_impl(), the BUILD_DIR is locally
# set to an implementation-specific build directory. That path is
# created through appending a hyphen and the implementation name
# to the final component of the initial BUILD_DIR.
#
# Example value:
# @CODE
# ${WORKDIR}/foo-1.3-lua5-1
# @CODE
# @ECLASS-VARIABLE: LUA_DEPS
# @OUTPUT_VARIABLE
# @DESCRIPTION:
# This is an eclass-generated Lua dependency string for all
# implementations listed in LUA_COMPAT.
#
# Example use:
# @CODE
# RDEPEND="${LUA_DEPS}
# dev-foo/mydep"
# DEPEND="${RDEPEND}"
# @CODE
#
# Example value:
# @CODE
# lua_targets_lua5-1? ( dev-lang/lua:5.1 )
# lua_targets_lua5-2? ( dev-lang/lua:5.2 )
# @CODE
# @ECLASS-VARIABLE: LUA_REQUIRED_USE
# @OUTPUT_VARIABLE
# @DESCRIPTION:
# This is an eclass-generated required-use expression which ensures at
# least one Lua implementation has been enabled.
#
# This expression should be utilized in an ebuild by including it in
# REQUIRED_USE, optionally behind a use flag.
#
# Example use:
# @CODE
# REQUIRED_USE="lua? ( ${LUA_REQUIRED_USE} )"
# @CODE
#
# Example value:
# @CODE
# || ( lua_targets_lua5-1 lua_targets_lua5-2 )
# @CODE
# @ECLASS-VARIABLE: LUA_USEDEP
# @OUTPUT_VARIABLE
# @DESCRIPTION:
# This is an eclass-generated USE-dependency string which can be used to
# depend on another Lua package being built for the same Lua
# implementations.
#
# Example use:
# @CODE
# RDEPEND="dev-lua/foo[${LUA_USEDEP}]"
# @CODE
#
# Example value:
# @CODE
# lua_targets_lua5-1(-)?,lua_targets_lua5-2(-)?
# @CODE
if [[ ! ${_LUA_R0} ]]; then
# @FUNCTION: _lua_validate_useflags
# @INTERNAL
# @DESCRIPTION:
# Enforce the proper setting of LUA_TARGETS, if LUA_COMPAT_OVERRIDE
# is not in effect. If it is, just warn that the flags will be ignored.
_lua_validate_useflags() {
debug-print-function ${FUNCNAME} "${@}"
if [[ ${LUA_COMPAT_OVERRIDE} ]]; then
if [[ ! ${_LUA_COMPAT_OVERRIDE_WARNED} ]]; then
ewarn "WARNING: LUA_COMPAT_OVERRIDE in effect. The following Lua"
ewarn "implementations will be enabled:"
ewarn
ewarn " ${LUA_COMPAT_OVERRIDE}"
ewarn
ewarn "Dependencies won't be satisfied, and LUA_TARGETS will be ignored."
_LUA_COMPAT_OVERRIDE_WARNED=1
fi
# we do not use flags with LCO
return
fi
local i
for i in "${_LUA_SUPPORTED_IMPLS[@]}"; do
use "lua_targets_${i}" && return 0
done
eerror "No Lua implementation selected for the build. Please add one"
eerror "of the following values to your LUA_TARGETS"
eerror "(in make.conf or package.use):"
eerror
eerror "${LUA_COMPAT[@]}"
echo
die "No supported Lua implementation in LUA_TARGETS."
}
# @FUNCTION: _lua_obtain_impls
# @INTERNAL
# @DESCRIPTION:
# Set up the enabled implementation list.
_lua_obtain_impls() {
_lua_validate_useflags
if [[ ${LUA_COMPAT_OVERRIDE} ]]; then
MULTIBUILD_VARIANTS=( ${LUA_COMPAT_OVERRIDE} )
return
fi
MULTIBUILD_VARIANTS=()
local impl
for impl in "${_LUA_SUPPORTED_IMPLS[@]}"; do
has "${impl}" "${LUA_COMPAT[@]}" && \
use "lua_targets_${impl}" && MULTIBUILD_VARIANTS+=( "${impl}" )
done
}
# @FUNCTION: _lua_multibuild_wrapper
# @USAGE: <command> [<args>...]
# @INTERNAL
# @DESCRIPTION:
# Initialize the environment for the Lua implementation selected
# for multibuild.
_lua_multibuild_wrapper() {
debug-print-function ${FUNCNAME} "${@}"
local -x ELUA LUA
_lua_export "${MULTIBUILD_VARIANT}" ELUA LUA
local -x PATH=${PATH} PKG_CONFIG_PATH=${PKG_CONFIG_PATH}
_lua_wrapper_setup
"${@}"
}
# @FUNCTION: lua_copy_sources
# @DESCRIPTION:
# Create a single copy of the package sources for each enabled Lua
# implementation.
#
# The sources are always copied from initial BUILD_DIR (or S if unset)
# to implementation-specific build directory matching BUILD_DIR used by
# lua_foreach_abi().
lua_copy_sources() {
debug-print-function ${FUNCNAME} "${@}"
local MULTIBUILD_VARIANTS
_lua_obtain_impls
multibuild_copy_sources
}
# @FUNCTION: lua_foreach_impl
# @USAGE: <command> [<args>...]
# @DESCRIPTION:
# Run the given command for each of the enabled Lua implementations.
# If additional parameters are passed, they will be passed through
# to the command.
#
# The function will return 0 status if all invocations succeed.
# Otherwise, the return code from first failing invocation will
# be returned.
#
# For each command being run, ELUA, LUA and BUILD_DIR are set
# locally, and the former two are exported to the command environment.
lua_foreach_impl() {
debug-print-function ${FUNCNAME} "${@}"
local MULTIBUILD_VARIANTS
_lua_obtain_impls
multibuild_foreach_variant _lua_multibuild_wrapper "${@}"
}
_LUA_R0=1
fi
# @FUNCTION: _lua_set_globals
# @INTERNAL
# @DESCRIPTION:
# Sets all the global output variables provided by this eclass.
# This function must be called once, in global scope.
_lua_set_globals() {
local deps i LUA_PKG_DEP
_lua_set_impls
for i in "${_LUA_SUPPORTED_IMPLS[@]}"; do
_lua_export "${i}" LUA_PKG_DEP
deps+="lua_targets_${i}? ( ${LUA_PKG_DEP} ) "
done
local flags=( "${_LUA_SUPPORTED_IMPLS[@]/#/lua_targets_}" )
local optflags=${flags[@]/%/(-)?}
local requse="|| ( ${flags[*]} )"
local usedep=${optflags// /,}
if [[ ${LUA_DEPS+1} ]]; then
# IUSE is magical, so we can't really check it
# (but we verify LUA_COMPAT already)
if [[ ${LUA_DEPS} != "${deps}" ]]; then
eerror "LUA_DEPS have changed between inherits (LUA_REQ_USE?)!"
eerror "Before: ${LUA_DEPS}"
eerror "Now : ${deps}"
die "LUA_DEPS integrity check failed"
fi
# these two are formality -- they depend on LUA_COMPAT only
if [[ ${LUA_REQUIRED_USE} != ${requse} ]]; then
eerror "LUA_REQUIRED_USE have changed between inherits!"
eerror "Before: ${LUA_REQUIRED_USE}"
eerror "Now : ${requse}"
die "LUA_REQUIRED_USE integrity check failed"
fi
if [[ ${LUA_USEDEP} != "${usedep}" ]]; then
eerror "LUA_USEDEP have changed between inherits!"
eerror "Before: ${LUA_USEDEP}"
eerror "Now : ${usedep}"
die "LUA_USEDEP integrity check failed"
fi
else
IUSE=${flags[*]}
LUA_DEPS=${deps}
LUA_REQUIRED_USE=${requse}
LUA_USEDEP=${usedep}
readonly LUA_DEPS LUA_REQUIRED_USE
fi
}
_lua_set_globals
unset -f _lua_set_globals