commit: 99bfe5fc6f7cea4dbf7764628cbde4187959d66b Author: Ulrich Müller <ulm <AT> gentoo <DOT> org> AuthorDate: Tue Aug 20 18:02:49 2024 +0000 Commit: Ulrich Müller <ulm <AT> gentoo <DOT> org> CommitDate: Tue Oct 8 15:22:40 2024 +0000 URL: https://gitweb.gentoo.org/repo/gentoo.git/commit/?id=99bfe5fc
eapi7-ver.eclass: Remove dead eclass Signed-off-by: Ulrich Müller <ulm <AT> gentoo.org> eclass/eapi7-ver.eclass | 309 ------------------------------------------------ 1 file changed, 309 deletions(-) diff --git a/eclass/eapi7-ver.eclass b/eclass/eapi7-ver.eclass deleted file mode 100644 index 85c0856f73b3..000000000000 --- a/eclass/eapi7-ver.eclass +++ /dev/null @@ -1,309 +0,0 @@ -# Copyright 1999-2021 Gentoo Authors -# Distributed under the terms of the GNU General Public License v2 - -# @DEAD -# @ECLASS: eapi7-ver.eclass -# @MAINTAINER: -# PMS team <[email protected]> -# @AUTHOR: -# Ulrich Müller <[email protected]> -# Michał Górny <[email protected]> -# @SUPPORTED_EAPIS: 0 1 2 3 4 5 6 -# @BLURB: Testing implementation of EAPI 7 version manipulators -# @DESCRIPTION: -# A stand-alone implementation of the version manipulation functions -# aimed for EAPI 7. Intended to be used for wider testing of -# the proposed functions and to allow ebuilds to switch to the new -# model early, with minimal change needed for actual EAPI 7. -# -# https://bugs.gentoo.org/482170 -# -# @SUBSECTION Version strings -# -# The functions support arbitrary version strings consisting of version -# components interspersed with (possibly empty) version separators. -# -# A version component can either consist purely of digits ([0-9]+) -# or purely of uppercase and lowercase letters ([A-Za-z]+). A version -# separator is either a string of any other characters ([^A-Za-z0-9]+), -# or it occurs at the transition between a sequence of letters -# and a sequence of digits, or vice versa. In the latter case, -# the version separator is an empty string. -# -# The version is processed left-to-right, and each successive component -# is assigned numbers starting with 1. The components are either split -# on version separators or on boundaries between digits and letters -# (in which case the separator between the components is empty). -# Version separators are assigned numbers starting with 1 for -# the separator between 1st and 2nd components. As a special case, -# if the version string starts with a separator, it is assigned index 0. -# -# Examples: -# -# @CODE -# 1.2b-alpha4 -> 1 . 2 '' b - alpha '' 4 -# c s c s c s c s c -# 1 1 2 2 3 3 4 4 5 -# -# .11. -> . 11 . -# s c s -# 0 1 1 -# @CODE -# -# @SUBSECTION Ranges -# -# A range can be specified as 'm' for m-th version component, 'm-' -# for all components starting with m-th or 'm-n' for components starting -# at m-th and ending at n-th (inclusive). If the range spans outside -# the version string, it is truncated silently. - -case ${EAPI:-0} in - 0|1|2|3|4|5|6) ;; - 7|8) die "${ECLASS}: EAPI=${EAPI} includes all functions from this eclass" ;; - *) die "${ECLASS}: EAPI=${EAPI} unknown" ;; -esac - -# @FUNCTION: _ver_parse_range -# @USAGE: <range> <max> -# @INTERNAL -# @DESCRIPTION: -# Parse the range string <range>, setting 'start' and 'end' variables -# to the appropriate bounds. <max> specifies the appropriate upper -# bound for the range; the user-specified value is truncated to this. -_ver_parse_range() { - local range=${1} - local max=${2} - - [[ ${range} == [0-9]* ]] \ - || die "${FUNCNAME}: range must start with a number" - start=${range%-*} - [[ ${range} == *-* ]] && end=${range#*-} || end=${start} - if [[ ${end} ]]; then - [[ ${start} -le ${end} ]] \ - || die "${FUNCNAME}: end of range must be >= start" - [[ ${end} -le ${max} ]] || end=${max} - else - end=${max} - fi -} - -# @FUNCTION: _ver_split -# @USAGE: <version> -# @INTERNAL -# @DESCRIPTION: -# Split the version string <version> into separator-component array. -# Sets 'comp' to an array of the form: ( s_0 c_1 s_1 c_2 s_2 c_3... ) -# where s_i are separators and c_i are components. -_ver_split() { - local v=${1} LC_ALL=C - - comp=() - - # get separators and components - local s c - while [[ ${v} ]]; do - # cut the separator - s=${v%%[a-zA-Z0-9]*} - v=${v:${#s}} - # cut the next component; it can be either digits or letters - [[ ${v} == [0-9]* ]] && c=${v%%[^0-9]*} || c=${v%%[^a-zA-Z]*} - v=${v:${#c}} - - comp+=( "${s}" "${c}" ) - done -} - -# @FUNCTION: ver_cut -# @USAGE: <range> [<version>] -# @DESCRIPTION: -# Print the substring of the version string containing components -# defined by the <range> and the version separators between them. -# Processes <version> if specified, ${PV} otherwise. -# -# For the syntax of versions and ranges, please see the eclass -# description. -ver_cut() { - local range=${1} - local v=${2:-${PV}} - local start end - local -a comp - - _ver_split "${v}" - local max=$((${#comp[@]}/2)) - _ver_parse_range "${range}" "${max}" - - if [[ ${start} -gt 0 ]]; then - start=$(( start*2 - 1 )) - fi - # Work around a bug in bash-3.2, where "${comp[*]:start:end*2-start}" - # inserts stray 0x7f characters for empty array elements - printf "%s" "${comp[@]:start:end*2-start}" $'\n' -} - -# @FUNCTION: ver_rs -# @USAGE: <range> <repl> [<range> <repl>...] [<version>] -# @DESCRIPTION: -# Print the version string after substituting the specified version -# separators at <range> with <repl> (string). Multiple '<range> <repl>' -# pairs can be specified. Processes <version> if specified, -# ${PV} otherwise. -# -# For the syntax of versions and ranges, please see the eclass -# description. -ver_rs() { - local v - (( ${#} & 1 )) && v=${@: -1} || v=${PV} - local start end i - local -a comp - - _ver_split "${v}" - local max=$((${#comp[@]}/2 - 1)) - - while [[ ${#} -ge 2 ]]; do - _ver_parse_range "${1}" "${max}" - for (( i = start*2; i <= end*2; i+=2 )); do - [[ ${i} -eq 0 && -z ${comp[i]} ]] && continue - comp[i]=${2} - done - shift 2 - done - - local IFS= - echo "${comp[*]}" -} - -# @FUNCTION: _ver_compare_int -# @USAGE: <a> <b> -# @RETURN: 0 if <a> -eq <b>, 1 if <a> -lt <b>, 3 if <a> -gt <b> -# @INTERNAL -# @DESCRIPTION: -# Compare two non-negative integers <a> and <b>, of arbitrary length. -# If <a> is equal to, less than, or greater than <b>, return 0, 1, or 3 -# as exit status, respectively. -_ver_compare_int() { - local a=$1 b=$2 d=$(( ${#1}-${#2} )) - - # Zero-pad to equal length if necessary. - if [[ ${d} -gt 0 ]]; then - printf -v b "%0${d}d%s" 0 "${b}" - elif [[ ${d} -lt 0 ]]; then - printf -v a "%0$(( -d ))d%s" 0 "${a}" - fi - - [[ ${a} > ${b} ]] && return 3 - [[ ${a} == "${b}" ]] -} - -# @FUNCTION: _ver_compare -# @USAGE: <va> <vb> -# @RETURN: 1 if <va> < <vb>, 2 if <va> = <vb>, 3 if <va> > <vb> -# @INTERNAL -# @DESCRIPTION: -# Compare two versions <va> and <vb>. If <va> is less than, equal to, -# or greater than <vb>, return 1, 2, or 3 as exit status, respectively. -_ver_compare() { - local va=${1} vb=${2} a an al as ar b bn bl bs br re LC_ALL=C - - re="^([0-9]+(\.[0-9]+)*)([a-z]?)((_(alpha|beta|pre|rc|p)[0-9]*)*)(-r[0-9]+)?$" - - [[ ${va} =~ ${re} ]] || die "${FUNCNAME}: invalid version: ${va}" - an=${BASH_REMATCH[1]} - al=${BASH_REMATCH[3]} - as=${BASH_REMATCH[4]} - ar=${BASH_REMATCH[7]} - - [[ ${vb} =~ ${re} ]] || die "${FUNCNAME}: invalid version: ${vb}" - bn=${BASH_REMATCH[1]} - bl=${BASH_REMATCH[3]} - bs=${BASH_REMATCH[4]} - br=${BASH_REMATCH[7]} - - # Compare numeric components (PMS algorithm 3.2) - # First component - _ver_compare_int "${an%%.*}" "${bn%%.*}" || return - - while [[ ${an} == *.* && ${bn} == *.* ]]; do - # Other components (PMS algorithm 3.3) - an=${an#*.} - bn=${bn#*.} - a=${an%%.*} - b=${bn%%.*} - if [[ ${a} == 0* || ${b} == 0* ]]; then - # Remove any trailing zeros - [[ ${a} =~ 0+$ ]] && a=${a%"${BASH_REMATCH[0]}"} - [[ ${b} =~ 0+$ ]] && b=${b%"${BASH_REMATCH[0]}"} - [[ ${a} > ${b} ]] && return 3 - [[ ${a} < ${b} ]] && return 1 - else - _ver_compare_int "${a}" "${b}" || return - fi - done - [[ ${an} == *.* ]] && return 3 - [[ ${bn} == *.* ]] && return 1 - - # Compare letter components (PMS algorithm 3.4) - [[ ${al} > ${bl} ]] && return 3 - [[ ${al} < ${bl} ]] && return 1 - - # Compare suffixes (PMS algorithm 3.5) - as=${as#_}${as:+_} - bs=${bs#_}${bs:+_} - while [[ -n ${as} && -n ${bs} ]]; do - # Compare each suffix (PMS algorithm 3.6) - a=${as%%_*} - b=${bs%%_*} - if [[ ${a%%[0-9]*} == "${b%%[0-9]*}" ]]; then - _ver_compare_int "${a##*[a-z]}" "${b##*[a-z]}" || return - else - # Check for p first - [[ ${a%%[0-9]*} == p ]] && return 3 - [[ ${b%%[0-9]*} == p ]] && return 1 - # Hack: Use that alpha < beta < pre < rc alphabetically - [[ ${a} > ${b} ]] && return 3 || return 1 - fi - as=${as#*_} - bs=${bs#*_} - done - if [[ -n ${as} ]]; then - [[ ${as} == p[_0-9]* ]] && return 3 || return 1 - elif [[ -n ${bs} ]]; then - [[ ${bs} == p[_0-9]* ]] && return 1 || return 3 - fi - - # Compare revision components (PMS algorithm 3.7) - _ver_compare_int "${ar#-r}" "${br#-r}" || return - - return 2 -} - -# @FUNCTION: ver_test -# @USAGE: [<v1>] <op> <v2> -# @DESCRIPTION: -# Check if the relation <v1> <op> <v2> is true. If <v1> is not specified, -# default to ${PVR}. <op> can be -gt, -ge, -eq, -ne, -le, -lt. -# Both versions must conform to the PMS version syntax (with optional -# revision parts), and the comparison is performed according to -# the algorithm specified in the PMS. -ver_test() { - local va op vb - - if [[ $# -eq 3 ]]; then - va=${1} - shift - else - va=${PVR} - fi - - [[ $# -eq 2 ]] || die "${FUNCNAME}: bad number of arguments" - - op=${1} - vb=${2} - - case ${op} in - -eq|-ne|-lt|-le|-gt|-ge) ;; - *) die "${FUNCNAME}: invalid operator: ${op}" ;; - esac - - _ver_compare "${va}" "${vb}" - test $? "${op}" 2 -}
