MAKEFLAGS

Twitter iPhone pliant OnePlus 11 PS5 Disney+ Orange Livebox Windows 11

Entraide Linux Autres OS Unix MAKEFLAGS

1 réponse

Thomas

28/05/2021 à 20:31

bonjour :-)

je ne comprend pas comment marche MAKEFLAGS en détails

il semble que cette doc ne soit pas parfaitement complète :
https://www.gnu.org/software/make/manual/html_node/Options_002fRecursion.
html
(est il nécessaire de mettre un lien court, ou tout le monde connait ?)

je trouve que ça serais très pratique, si ici :
https://www.gnu.org/software/make/manual/html_node/Options-Summary.html
les options étaient regroupées en au moins 2 groupes :

- celles qui sont traitées avant la lecture du makefile et qui
n'apparaissent pas dans MAKEFLAGS

- celles qui sont mises dans MAKEFLAGS avant la lecture du makefile, et
qui sont traitées Í partir de MAKEFLAGS entre les 2 phases de traitement
(Í préciser : comment c'est situé par rapport Í la seconde expansion)

Í moins qu'il y ait 2 fois le traitement : au début et au milieu ?

- selon les cas, un 3eme groupe pour celles qui auraient encore un
traitement différent :
apparemment -e apparait dans MAKEFLAGS, pourtant ça impacte la 1ere
phase de traitement, pas seulement la 2eme

si on fait
MAKEFLAGS := e
est ce que c'est traité immédiatement et change le traitement des lignes
suivantes, au milieu de la 1ere phase ?

si on fait

MAKEFLAGS := option

est ce que ça efface les autres options du 2eme groupe, celles données
sur la ligne de commande ?
et du coup, pour ne pas les effacer nous avons Í faire

MAKEFLAGS += option

?

ou bien est ce que celles données sur la ligne de commande sont traitées
avant, nous n'avons pas la possibilité de les effacer, et le MAKEFLAGS
est disponible pour
- nous informer d'un 1er lot d'options traitées
- faire un 2eme lot d'options Í traiter après
?

pour la curiosité, est ce que qqn a déjÍ fait :

# MAKEOVERRIDES := $(MAKEOVERRIDES)
# test-MAKEFLAGS: MAKEOVERRIDES := $(MAKEOVERRIDES)
# MAKEOVERRIDES :# test-MAKEFLAGS: MAKEOVERRIDES :
# MAKEFLAGS := $(MAKEFLAGS)
# test-MAKEFLAGS: MAKEFLAGS := $(MAKEFLAGS)
# MAKEFLAGS :# test-MAKEFLAGS: MAKEFLAGS :

test-MAKEFLAGS:
$(info recipe -flavor-MAKEOVERRIDES = $(flavor MAKEOVERRIDES))
$(info recipe -value -MAKEOVERRIDES = $(value MAKEOVERRIDES))
$(info recipe -flavor-MAKEFLAGS = $(flavor MAKEFLAGS))
$(info recipe -value -MAKEFLAGS = $(value MAKEFLAGS))
@echo "echo -MAKEOVERRIDES = $$MAKEOVERRIDES"
@echo "echo -MAKEFLAGS = $$MAKEFLAGS"

test-MAKEFLAGS: $(info prerequ -flavor-MAKEOVERRIDES = $(flavor
MAKEOVERRIDES))
test-MAKEFLAGS: $(info prerequ -value -MAKEOVERRIDES = $(value
MAKEOVERRIDES))
test-MAKEFLAGS: $(info prerequ -flavor-MAKEFLAGS = $(flavor
MAKEFLAGS))
test-MAKEFLAGS: $(info prerequ -value -MAKEFLAGS = $(value
MAKEFLAGS))

test-MAKEFLAGS: v:= $(info targetvar-flavor-MAKEOVERRIDES = $(flavor
MAKEOVERRIDES))
test-MAKEFLAGS: v:= $(info targetvar-value -MAKEOVERRIDES = $(value
MAKEOVERRIDES))
test-MAKEFLAGS: v:= $(info targetvar-flavor-MAKEFLAGS = $(flavor
MAKEFLAGS))
test-MAKEFLAGS: v:= $(info targetvar-value -MAKEFLAGS = $(value
MAKEFLAGS))

$(info widevar -flavor-MAKEOVERRIDES = $(flavor MAKEOVERRIDES))
$(info widevar -value -MAKEOVERRIDES = $(value MAKEOVERRIDES))
$(info widevar -flavor-MAKEFLAGS = $(flavor MAKEFLAGS))
$(info widevar -value -MAKEFLAGS = $(value MAKEFLAGS))

$ make test-MAKEFLAGS var=val -k
prerequ -flavor-MAKEOVERRIDES = recursive
prerequ -value -MAKEOVERRIDES = ${-*-command-variables-*-}
prerequ -flavor-MAKEFLAGS = recursive
prerequ -value -MAKEFLAGS = k
targetvar-flavor-MAKEOVERRIDES = recursive
targetvar-value -MAKEOVERRIDES = ${-*-command-variables-*-}
targetvar-flavor-MAKEFLAGS = recursive
targetvar-value -MAKEFLAGS = k
widevar -flavor-MAKEOVERRIDES = recursive
widevar -value -MAKEOVERRIDES = ${-*-command-variables-*-}
widevar -flavor-MAKEFLAGS = recursive
widevar -value -MAKEFLAGS = k
recipe -flavor-MAKEOVERRIDES = recursive
recipe -value -MAKEOVERRIDES = ${-*-command-variables-*-}
recipe -flavor-MAKEFLAGS = recursive
recipe -value -MAKEFLAGS = k -- $(MAKEOVERRIDES)
echo -MAKEOVERRIDES = ${-*-command-variables-*-}
echo -MAKEFLAGS = k -- var=val

--
RAPID maintainer
http://savannah.nongnu.org/projects/rapid/

1 réponse

Thomas

29/05/2021 à 01:52

In article
,
Thomas wrote:

pour la curiosité, est ce que qqn a déjÍ fait :
# MAKEOVERRIDES := $(MAKEOVERRIDES)
# test-MAKEFLAGS: MAKEOVERRIDES := $(MAKEOVERRIDES)
# MAKEOVERRIDES :> # test-MAKEFLAGS: MAKEOVERRIDES :>
# MAKEFLAGS := $(MAKEFLAGS)
# test-MAKEFLAGS: MAKEFLAGS := $(MAKEFLAGS)
# MAKEFLAGS :> # test-MAKEFLAGS: MAKEFLAGS :>
test-MAKEFLAGS:
$(info recipe -flavor-MAKEOVERRIDES = $(flavor MAKEOVERRIDES))
$(info recipe -value -MAKEOVERRIDES = $(value MAKEOVERRIDES))
$(info recipe -flavor-MAKEFLAGS = $(flavor MAKEFLAGS))
$(info recipe -value -MAKEFLAGS = $(value MAKEFLAGS))
@echo "echo -MAKEOVERRIDES = $$MAKEOVERRIDES"
@echo "echo -MAKEFLAGS = $$MAKEFLAGS"
test-MAKEFLAGS: $(info prerequ -flavor-MAKEOVERRIDES = $(flavor MAKEOVERRIDES))
test-MAKEFLAGS: $(info prerequ -value -MAKEOVERRIDES = $(value MAKEOVERRIDES))
test-MAKEFLAGS: $(info prerequ -flavor-MAKEFLAGS = $(flavor MAKEFLAGS))
test-MAKEFLAGS: $(info prerequ -value -MAKEFLAGS = $(value MAKEFLAGS))
test-MAKEFLAGS: v:= $(info targetvar-flavor-MAKEOVERRIDES = $(flavor MAKEOVERRIDES))
test-MAKEFLAGS: v:= $(info targetvar-value -MAKEOVERRIDES = $(value MAKEOVERRIDES))
test-MAKEFLAGS: v:= $(info targetvar-flavor-MAKEFLAGS = $(flavor MAKEFLAGS))
test-MAKEFLAGS: v:= $(info targetvar-value -MAKEFLAGS = $(value MAKEFLAGS))
$(info widevar -flavor-MAKEOVERRIDES = $(flavor MAKEOVERRIDES))
$(info widevar -value -MAKEOVERRIDES = $(value MAKEOVERRIDES))
$(info widevar -flavor-MAKEFLAGS = $(flavor MAKEFLAGS))
$(info widevar -value -MAKEFLAGS = $(value MAKEFLAGS))

je n'ai pas pu m'empêcher de le factoriser, même si ça sert Í rien ...
c'est marrant, ça ressemble un peu Í des maths,
mais c'est plus simple : le logiciel nous informe si on s'est trompé
qqpart en ne donnant pas le résultat attendu :-D
(je n'ai pas réfléchi au banc de tests qui permettrait de tester les 256
combinaisons possibles (ou moins parce que certaines sont inutiles) en
un seul appel Í make :-P )
j'en ai profité pour ajouter la fonction origin, qui elle aussi est
surprenante ...
il reste une nouvelle question qui est survenue :
pourquoi ce qui marche pour les variables ne marche pas pour les
fonctions ?
https://www.gnu.org/software/make/manual/html_node/Computed-Names.html
https://www.gnu.org/software/make/manual/html_node/Call-Function.html
par ex dans function-res, j'aurais économisé le "call"
# MAKEOVERRIDES := $(MAKEOVERRIDES)
# test-MAKEFLAGS: MAKEOVERRIDES := $(MAKEOVERRIDES)
# MAKEOVERRIDES :# test-MAKEFLAGS: MAKEOVERRIDES :
# MAKEFLAGS := $(MAKEFLAGS)
# test-MAKEFLAGS: MAKEFLAGS := $(MAKEFLAGS)
# MAKEFLAGS :# test-MAKEFLAGS: MAKEFLAGS :
vars := MAKEOVERRIDES MAKEFLAGS....
functs := origin flavor value.
function-res = $(call $1,$(strip $2))
function-info = $(info $1 - $2 - $3 = $(call function-res,$2,$3))
function-foreach =
$(foreach v,$($1),$(call $2,$3,$(subst ., ,$v),$4))$(info )
function-ciment = $(call function-foreach,functs,function-info,$1,$2)
function-glob = $(call function-foreach,vars,function-ciment,$1)
# function-glob =
$(foreach v,$(vars),$(foreach f,$(functs),$(call
function-info,$1,$(subst ., ,$f),$(subst ., ,$v)))$(info ))$(info )
test-MAKEFLAGS:
$(call function-glob,recipe )
@echo "echo - MAKEOVERRIDES = $$MAKEOVERRIDES"
@echo "echo - MAKEFLAGS = $$MAKEFLAGS"
test-MAKEFLAGS: $(call function-glob,prerequ )
test-MAKEFLAGS: v:= $(call function-glob,targetvar)
$(call function-glob,widevar )
$ make test-MAKEFLAGS var=val -k
prerequ - origin - MAKEOVERRIDES = environment
prerequ - flavor - MAKEOVERRIDES = recursive
prerequ - value - MAKEOVERRIDES = ${-*-command-variables-*-}
prerequ - origin - MAKEFLAGS = file
prerequ - flavor - MAKEFLAGS = recursive
prerequ - value - MAKEFLAGS = k
targetvar - origin - MAKEOVERRIDES = environment
targetvar - flavor - MAKEOVERRIDES = recursive
targetvar - value - MAKEOVERRIDES = ${-*-command-variables-*-}
targetvar - origin - MAKEFLAGS = file
targetvar - flavor - MAKEFLAGS = recursive
targetvar - value - MAKEFLAGS = k
widevar - origin - MAKEOVERRIDES = environment
widevar - flavor - MAKEOVERRIDES = recursive
widevar - value - MAKEOVERRIDES = ${-*-command-variables-*-}
widevar - origin - MAKEFLAGS = file
widevar - flavor - MAKEFLAGS = recursive
widevar - value - MAKEFLAGS = k
recipe - origin - MAKEOVERRIDES = environment
recipe - flavor - MAKEOVERRIDES = recursive
recipe - value - MAKEOVERRIDES = ${-*-command-variables-*-}
recipe - origin - MAKEFLAGS = file
recipe - flavor - MAKEFLAGS = recursive
recipe - value - MAKEFLAGS = k -- $(MAKEOVERRIDES)
echo - MAKEOVERRIDES = ${-*-command-variables-*-}
echo - MAKEFLAGS = k -- var=val
--
RAPID maintainer
http://savannah.nongnu.org/projects/rapid/

In article
<fantome.forums.tDeContes-8416B7.20311028052021@news.free.fr>,
Thomas <fantome.forums.tDeContes@free.fr.invalid> wrote:

pour la curiosité, est ce que qqn a déjÍ fait :

# MAKEOVERRIDES := $(MAKEOVERRIDES)
# test-MAKEFLAGS: MAKEOVERRIDES := $(MAKEOVERRIDES)
# MAKEOVERRIDES :> # test-MAKEFLAGS: MAKEOVERRIDES :>
# MAKEFLAGS := $(MAKEFLAGS)
# test-MAKEFLAGS: MAKEFLAGS := $(MAKEFLAGS)
# MAKEFLAGS :> # test-MAKEFLAGS: MAKEFLAGS :>

test-MAKEFLAGS:
$(info recipe -flavor-MAKEOVERRIDES = $(flavor MAKEOVERRIDES))
$(info recipe -value -MAKEOVERRIDES = $(value MAKEOVERRIDES))
$(info recipe -flavor-MAKEFLAGS = $(flavor MAKEFLAGS))
$(info recipe -value -MAKEFLAGS = $(value MAKEFLAGS))
@echo "echo -MAKEOVERRIDES = $$MAKEOVERRIDES"
@echo "echo -MAKEFLAGS = $$MAKEFLAGS"

test-MAKEFLAGS: $(info prerequ -flavor-MAKEOVERRIDES = $(flavor MAKEOVERRIDES))
test-MAKEFLAGS: $(info prerequ -value -MAKEOVERRIDES = $(value MAKEOVERRIDES))
test-MAKEFLAGS: $(info prerequ -flavor-MAKEFLAGS = $(flavor MAKEFLAGS))
test-MAKEFLAGS: $(info prerequ -value -MAKEFLAGS = $(value MAKEFLAGS))

test-MAKEFLAGS: v:= $(info targetvar-flavor-MAKEOVERRIDES = $(flavor MAKEOVERRIDES))
test-MAKEFLAGS: v:= $(info targetvar-value -MAKEOVERRIDES = $(value MAKEOVERRIDES))
test-MAKEFLAGS: v:= $(info targetvar-flavor-MAKEFLAGS = $(flavor MAKEFLAGS))
test-MAKEFLAGS: v:= $(info targetvar-value -MAKEFLAGS = $(value MAKEFLAGS))

$(info widevar -flavor-MAKEOVERRIDES = $(flavor MAKEOVERRIDES))
$(info widevar -value -MAKEOVERRIDES = $(value MAKEOVERRIDES))
$(info widevar -flavor-MAKEFLAGS = $(flavor MAKEFLAGS))
$(info widevar -value -MAKEFLAGS = $(value MAKEFLAGS))

je n'ai pas pu m'empêcher de le factoriser, même si ça sert Í rien ...

c'est marrant, ça ressemble un peu Í des maths,
mais c'est plus simple : le logiciel nous informe si on s'est trompé
qqpart en ne donnant pas le résultat attendu :-D

(je n'ai pas réfléchi au banc de tests qui permettrait de tester les 256
combinaisons possibles (ou moins parce que certaines sont inutiles) en
un seul appel Í make :-P )

j'en ai profité pour ajouter la fonction origin, qui elle aussi est
surprenante ...

il reste une nouvelle question qui est survenue :
pourquoi ce qui marche pour les variables ne marche pas pour les
fonctions ?

https://www.gnu.org/software/make/manual/html_node/Computed-Names.html
https://www.gnu.org/software/make/manual/html_node/Call-Function.html

par ex dans function-res, j'aurais économisé le "call"

# MAKEOVERRIDES := $(MAKEOVERRIDES)
# test-MAKEFLAGS: MAKEOVERRIDES := $(MAKEOVERRIDES)
# MAKEOVERRIDES :# test-MAKEFLAGS: MAKEOVERRIDES :
# MAKEFLAGS := $(MAKEFLAGS)
# test-MAKEFLAGS: MAKEFLAGS := $(MAKEFLAGS)
# MAKEFLAGS :# test-MAKEFLAGS: MAKEFLAGS :

vars := MAKEOVERRIDES MAKEFLAGS....
functs := origin flavor value.

function-res = $(call $1,$(strip $2))
function-info = $(info $1 - $2 - $3 = $(call function-res,$2,$3))

function-foreach =
$(foreach v,$($1),$(call $2,$3,$(subst ., ,$v),$4))$(info )

function-ciment = $(call function-foreach,functs,function-info,$1,$2)
function-glob = $(call function-foreach,vars,function-ciment,$1)

# function-glob =
$(foreach v,$(vars),$(foreach f,$(functs),$(call
function-info,$1,$(subst ., ,$f),$(subst ., ,$v)))$(info ))$(info )

test-MAKEFLAGS:
$(call function-glob,recipe )
@echo "echo - MAKEOVERRIDES = $$MAKEOVERRIDES"
@echo "echo - MAKEFLAGS = $$MAKEFLAGS"

test-MAKEFLAGS: $(call function-glob,prerequ )

test-MAKEFLAGS: v:= $(call function-glob,targetvar)

$(call function-glob,widevar )

$ make test-MAKEFLAGS var=val -k
prerequ - origin - MAKEOVERRIDES = environment
prerequ - flavor - MAKEOVERRIDES = recursive
prerequ - value - MAKEOVERRIDES = ${-*-command-variables-*-}

prerequ - origin - MAKEFLAGS = file
prerequ - flavor - MAKEFLAGS = recursive
prerequ - value - MAKEFLAGS = k

targetvar - origin - MAKEOVERRIDES = environment
targetvar - flavor - MAKEOVERRIDES = recursive
targetvar - value - MAKEOVERRIDES = ${-*-command-variables-*-}

targetvar - origin - MAKEFLAGS = file
targetvar - flavor - MAKEFLAGS = recursive
targetvar - value - MAKEFLAGS = k

widevar - origin - MAKEOVERRIDES = environment
widevar - flavor - MAKEOVERRIDES = recursive
widevar - value - MAKEOVERRIDES = ${-*-command-variables-*-}

widevar - origin - MAKEFLAGS = file
widevar - flavor - MAKEFLAGS = recursive
widevar - value - MAKEFLAGS = k

recipe - origin - MAKEOVERRIDES = environment
recipe - flavor - MAKEOVERRIDES = recursive
recipe - value - MAKEOVERRIDES = ${-*-command-variables-*-}

recipe - origin - MAKEFLAGS = file
recipe - flavor - MAKEFLAGS = recursive
recipe - value - MAKEFLAGS = k -- $(MAKEOVERRIDES)

echo - MAKEOVERRIDES = ${-*-command-variables-*-}
echo - MAKEFLAGS = k -- var=val

--
RAPID maintainer
http://savannah.nongnu.org/projects/rapid/

Vous avez filtré cet utilisateur ! Consultez son message

In article
,
Thomas wrote:

pour la curiosité, est ce que qqn a déjÍ fait :
# MAKEOVERRIDES := $(MAKEOVERRIDES)
# test-MAKEFLAGS: MAKEOVERRIDES := $(MAKEOVERRIDES)
# MAKEOVERRIDES :> # test-MAKEFLAGS: MAKEOVERRIDES :>
# MAKEFLAGS := $(MAKEFLAGS)
# test-MAKEFLAGS: MAKEFLAGS := $(MAKEFLAGS)
# MAKEFLAGS :> # test-MAKEFLAGS: MAKEFLAGS :>
test-MAKEFLAGS:
$(info recipe -flavor-MAKEOVERRIDES = $(flavor MAKEOVERRIDES))
$(info recipe -value -MAKEOVERRIDES = $(value MAKEOVERRIDES))
$(info recipe -flavor-MAKEFLAGS = $(flavor MAKEFLAGS))
$(info recipe -value -MAKEFLAGS = $(value MAKEFLAGS))
@echo "echo -MAKEOVERRIDES = $$MAKEOVERRIDES"
@echo "echo -MAKEFLAGS = $$MAKEFLAGS"
test-MAKEFLAGS: $(info prerequ -flavor-MAKEOVERRIDES = $(flavor MAKEOVERRIDES))
test-MAKEFLAGS: $(info prerequ -value -MAKEOVERRIDES = $(value MAKEOVERRIDES))
test-MAKEFLAGS: $(info prerequ -flavor-MAKEFLAGS = $(flavor MAKEFLAGS))
test-MAKEFLAGS: $(info prerequ -value -MAKEFLAGS = $(value MAKEFLAGS))
test-MAKEFLAGS: v:= $(info targetvar-flavor-MAKEOVERRIDES = $(flavor MAKEOVERRIDES))
test-MAKEFLAGS: v:= $(info targetvar-value -MAKEOVERRIDES = $(value MAKEOVERRIDES))
test-MAKEFLAGS: v:= $(info targetvar-flavor-MAKEFLAGS = $(flavor MAKEFLAGS))
test-MAKEFLAGS: v:= $(info targetvar-value -MAKEFLAGS = $(value MAKEFLAGS))
$(info widevar -flavor-MAKEOVERRIDES = $(flavor MAKEOVERRIDES))
$(info widevar -value -MAKEOVERRIDES = $(value MAKEOVERRIDES))
$(info widevar -flavor-MAKEFLAGS = $(flavor MAKEFLAGS))
$(info widevar -value -MAKEFLAGS = $(value MAKEFLAGS))

je n'ai pas pu m'empêcher de le factoriser, même si ça sert Í rien ...
c'est marrant, ça ressemble un peu Í des maths,
mais c'est plus simple : le logiciel nous informe si on s'est trompé
qqpart en ne donnant pas le résultat attendu :-D
(je n'ai pas réfléchi au banc de tests qui permettrait de tester les 256
combinaisons possibles (ou moins parce que certaines sont inutiles) en
un seul appel Í make :-P )
j'en ai profité pour ajouter la fonction origin, qui elle aussi est
surprenante ...
il reste une nouvelle question qui est survenue :
pourquoi ce qui marche pour les variables ne marche pas pour les
fonctions ?
https://www.gnu.org/software/make/manual/html_node/Computed-Names.html
https://www.gnu.org/software/make/manual/html_node/Call-Function.html
par ex dans function-res, j'aurais économisé le "call"
# MAKEOVERRIDES := $(MAKEOVERRIDES)
# test-MAKEFLAGS: MAKEOVERRIDES := $(MAKEOVERRIDES)
# MAKEOVERRIDES :# test-MAKEFLAGS: MAKEOVERRIDES :
# MAKEFLAGS := $(MAKEFLAGS)
# test-MAKEFLAGS: MAKEFLAGS := $(MAKEFLAGS)
# MAKEFLAGS :# test-MAKEFLAGS: MAKEFLAGS :
vars := MAKEOVERRIDES MAKEFLAGS....
functs := origin flavor value.
function-res = $(call $1,$(strip $2))
function-info = $(info $1 - $2 - $3 = $(call function-res,$2,$3))
function-foreach =
$(foreach v,$($1),$(call $2,$3,$(subst ., ,$v),$4))$(info )
function-ciment = $(call function-foreach,functs,function-info,$1,$2)
function-glob = $(call function-foreach,vars,function-ciment,$1)
# function-glob =
$(foreach v,$(vars),$(foreach f,$(functs),$(call
function-info,$1,$(subst ., ,$f),$(subst ., ,$v)))$(info ))$(info )
test-MAKEFLAGS:
$(call function-glob,recipe )
@echo "echo - MAKEOVERRIDES = $$MAKEOVERRIDES"
@echo "echo - MAKEFLAGS = $$MAKEFLAGS"
test-MAKEFLAGS: $(call function-glob,prerequ )
test-MAKEFLAGS: v:= $(call function-glob,targetvar)
$(call function-glob,widevar )
$ make test-MAKEFLAGS var=val -k
prerequ - origin - MAKEOVERRIDES = environment
prerequ - flavor - MAKEOVERRIDES = recursive
prerequ - value - MAKEOVERRIDES = ${-*-command-variables-*-}
prerequ - origin - MAKEFLAGS = file
prerequ - flavor - MAKEFLAGS = recursive
prerequ - value - MAKEFLAGS = k
targetvar - origin - MAKEOVERRIDES = environment
targetvar - flavor - MAKEOVERRIDES = recursive
targetvar - value - MAKEOVERRIDES = ${-*-command-variables-*-}
targetvar - origin - MAKEFLAGS = file
targetvar - flavor - MAKEFLAGS = recursive
targetvar - value - MAKEFLAGS = k
widevar - origin - MAKEOVERRIDES = environment
widevar - flavor - MAKEOVERRIDES = recursive
widevar - value - MAKEOVERRIDES = ${-*-command-variables-*-}
widevar - origin - MAKEFLAGS = file
widevar - flavor - MAKEFLAGS = recursive
widevar - value - MAKEFLAGS = k
recipe - origin - MAKEOVERRIDES = environment
recipe - flavor - MAKEOVERRIDES = recursive
recipe - value - MAKEOVERRIDES = ${-*-command-variables-*-}
recipe - origin - MAKEFLAGS = file
recipe - flavor - MAKEFLAGS = recursive
recipe - value - MAKEFLAGS = k -- $(MAKEOVERRIDES)
echo - MAKEOVERRIDES = ${-*-command-variables-*-}
echo - MAKEFLAGS = k -- var=val
--
RAPID maintainer
http://savannah.nongnu.org/projects/rapid/

MAKEFLAGS

1 réponse

Veuillez sélectionner un problème