Comparaison du numéro de version dans le fichier makefile

Dans un makefile, j'aimerais définir une variable indiquant si le courant redhat-release est supérieure à 5.3. (Cette variable sera passé à gcc comme un #define)

Jusqu'à présent, je suis venu avec:

# Find out which version of Red-Hat we're running
RH_VER_NUM = $(shell /bin/grep -o [0-9].[0-9] /etc/redhat-release)
RH_GT_5_3 = $RH_VER_NUM > '5.3'

Quelle serait la bonne façon de définir RH_GT_5_3?

source d'informationauteur tsotso

  1. 16

    GNU Make ne contient pas toutes les comparaisons de chaînes autres que de l'égalité, et test ne peut faire moins que/plus grand que les tests sur des entiers. Diviser le numéro de version dans ses parties intégrantes et de faire la comparaison de cette façon. Essayez ceci (notez également que := est mieux que = ici, que de faire de l'évaluation différée voudrais appeler votre $(shell) commandes beaucoup plus de fois que nécessaire:

    RH_VER_MAJOR := $(shell echo $(RH_VER_NUM) | cut -f1 -d.)
RH_VER_MINOR := $(shell echo $(RH_VER_NUM) | cut -f2 -d.)
RH_GT_5_3 := $(shell [ $(RH_VER_MAJOR) -gt 5 -o \( $(RH_VER_MAJOR) -eq 5 -a $(RH_VER_MINOR) -ge 3 \) ] && echo true)

ifeq ($(RH_GT_5_3),true)
CPPFLAGS += -DRH_GT_5_3=1
endif
  2. 2

    La solution la plus simple je pense est d'utiliser bc:

    # Find out which version of Red-Hat we're running
RH_VER_NUM = $(shell /bin/grep -o [0-9].[0-9] /etc/redhat-release)
RH_GT_5_3 = $(shell echo $(RH_VER_NUM)\>=5.3 | bc )

ifeq ($(RH_GT_5_3),1)
CPPFLAGS += -DRH_GT_5_3=1
endif

    Ce sera égale à 1 si plus de 5,3, et 0 autrement.

  3. 1

    Je réalise que c'est une vieille question, mais tout de même. En fait, vous pouvez recourir à lsb_releaseque j'ai trouvé pour être installé sur tous les récents système RedHat.

    Pour être précis, vous auriez du faire usage de

    lsb_release -sr

    à l'intérieur de $(shell ...) et puis coupé à la . comme ceci:

    RH_VER:=$(shell lsb_release -sr)
RH_MAJVER:=$(word 1, $(subst ., ,$(RH_VER)))
RH_MINVER:=$(word 2, $(subst ., ,$(RH_VER)))

    vous avez maintenant la majeure/mineure de la version et pouvez le vérifier à l'encontre de tout ce que vous voulez.

    Le cas classique serait $(filter ...) et les autres fonctions de texte GNU faire offre.

    Néanmoins je suis d'accord qu'une sorte de config.h aurait plus de sens, bien que les Autotools est pas parfait pour tous les scénarios (il existe d'autres outils de construction qui tentent la même chose, tout de même).

  4. 1

    Un peu plus courte est la solution de:

    RH_GT_5_3 := $(shell echo -e "5.4\n$(RH_VER_NUM)"|sort -ct. -k1,1n -k2,2n && echo YES)

    Ce sera mis en RH_GT_5_3 sur "OUI" si RH_VER_NUM est supérieure ou égale à 5,4 (donc supérieure à 5.3). Sinon RH_GT_5_3 sera vide.

    Si plusieurs numéros de version doivent être vérifiés, nous pouvons définir une fonction:

    IF_VER_GE = $(shell echo -e "$2\n$1"|sort -ct. -k1,1n -k2,2n && echo YES)
GLIBC := $(word 2,$(shell getconf GNU_LIBC_VERSION))
...
all:
ifeq "$(call IF_VER_GE, $(GLIBC), 2.5)" "YES"
    echo "GE"
else
    echo "LT"
endif

    J'ai utilisé le "$(word 2,..." au lieu de "$(lastword,..." parce que le plus tard ne fonctionne pas en 3.8. Et plus courte...

    ... quelques siècles et des siècles plus tard

    J'ai essayé de résoudre la comparaison de version interne makefile fonctions. J'ai trouvé un projet (GNU Make Bibliothèque Standard (GMSL)), ce qui ajoute un include pour le makefile qui implémente l'arithmétique des nombres entiers. Malheureusement avec la commune unaire système de numération. Mais en comparant les numéros de version sont plus complexes. Comme j'ai travaillé avec les versions d'avoir un nombre de plus de 100_000 j'ai décidé de mettre en œuvre un cadre plus général de la solution. Il fonctionne avec un nombre arbitraire de la subversion numéros de chaque avec des chiffres arbitraires. Quelques idées ont été empruntés à la GMSL projet

    Il met en œuvre le ver.lt de la fonction. Il renvoie 'T' si le premier numéro de la version est inférieure à la seconde. Elle renvoie une chaîne vide sinon. Bien sûr, la subversion numéros sont comparés numériquement pas lexicographiquement. Donc 1.20 est supérieure à 1.3. Il y a certaines questions. 1.2 < 1.2.0, 1.0.1 < 1.00.1, 1.9.1 < 1.01.1 (comme il est prévu qu'un nombre commence par un chiffre différent de zéro. Sauf le 0.). Je ne veux pas les résoudre maintenant.

    La solution

    Il est testAed sous gnu make 3.82.90. Il y a quelques lignes très longues comme makefile ajouter des espaces si les '\' est utilisée. J'ai laissé certaines mises en œuvre, mais pas les fonctions utilisées dans le code. J'aurais peut-être une meilleure utilisation temporaire des noms de variables (comme GMSL utilise _gmsl). Parfois, les variables temporaires pourraient être arrêté, mais le code sera plus cryptique.

    .SILENT:
S :=
SP := $S $S

# For non empty strings
#not = $(if $1,$S,T)
#str.ne = $(if $(subst $1,,$2),T,$S)
str.eq = $(if $(subst $1,,$2),$S,T)
str.le = $(call str.eq,$(word 1,$(sort $1 $2)),$1)
#str.ge = $(call str.eq,$(word 1,$(sort $1 $2)),$2)

# Creates a list of digits from a number
mklist = $(eval __tmp := $1)$(foreach i,0 1 2 3 4 5 6 7 8 9,$(eval __tmp := $$(subst $$i,$$i ,$(__tmp))))$(__tmp)
# reverse: $(subst $(SP),,$(list))

#pop = $(wordlist 2, $(words $1), x $1)
#push = $1 $2
shift = $(wordlist 2, $(words $1), $1)
#unshift = $2 $1

num.le = $(eval __tmp1 := $(call mklist,$1))$(eval __tmp2 := $(call mklist,$2))$(if $(call str.eq,$(words $(__tmp1)),$(words $(__tmp2))),$(call str.le,$1,$2),$(call str.le,$(words $(__tmp1)),$(words $(__tmp2))))

#num.ge = $(eval __tmp1 := $(call mklist,$1))$(eval __tmp2 := $(call mklist,$2))$(if $(call str.eq,$(words $(__tmp1)),$(words $(__tmp2))),$(call str.ge,$1,$2),$(call str.ge,$(words $(__tmp1)),$(words $(__tmp2))))

#Strip zeroes from the beginning of a list
list.strip = $(eval __flag := 1)$(foreach d,$1,$(if $(__flag),$(if $(subst 0,,$d),$(eval __flag :=)$d,$S),$d))
#Strip zeroes from the beginning of a number
#num.strip = $(subst $(SP),,$(call list.strip,$(call mklist,$1)))

# temp string: 0 - two number equals, L first LT, G first GT or second is short,
gen.cmpstr = $(eval __Tmp1 := $(subst ., ,$1))$(eval __Tmp2 := $(subst ., ,$2))$(foreach i,$(__Tmp1),$(eval j := $(word 1,$(__Tmp2)))$(if $j,$(if $(call str.eq,$i,$j),0,$(if $(call num.le,$i,$j),L,G)),G)$(eval __Tmp2 := $$(call shift,$(__Tmp2))))$(if $(__Tmp2), L)

ver.lt = $(call str.eq,$(word 1,$(call list.strip,$(call gen.cmpstr,$1,$2))),L)

all:
    echo ver.lt,1.20,1.3:$(call ver.lt,1.20,1.3)%
    echo ver.lt,1.5.9,1.5:$(call ver.lt,1.5.9,1.5)%
    echo ver.lt,1.4.9,1.5:$(call ver.lt,1.4.9,1.5)%
    echo ver.lt,1.2,1.2.0:$(call ver.lt,1.2,1.2.0)%
    echo ver.lt,1.20.3.4.5,1.10.5:$(call ver.lt,1.20.3.4.5,1.10.5)%
    echo ver.lt,1.20.3.4.5,1.0.5:$(call ver.lt,1.20.3.4.5,1.0.5)%
    echo ver.lt,1.0,1.0.5:$(call ver.lt,1.0,1.0.5)%
    echo ver.lt,1.20,1.10.3:$(call ver.lt,1.20,1.10.3)%
    echo ver.lt,1.20,1.30.3::$(call ver.lt,1.20,1.30.3)%
    echo ver.lt,1.10.3,1.10.3:$(call ver.lt,1.10.3,1.10.3)%

    Et la sortie

    ver.lt,1.20,1.3:%
ver.lt,1.5.9,1.5:%
ver.lt,1.4.9,1.5:T%
ver.lt,1.2,1.2.0:T%
ver.lt,1.20.3.4.5,1.10.5:%
ver.lt,1.20.3.4.5,1.0.5:%
ver.lt,1.0,1.0.5:T%
ver.lt,1.20,1.10.3:%
ver.lt,1.20,1.30.3::T%
ver.lt,1.10.3,1.10.3:%

    Plus de musique

    J'ai trouvé un autre projet intéressant appelé makepp (makepp.sourceforge.net). Il permet de mettre en œuvre de nouvelles fonctions en perl à l'intérieur du makefile.

  5. 1

    Que sur l'utilisation de la fonction de tri:

    ifeq "$(firstword $($(RH_VER_NUM),5.3))" "5.3"

    RH_GT_5_3 = 1

    endif

    (bien qu'il serait en fait de test pour un plus grand ou égal, mais vous voyez l'idée)

  6. 1

    Bravo à TrueY de venir avec une version qui n'utilise pas du tout cher de commandes du shell. J'ai une version plus simple qui compare uniquement 2 petits entiers (souvent à vous ne se soucient que de la version majeure).

    L'idée est tout simplement

    x > y

    = y, est membre de {0,1,2,3,4 ..., x - 1)

    Les membres de l'opérateur peuvent être mis en œuvre avec GNU make $(filtre) et de générer l'ensemble peut être réalisé avec $(liste de mots)

    # returns all integers less than x
LessThanSubset=$(wordlist 1,$(1),0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20)

# if x > y, return 1, empty otherwise
GreaterThan=$(if $(filter $(2),$(call LessThanSubset,$(1))),1)
GreaterOrEqual=$(if $(filter $(2),$(call LessThanSubset,$(1)) $(1)),1)

# example
$(error 5 > 4 = $(call GreaterThan,5,4))
  7. 0

    Une manière moderne serait d'obtenir la version en faire (à l'aide d'une coquille d'invocation), par exemple:

    SHELL := /bin/bash
# Define redhat_release as major_version * 100 + minor_version
redhat_release := $(shell [[ "$$(cat /etc/redhat-release)" =~ ([0-9]+)\.([0-9]+) ]] && echo $$(( $${BASH_REMATCH[1]} * 100 + $${BASH_REMATCH[2]} )))

    Et ensuite avoir la version des indicateurs spécifiques:

    # Flags for different redhat versions
redhat_flags.604 := abc
redhat_flags.605 := ${redhat_flags.604} def 
redhat_flags := ${redhat_flags.${redhat_release}}

    Et de les imprimer:

    $(info redhat_release=${redhat_release})
$(info redhat_flags=${redhat_flags})

    De sortie:

    $ make
redhat_release=605
redhat_flags=abc def