makepp_variables - En ligne dans le Cloud

PROGRAMME:

Nom

makepp_variables -- Comment utiliser les variables dans makepp

DESCRIPTION

?: $*,
$+,
$/,
$<,
$ ?,
$@,
$^,
=,
!=,
&=,
+=,
:=,
;=,
?=, A: AR,
ARFLAG,
COMME, C: cc,
FLAG,
"dépendances_modifiées",
entrées_modifiées,
CURDIR,
CXX,
CXXFLAGS, D: "dépendances",
"dépendance", F: F77,
FC,
"pour chaque", I: contribution,
entrées, L: LD,
LEX,
LIBTOOL, M: FABRIQUER,
FAIRE DES OBJECTIFS,
FAIRE DES DRAPEAU,
FAIREINFO,
MAKEPP_DEBUG,
MARQUEPPFLAGS,
_MAKEPPFLAGS,
MAKEPP_LN_CP,
"makepp_percent_subdirs",
"makepp_require_phony",
makepp_signature_C_flat,
"makepp_simple_concaténation",
MAKEPP_VERSION, O: "sortir",
"les sorties", P: PERLE,
personne handicapée, R: IRM,
RACINE, S: COQUILLE,
"dépendances_triées",
entrées_triées,
"tige", T: cible,
cibles, V: VPATH, Y: YACC

Les makefiles utilisent généralement des variables à de nombreux endroits. Une raison importante d'utiliser
variables est de s'assurer que les informations sont contenues dans un seul endroit dans le makefile, donc
que si cela change, il n'y a aucun risque que les deux copies des informations sortent de
synchroniser.

Les noms de variables sont sensibles à la casse. En théorie, les noms de variables peuvent être composés de plusieurs
personnages, mais makepp ne pourra probablement pas le détecter si vous faites autre chose que
caractères alphanumériques, "_" et "-".

Chaque makefile a son propre ensemble de variables, et la définition d'une variable dans un makefile sera
n'ont aucun effet sur sa valeur dans tout autre makefile. Si vous souhaitez définir des variables dans
de nombreux makefiles, la meilleure façon de le faire est que chacun d'eux inclue une définition commune
(voir l'instruction include) ou utilisez des variables "globales".

Variable Affectation
Une variable peut prendre une valeur de plusieurs manières différentes :

· Une variable peut être définie à l'intérieur d'un makefile. Il y a plusieurs façons de faire
cette; voir ci-dessous.

· La valeur d'une variable peut être spécifiée sur la ligne de commande, comme ceci :

makepp CFLAGS=-O2 mon_programme

Si plus d'un makefile est chargé, la variable CFLAGS est propagée à tous les
makefiles. Les variables définies sur la ligne de commande remplacent automatiquement tout paramètre de
la variable dans l'un des makefiles.

Si jamais nécessaire, le makefile doit à son tour écraser explicitement les paramètres de la ligne de commande.
L'intention n'est pas d'ignorer ce que demande l'utilisateur, mais plutôt un moyen de le modifier.
Le modificateur "override" peut précéder toute instruction d'affectation. Mais dans le cas de
instructions de mot-clé, l'ordre est important, c'est pourquoi la variante de remplacement est
toujours montré ci-dessous. Le modificateur "override" s'applique uniquement à toutes les affectations où il
est présent et n'influence pas les affectations ultérieures à la variable.

· Si une variable est définie dans l'environnement, elle peut être référencée en tant que variable makepp.
Normalement, les affectations aux variables à l'intérieur d'un makefile remplacent les paramètres du
environnement, mais vous pouvez changer cela en utilisant le "-e" ou "--environment-overrides"
commande option de ligne.

Les variables sont affectées avec l'une des nombreuses expressions d'affectation, comme celle-ci

X = 1
MODULES := abcd
CC ?= gcc
FLAG += -Mur
définir VAR
var ligne 1
var ligne 2
fin def
export CHEMIN := $(PWD):$(CHEMIN)
global MYPROJECT.INFO = info à voir dans tous les makefiles

Les espaces de début et de fin autour des valeurs sont toujours supprimés.

Les différents opérateurs d'affectation ont des significations quelque peu différentes.

étapes affectation opérateurs

=
VARIABLE = chaîne de texte
remplacer VARIABLE = chaîne de texte

Il s'agit de l'instruction d'affectation habituelle que toutes les implémentations de make prennent en charge. Les
l'expression du côté droit n'est pas évaluée tant que la valeur de "$(VARIABLE)" n'est pas
effectivement utilisé quelque part. Ainsi, si vous procédez comme suit :

X = 1
Oui = $(X)
X = 2

Ensuite, "$(Y)" plus tard dans le makefile sera évalué à "2".

En général, vous souhaitez généralement utiliser ":=" (voir ci-dessous) au lieu de "=" car il
fournit une évaluation des variables plus prévisible. Cependant, il y a des moments où vous avez besoin
de différer l'évaluation de la variable. De plus, si vous écrivez un makefile qui doit être
rétrocompatible avec une version de make autre que GNU make, alors vous n'avez pas
choix : vous ne pouvez utiliser que "=".

:=
VARIABLE := expression
remplacer VARIABLE := expr

C'est la même chose que "VARIABLE = expr" sauf que le côté droit est évalué
une fois pour toutes au moment de la mission. Ainsi si

X: = 1
Oui := $(X)
X: = 2

puis "$(Y)" plus tard dans le makefile sera évalué à "1" puisque c'est ce que "$(X)" était
lorsque "$(Y)" a été défini.

;=
VARIABLE ;= expression
remplacer VARIABLE ;= expr

C'est la même chose que "VARIABLE := expr" sauf que le côté droit est évalué
seulement au moment de la première utilisation et ensuite rappelé. C'est utile pour cher
commandes, qui renvoient toujours la même valeur, mais que vous ne souhaitez pas exécuter lorsque
construire des cibles indépendantes :

VAR1 ;= $(calculs coûteux en perl)
VAR2 ;= $(commande externe shell)

Notez que les anciens makefiles utiliseront généralement ":=" ici, pour ne le faire au moins qu'une seule fois.
Mais avec cet opérateur, vous pouvez également ne pas le faire, si vous ne le faites pas actuellement.
besoin de la valeur. Pour des valeurs identiques dans plusieurs répertoires, vous pouvez
optimisez cela davantage avec "global", discuté ci-dessous.

Cependant, il ne s'agit pas d'un moyen intelligent de forcer l'ordre d'évaluation. Si un
variable définie comme ceci inclut la valeur d'une autre variable, et cette autre
a une valeur spécifique à la cible, et la première extension est pour cette cible, puis le
la valeur spécifique à la cible restera également dans tous les autres contextes. C'est un bug et
sera, espérons-le, corrigé à l'avenir.

+=
VARIABLE += expression
remplacer VARIABLE += expr

Ajoute la chaîne au contenu précédent de la variable, séparé par un espace. Si
la variable a été précédemment affectée avec ":=", alors le côté droit est évalué
avant d'ajouter.

&=
VARIABLE &= expr
remplacer VARIABLE &= expr

Ajoute la chaîne au contenu précédent de la variable, séparé par un espace.
Si la variable a été précédemment affectée avec ":=", alors le côté droit est
évalué avant l'ajout.

Par exemple, une manière de garantir que "CFLAGS", quoi que l'utilisateur puisse y ajouter,
commence toujours par "-Wall" sont ces deux lignes :

CFLAGS = -O2 # Éventuellement remplacé sur la ligne de commande
remplacer CFLAGS &= -Wall # Préfixé inconditionnellement

Dans les anciens makefiles, vous deviez généralement faire quelque chose comme ça, qui avait le côté
effet de forcer le type à ":=" pour éviter une récursivité sans fin :

VARIABLE := expression $(VARIABLE)

?=
VARIABLE ?= expression
override VARIABLE ?= expr # Inutile, mais légal

Définit la valeur de la variable, mais seulement si la variable n'est pas spécifiée plus tôt dans
le makefile, sur la ligne de commande ou dans l'environnement. La mission ci-dessus est
exactement équivalent à

ifndef VARIABLE
VARIABLE = expression
fin si

!=
VARIABLE != commande shell
remplacer VARIABLE != commande shell

Exécute la commande shell et définit la variable pour qu'elle contienne la sortie standard de la commande.
C'est exactement l'équivalent de

VARIABLE := $(commande shell)

Multiligne les variables

L'instruction "define" est l'équivalent multiligne des instructions simples ci-dessus. Les
l'opérateur après la variable est facultatif. S'il est manquant, il équivaut à "définir VARIABLE
=". Les opérateurs "&=" et "+=" sont légèrement différents ici, en ce sens qu'ils collent ceci à
l'ancienne valeur avec une nouvelle ligne, plutôt qu'un espace. Il ne doit y avoir rien d'autre qu'un
commentaire après l'instruction, c'est-à-dire que la valeur commence sur la ligne suivante.

définir VARIABLE :=
première ligne de la valeur de la variable
deuxième ligne de la valeur de la variable
troisième ligne de la valeur de la variable
endéf

remplacer définir VARIABLE

fin def

Les mots clés avant « définir » peuvent être des combinaisons de « exporter » ou « global » et
"passer outre".

Si vous avez besoin que la valeur d'une variable contienne des sauts de ligne, vous devez utiliser l'instruction "define" comme
affiché (ou vous pouvez affecter la valeur directement dans Perl). ("endef" a été choisi pour
compatibilité avec GNU make. Vous pouvez également utiliser "enddef".) Ceci est principalement utile pour
« séquences de commandes prédéfinies », par exemple, quelque chose comme ceci :

définir COMPILE_C_PROGRAM
@&echo "Compilation de $(entrée)"
@$(CC) $(CFLAGS) $(CPPFLAGS) $(INCLUDES) -c $(entrée) -o $(sortie)
endéf

Ensuite, vous pouvez utiliser cette variable multiligne dans plusieurs règles, comme celle-ci :

%.o : %.c
$(COMPILE_C_PROGRAMME)

$(ARCH)/%.o : $(ARCH)/%.c
$(COMPILE_C_PROGRAMME)

Notez que vous pouvez souvent obtenir le même effet en utilisant un point-virgule au lieu d'une nouvelle ligne,
parce que le shell interprète cela aussi comme un délimiteur de commande. Par exemple,

COMPILE_C_PROGRAM = @echo "Compilation $(entrée)" ; \
$(CC) $(CFLAGS) $(CPPFLAGS) $(INCLUDES) -c $(entrée) -o $(sortie)

aura le même effet, sauf que le point-virgule force Perl à le passer au shell,
au lieu d'exécuter la commande directement et plus efficacement. Vous devez également mettre chaque
intégré sur une ligne qui lui est propre, ce qui signifie que vous devez passer à l'écho externe dans le
cas du point-virgule.

Il y a une spécialité lors de l'expansion dans "define", c'est-à-dire "define X :=" ou sur un
variable qui était déjà ":=", "define X &=" et "define X +=". Dans ce cas le
"$(shell command ...)" ou "$(&command ...)" intégré n'obtiennent pas de nouvelles lignes transformées en
les espaces.

Exportation les variables à sous-processus

exporter VAR ...
exporter VAR = valeur
remplacer l'exportation VAR += valeur

La première forme marque les variables données pour l'exportation vers les sous-processus, avec n'importe quelle valeur
la variable a alors. La seconde forme, qui ne s'applique qu'à une seule variable, en plus
attribue immédiatement une valeur. Toutes les variantes d'affectation sont autorisées.

Partager les variables à travers fichiers make

VAR globale...
VAR global = valeur
remplacer la valeur globale VAR &=

La première forme marque les variables données comme globales pour tous les makefiles. Si l'un d'eux
avait déjà une valeur, cette valeur est déplacée de la variable locale makefile vers la variable globale
une. Cependant, si, au moment où cette instruction est vue, d'autres makefiles avaient déjà un
valeur pour l'un d'entre eux, alors ces makefiles ne verront pas le global.

La seconde forme, qui ne s'applique qu'à une seule variable, attribue en plus un droit à la valeur
une façon. Toutes les variantes d'affectation sont autorisées. Notez que ":=" se développera immédiatement
aux valeurs du makefile local. Au contraire, les variables "=" s'étendront jusqu'au
valeurs au point d'utilisation.

Les variables globales peuvent être difficiles à gérer, car makepp peut charger des makefiles dans n'importe quel
ordre, car le besoin se fait sentir de construire une cible pour laquelle aucune règle ou fichier makefile n'est chargé.
Pour cette raison, il est recommandé d'avoir un Fichier RootMakepp et pour charger explicitement tous
d'autres qui modifient ou utilisent la variable avec "load-makefile".

GLIBLIBS global ;= $(shell pkg-config --libs glib-2.0)

Sachez également que votre projet pourra un jour être construit avec d'autres projets. Pour ça
C'est pourquoi il est recommandé de toujours faire du nom de projet une partie de tout nom de variable globale.

Spécifique à la cible missions

cible : VARIABLE = chaîne
cible : VARIABLE := chaîne
cible : remplacer VARIABLE += chaîne

Définit une valeur spécifique à la cible de la variable. Une valeur spécifique à la cible est en vigueur uniquement
dans une action qui produit la cible donnée. Ceci est principalement utilisé pour des choses comme
ce:

CLAPET := -O2

mon_prog : fichier1.o fichier2.o fichier_spécial.o

fichier_spécial.o : CFLAGS := -g

%.o : %c
$(CC) $(CFLAGS) -c $(entrée) -o $(sortie)

Ce qui se passe ici, c'est que tous les fichiers ".c" seront compilés avec optimisation ("-O2") sauf
"special_file.c", qui est compilé en mode débogage ("-g"). C'est un moyen pratique de
spécifiez différentes options de compilation pour quelques fichiers seulement.

Les affectations de variables spécifiques à la cible comme celle-ci s'appliquent uniquement aux actions de la règle ; elles ou ils
ne sont pas en vigueur lors de l'évaluation des cibles ou des dépendances d'une règle. Si une règle
a plus d'une cible, les affectations de variables spécifiques à la cible sont prises uniquement à partir du
premier cible. Notez également que les variables spécifiques à la cible de makepp sont légèrement différentes
de GNU make's en ce qu'ils ne s'appliquent qu'à la règle pour le fichier mentionné, et non à
aucun de ses prédécesseurs.

L'expansion des caractères génériques est effectuée sur la cible, vous pouvez donc faire quelque chose comme ceci :

test_*.o : CFLAGS += -DTEST

Pour la compatibilité avec GNU make, "%" peut être utilisé à la place de "*".

Variable Substitution
Les règles de substitution de variables de Makepp sont similaires à celles des autres marques, mais quelque peu
plus puissant. Comme dans toutes les marques, "$(CC)" ou "${CC}" représentent tous deux la valeur du
variable CC. Si vous avez besoin d'un signe dollar littéral, mettez un signe dollar double ($$), comme
ce:

cible : dep1 dep2 dep3 dep4
&rm -f $(sortie)
pour le fichier dans $(entrées) ; do cat $$file >> $(output); terminé

De plus makepp a une syntaxe "$[VARIABLE]", qui fait la même chose que l'autre
deux, mais avant makepp groks autre chose. Cela permet de l'utiliser pour des règles complètes
et/ou au conditionnel :

définir bracket_rule =
ifdef SOME_VAR
support:
&écho ceci est une règle -o $(sortie)
fin si
fin def

$[support_rule]

style rc substitution

Par défaut, makepp utilise la substitution de style rc (ainsi appelée parce qu'elle a été lancée par le
coque rc). Ceci est mieux illustré par un exemple :

MODULES = abcd

mylib.a : rép_module/$(MODULES).o $(OTHER_OBJECTS)
$(CXX) $(dépendances) -o $(cible)

Le préfixe "module_dir/" est ajouté au début de chaque mot dans MODULES, et le suffixe ".o" est
ajouté à chaque mot.

Vous pouvez également utiliser la substitution de style rc sans même mettre la liste de mots dans un
variable; la syntaxe est "$( mot1 mot2)". Notez l'espace entre la parenthèse et le
premier mot. Ainsi, l'exemple ci-dessus aurait pu être écrit comme:

mylib.a : module_dir/$( abcd).o $(OTHER_OBJECTS)
$(CXX) $(dépendances) -o $(cible)

Une variable donnera une substitution de style rc uniquement lorsqu'elle contient plus d'un mot.
Avec un mot, c'est comme une fabrication traditionnelle. Hélas, lorsque la variable est vide, il y a un
conflit. Les marques traditionnelles l'étendent simplement à la chaîne vide. Mais quand tu penses à
comme une liste, vous voudriez que "-I$(DIRLIST)" disparaisse, pas pour donner un "-I" solitaire. Les
la solution est de l'envelopper dans une liste qui commence par un espace : "-I$( $(DIRLIST))" vous donne
exactement autant d'options qu'il y a de mots dans la liste.

Si vous mettez plusieurs variables dans le même mot qui se développent en tableaux de mots, le style rc
la substitution prend en fait le produit cartésien, vous pouvez donc faire quelque chose comme ça si
tu veux:

DIR = s1 s2
MODULES = abc
SUFFIXES = .o .c
FICHIERS := $(DIRS)/$(MODULES)$(SUFFIXES)

et FILES contiendra la chaîne

s1/ao s1/ac s1/bo s1/bc s1/co s1/cc s2/ao s2/ac s2/bo s2/bc s2/co s2/cc

Outre l'espace blanc, la substitution de style rc s'arrête à n'importe quel guillemet, tout rond, bouclé ou carré
parenthèses, et l'un des ", : ; = # @". Notez que cela peut être surprenant, et encore une fois besoin
une liste explicite. Supposons que vous vouliez rechercher des en-têtes par caractère générique dans tous les répertoires
commençant par une majuscule :

MAUVAIS := [AZ]*/**/*.$( hpp h) # [AZ]*/**/*.hpp */**/*.h
BON := $( [AZ]*/**/*.)$( hpp h) # [AZ]*/**/*.hpp [AZ]*/**/*.h

Si la substitution de style rc gêne, ou si vous avez besoin d'avoir un début ou une fin
espace dans vos variables make, alors vous pouvez désactiver la substitution de style rc en définissant
la variable "makepp_simple_concaténation=1". Vous pouvez le désactiver globalement sur la commande
ligne ou en tant que variable d'environnement. Ou sur une base par makefile en définissant la variable dans
votre makefile. Vous devriez le faire vers le haut du makefile, sinon vous risquez de rencontrer
situations amusantes où la substitution de style rc est utilisée pour certaines évaluations et pas pour d'autres.
(Toutes les expressions évaluées avant l'affectation utiliseront des substitutions de style rc, et toutes
les expressions évaluées après ne le seront pas. Depuis l'époque de l'évaluation des expressions dans
makefiles est compliqué et pas toujours évident d'après l'ordre des instructions dans le
makefile, il est préférable de définir "makepp_simple_concaténation" le plus tôt possible.) Vous pouvez
définissez-le même pour une seule cible :

cible : makepp_simple_concaténation = 1
Cible:
&écho avant_premier$(LIST)après_last -o $(sortie)

Parce que "$[VARIABLE]" est évalué avant "$(VARIABLE)", combinant les deux dans rc-
substitution ne donnera pas le résultat auquel vous pouvez vous attendre, à moins que vous ne l'enveloppiez dans un
liste:

A = ab
N = 1 2
MAUVAIS := $(A)$[N]
BON := $(A)$( $[N])

Les dernières lignes sont lues comme

MAUVAIS := $(A)1 2 # a1 b1 2
BON := $(A)$( 1 2) # a1 a2 b1 b2

Substitution Bibliographie

Une référence de substitution a la forme "$(VAR:A=B)", où A est un modèle à rechercher et B est
un modèle pour le remplacer. Les références de substitution sont une abréviation pour le
fonction "patsubst". Par exemple:

fichiers_source = ac bc cc dc
object_files = $(source_files:%.c=%.o)

définira "$(object_files)" sur "ao bo co do". Le "%" est un caractère spécial qui correspond
n'importe quelle chaîne arbitraire. Si A et B commencent tous les deux par "%", un cas courant lors du remplacement
suffixes, ils peuvent être omis :

fichiers_objets = $(fichiers_source:.c=.o)
object_files = $(source_files:c=o) # pareil, car . n'est pas spécial

Espace blanc in les variables

Si vous devez contrôler les espaces dans une variable, vous devez (actuellement) désactiver le style rc
substitution (en définissant "makepp_simple_concaténation=1"), puis utilisez une syntaxe comme celle-ci :

nul =
T = -o $(nul)

ou, avec une évaluation vide :

T = -o $()

Lorsque vous faites cela, la variable "T" contient "-o" suivi d'un espace.

Ce genre de technique pour gérer les espaces n'est pas recommandé. Si vous avez besoin de variables
dans votre makefile pour contenir des espaces, vous devriez réfléchir sérieusement à ce que vous faites.
Si vous devez gérer des espaces, il est généralement préférable de mettre du code Perl dans votre
makefile pour s'en occuper (en utilisant les instructions "perl_begin" ou "sub"), ou pour le gérer
dans les instructions shell dans les actions des règles.

Ces cas surviennent généralement lorsque des personnes tentent d'utiliser les mêmes règles pour différents
architectures qui n'utilisent pas la syntaxe de commande Unix typique. Par exemple, on voit parfois
des choses comme ça dans les makefiles :

ifeq ($(ARCH),bizarre)
O := /SORTIE=
d'autre
nul :=
O := -o $(nul)
fin si

%.o : %.c
$(COMPILER) $(entrée) $(O)$(sortie)

Vous pouvez le faire avec makepp si vous le souhaitez vraiment, mais vous constaterez probablement que votre
les makefiles sont nettement plus lisibles si vous avez une variable moins compliquée
substitution, par exemple,

ifeq ($(ARCH),bizarre)
%.o : %.c
$(WEIRD_COMPILER) $(entrée) /OUTPUT=$(sortie)
d'autre
%.o : %.c
$(CC) -c $(entrée) -o $(sortie)
fin si

Les espaces blancs ne sont jamais autorisés dans les noms de variables, uniquement dans leurs valeurs. Ceci est différent
de certaines implémentations make.

Automatique Variables
Les variables automatiques sont des variables qui prennent des valeurs différentes selon la règle
elles sont évaluées. Makepp prend en charge la plupart des variables automatiques que d'autres
versions de faire usage. De plus, il a des noms moins cryptiques et plus longs pour la plupart d'entre eux
que vous pouvez utiliser à la place. (Pour les makefiles hérités qui redéfinissent ces noms, le
définition dans le makefile remplace la signification par défaut. Par exemple, si vous dites
"target = abc" dans votre makefile, alors "$(target)" se développera toujours en "abc", et ne
plus équivalent à $@.)

Ce qui suit est une liste complète de toutes les variables automatiques prises en charge par makepp :

sortie
l'objectif
$@ La cible de la règle actuelle. En fait, puisque makepp prend en charge plusieurs cibles pour
aucune règle, c'est la premier cible. Par exemple, dans la règle suivante

y.tab.c y.tab.h : analyseur.y
$(YACC) -o $(sortie) $(YFLAGS) $(entrée)

"$(output)" contiendra la valeur y.tab.c. Puisque ces variables magiques sont en fait
fonctions, vous pouvez également passer un index comme argument. Cela compte à partir de 1 ou vers l'arrière
À partir de 1. Donc "$(output 2)" ou "$(output -1)" contiendra la valeur y.tab.h.

Bien que les trois formes de cette variable aient la même valeur, il existe une différence dans
interprétation pour les règles multicibles. Si vous utilisez l'ancien nom cryptique $@,
makepp interprétera cela comme un ensemble de règles à l'ancienne, plutôt que comme une règle moderne qui
produit toutes ces cibles en une seule fois :

ab : # vraiment : une règle pour a et b
touchez $@

cd : # erreur : mpp se plaint que cela n'a pas généré d
toucher $(sortie)

sorties
objectifs
Toutes les cibles de la règle actuelle. Identique à "$(target)" sauf s'il y en a plus d'un
cible. Dans l'exemple ci-dessus, "$(outputs)" sera y.tab.c y.tab.h. Vous pouvez passer un
liste d'index, donc "$(outputs 2 1)" sera y.tab.h y.tab.c.

dépendance
contribution
$< La première dépendance explicite de la règle. Par exemple, dans cette règle

%.o : %.c
$(CC) $(CFLAGS) -c $(entrée) -o $(sortie)

"$(input)" sera le nom du .c fichier, peu importe ce que .h fichiers makepp
découvre. Si vous spécifiez plus d'une dépendance, vous pouvez les obtenir en passant un
index : "$(input $(INDEX))" est la dépendance de l'INDEX.

dépendances
entrées
$^ Toutes les dépendances explicites de la cible, sans compter .h fichiers découverts par
makepp_scanning pour les inclusions.

Par exemple, dans la règle

monprog.o : *.o
$(CC) $(CFLAGS) $(entrées) -o $(sortie)

"$(entrées)" sera tous les fichiers .o du répertoire. Vous ne pouvez choisir que ceux que vous
voulez en passant une liste d'index. Si vous spécifiez explicitement différents types de fichiers,
vous pouvez les choisir comme dans "$(inputs 2 3 4)" (mais avec un joker ce n'est pas trop
prometteur).

dépendances_triées
entrées_triées
$+ Toutes les dépendances de la cible, dans l'ordre trié, avec les doublons supprimés.
Équivalent à "$(sort $(entrées))".

dépendances_modifiées
entrées_modifiées
$? Les dépendances de la cible qui ont changé. Cela inclut seulement explicite
dépendances (c'est-à-dire celles que vous répertoriez dans le makefile), non découvertes implicitement
dépendances de l'analyse (telles que les fichiers .h).

Ceci est couramment utilisé dans des commandes comme celle-ci :

libmine.a : $(MODULES) : build_check ignore_action
$(AR) ru $@ $ ?

c'est à dire, ar est dit de remplacer uniquement les modules qui ont changé. (Noter la
Règle de vérification de construction "ignore_action". Si vous ne le spécifiez pas, makepp forcera le
action à exécuter chaque fois qu'elle change. Si aucune dépendance n'a changé, le
la chaîne d'action sera "ar ru libmine.a", ce qui est probablement différent de ce qu'elle était
la dernière fois que vous l'avez exécuté, donc sans "ignore_action", makepp l'exécutera. Dans ce
cas, c'est inoffensif, mais avec d'autres commandes, cela pourrait être un problème. Voir
makepp_build_check pour plus de détails sur "ignore_action".)

Construire des archives comme celle-ci n'est pas une bonne idée car cela rendra vos builds moins
fiable. Le problème avec ceci est que si vous construisez l'archive, supprimez l'un des
les modules de la liste des MODULES, les modules seront toujours dans l'archive et
makepp

endiguer
$* La racine dans une règle de motif (c'est-à-dire, quel que soit le '%' correspondant). Alternativement, si ce
n'est pas une règle de modèle, renvoie le nom du fichier sans l'extension (c'est-à-dire, c'est
équivalent à "$(basename $(input))".

Ceci est principalement pour la compatibilité descendante. Par exemple, dans les anciennes versions de make the
seul moyen de lui dire comment compiler n'importe quel .c fichier dans le fichier correspondant .o le fichier était comme
ce:

.co:
$(CC) $(CFLAGS) -c $*.c -o $*.o

C'est une mauvaise façon d'écrire la règle. Il est beaucoup plus clair d'utiliser le style GNU-make
règles de modèle, comme ceci :

%.o : %.c
$(CC) $(CFLAGS) -c $(entrée) -o $(sortie)

foreach
Le nom de fichier actuel de la clause "foreach". les clauses "foreach" sont rarement utilisées,
mais il s'agit du type de règle de modèle le plus généraliste pris en charge par makepp. Pour
Par exemple,

#
# Construisez des fichiers .c avec une sorte de préprocesseur spécial :
#
%.c : %.k
$(préprocesseur) $(entrée) > $(sortie)

#
# Compilez les fichiers .c en fichiers .o :
#
%.o : %.c
$(CC) $(CFLAGS) -c $(entrée) -o $(sortie)

#
# Drapeaux de compilation alternatifs spéciaux pour les fichiers .c qui sont dérivés
# à partir des fichiers .k :
#
$(foreach:%.k=%.o) : $(foreach:%.k=%.c) : foreach *.k
$(CC) $(SPECIAL_K_FLAGS) -c $(entrée) -o $(sortie)

Voir la documentation sur la clause foreach dans les règles pour plus de détails et d'exemples.

$/ Il s'agit essentiellement d'une constante, soit "/", soit sous Windows natif "\". Vous en avez besoin, si
vous voulez démarrer un programme de manière portable, par exemple celui que vous avez construit dans le répertoire actuel :

masortie :
.$/myprog >$(sortie)

Pour les noms de fichiers passés en arguments, ce n'est pas si nécessaire car Windows peut gérer Unix
syntaxe là-bas.

Option Variables
Vous pouvez les définir de toutes les manières expliquées ci-dessus (sauf indication contraire) pour modifier
le comportement de makepp. Par défaut, ils sont tous indéfinis.

MAKEPP_DEBUG
Si vous exportez ceci avec une valeur vraie avant d'appeler makepp, vous obtenez plus de débogage
Info. Il s'agit de la "RULE_SOURCE" des fichiers créés pendant que cela est en vigueur sous
makeppinfo, mppi et des détails sur l'expansion des variables et la correspondance des règles sous
makepplog, mppl. Cela vous montrera également si makepp manque de mémoire ou se bloque,
car il étend sans cesse les mêmes variables :

A = $A # évaluation différée, besoin :=
B = $C
C = G$

MAKEPP_LN_CP
Voir la note sous &ln.

makepp_percent_subdirs
Définissez ceci sur une valeur vraie (comme 1) pour que "%" dans les cibles ou les dépendances correspondent
dans plusieurs répertoires.

makepp_require_phony
Définissez ceci sur une valeur vraie (comme 1) pour éviter la fausseté implicite (c'est-à-dire si une règle
réussit sans produire sa cible). Cette variable doit être vraie par défaut, pour
empêcher les chaînes de dépendance brisées, mais cela briserait la compatibilité descendante avec
makefiles bâclées.

makepp_signature_C_flat
Il s'agit d'une option pour la signature C. Définissez-la sur une valeur réelle (comme 1) pour traiter votre
sources comme aplaties, c'est-à-dire que toutes les nouvelles lignes (sauf autour des instructions du préprocesseur) sont
traitées comme des espaces et les directives "#line" sont ignorées.

makepp_simple_concaténation
Définissez ceci sur une valeur vraie (comme 1) pour empêcher la "substitution de style rc".

PERL
Vous pouvez définir cela sur le perl exact que vous utilisez pour exécuter les scripts dans le makepp
suite, et l'exporter. Cela peut aider à exécuter des sous-scripts avec le même perl. C'est
surtout utile pour la suite de tests, l'installation et pour les builds récursives.

VPATH
La définition de cette variable sur une valeur appelle implicitement "vpath % value".

Prédéfini Variables
Makepp prédéfinit quelques variables, que vous pouvez remplacer :

AR Valeur par défaut: "ar".

FLAGS
Valeur par défaut: "rv".

AS Valeur par défaut: "comme".

CC Valeur par défaut: Le premier trouvé parmi "gcc", "egcc", "pgcc", "c89" ou "cc", ou sous Windows
en plus "cl" ou "bcc32".

Drapeaux
Valeur par défaut: Si "$(CC)" est un compilateur GNU "-g -Wall", s'il s'agit de l'un des deux Windows
compilateurs rien, sinon "-g".

CURDIR
Le répertoire dans lequel réside le Makefile actuel.

CXX Valeur par défaut: Le premier trouvé parmi "g++", "c++", "pg++", "cxx", "C""C" ou "aCC", ou sur
Windows en plus "cl" ou "bcc32".

CXXFLAGS
Valeur par défaut: Si "$(CXX)" est un compilateur GNU "-g -Wall", s'il s'agit de l'un des deux Windows
compilateurs rien, sinon "-g".

F77 Valeur par défaut: Le premier trouvé parmi "f77", "g77" ou "fort77".

FC Valeur par défaut: "$(F77)".

LD Valeur par défaut: "ld".

LEX Valeur par défaut: Le premier trouvé parmi "lex" ou "flex".

OUTILLIB
Valeur par défaut: "libtool".

FAITES
Cette variable a deux valeurs différentes, selon la présence ou non de
"--traditionnel-récursif-faire". Makepp reconnaît quand cette variable est utilisée et
désactive certaines fonctionnalités, avant même que la récursivité n'ait réellement lieu. Cela peut être
indésirable pendant que vous l'éliminez progressivement, convertissez donc d'abord les appels en un
makepp spécifique "$((MAKE))", qui ne désactivera pas les fonctionnalités. Vous ne devriez pas le définir
parce que cela interrompt notre travail de récursivité intelligent.

MAKECMD OBJECTIFS
Cette variable est définie mais n'est pas utilisée par makepp. Vous ne pouvez l'interroger pour faire quelque chose que si
une certaine cible a été demandée.

Valeur par défaut: Quelles que soient les cibles explicites fournies par l'utilisateur (ou une invocation récursive).
Vide lors de la création implicite de la cible par défaut.

ifneq $(filtre spécial-cible, $(MAKECMDGOALS))
# special-target est l'une des cibles explicites actuelles
sinon ifeq $(MAKECMDGOALS)
# pas de cibles explicites
fin si

MAKEFLAGS (exporté)
Les options standard avec lesquelles makepp a été appelé. Ceux qui ont une seule lettre
forme sont combinées au début sans "-" de début (Dieu sait pourquoi gmake a choisi
pour laisser tomber le "-").

FAIREINFO
Valeur par défaut: "makeinfo".

MAKEPPFLAGS (exporté)
Ceci est défini sur la même valeur que MAKEFLAGS, mais uniquement si cette variable est présente dans
l'environnement de makepp.

_MAKEPPFLAGS (exporté)
Les options spécifiques de makepp nécessaires à la compatibilité POSIX/gmake, avec lesquelles makepp
a été appelé. Ceux-ci sont dans une variable distincte afin qu'un makefile hérité ne puisse pas casser
compatibilité en désactivant MAKEFLAGS. Ceci est uniquement défini avec
"--traditionnel-récursif-faire".

MAKEPP_VERSION
La version de makepp avec laquelle vous exécutez. S'il s'agit d'une version bêta, elle aura un
trait d'union suivi de AAMMJJ plus quelques données internes supplémentaires. Vous pouvez l'utiliser pour "ifdef"
pour masquer les constructions spécifiques à makepp des autres marques.

Valeur par défaut: La même valeur affichée par "makepp --version"

PWD Un alias pour "CURDIR".

RM Valeur par défaut: "rm -f". Ceci est destiné aux anciens Makefiles. Pour les nouveaux, utilisez de préférence
la commande intégrée &rm directement. Si vous voulez écrire une fausse règle propre, regardez
la commande "makeppclean -r" à la place.

TRAITEMENT
Le chemin relatif à la racine de votre système de construction, c'est-à-dire le répertoire plus haut dans
lequel vous avez un "RootMakeppfile(.mk)". Si vous n'en avez pas, cette variable est
vide.

SHELL
Cette variable n'est respectée que si vous l'"exportez". Dans ce cas c'est le Shell
qui est utilisé pour exécuter des actions non intégrées contenant un caractère spécial (plain
ceux qui sont exécutés directement). Sous Windows Strawberry ou ActiveState Perl, si vous avez
un Shell de type Unix, vous devez à la place définir votre variable SHELL sur une valeur se terminant par "sh"
ou "sh.exe" before appeler makepp.

Valeur par défaut: Le premier trouvé parmi "/usr/xpg4/bin/sh" (par exemple Solaris) ou "/sbin/xpg4/sh"
(par exemple Reliant Unix) ou "/ Bin / sh".

YACC
Valeur par défaut: Le premier trouvé parmi "bison -y" ou "yacc".

Variables ainsi que Perl
Les valeurs des variables sont stockées sous forme de scalaires Perl ordinaires, vous pouvez donc y accéder directement depuis
Code Perl si vous devez faire des manipulations compliquées avec eux ; voir makepp_extending
pour en savoir plus.

L'accès aux variables globales depuis Perl est réalisé en les préfixant avec le "Mpp::global"
emballer. En fait toute variable, pas encore présente dans le makefile courant, et que vous
assigner à dans ce package sera désormais global, comme si vous veniez d'émettre le
déclaration "globale" pour cela.

Cet accès direct est cependant sujet aux erreurs ! L'utilisateur peut avoir remplacé ces variables
sur la ligne de commande ou via l'environnement. Un autre makefile chargé avant cela
on peut avoir rendu la variable globale ou cible spécifique. Dans ces cas, vous ne voudriez pas
trouver la valeur de la variable, ou lors de son affectation, pourrait lui enlever sa propriété
(équivalent à un modificateur "override", sauf pour les spécificités de la cible.)

Avec l'accès direct, vous contournez également l'expansion de ces variables, si elles sont de type
"=" ou ";=". Les variables spéciales comme "$(CC)" commencent comme des fonctions, jusqu'à ce qu'elles soient
assigné à. Ainsi, dans de nombreux cas, vous ne verrez pas leur valeur.

Pour ces raisons, il est préférable de laisser makepp déterminer la valeur correcte. Vous pouvez utiliser le
variante "makeperl", dans laquelle la variable a été évaluée avant que le code Perl ne soit
interprété :

makeperl { $$valeur_courante = '$(MAKEFILE_VAR)' }

Si vous avez besoin d'une variable dans les blocs makefile perl, cela se fait via la variable Perl
$makefile comme suit :

perl { $current_value = $makefile->expand_variable( 'MAKE_VAR' ) }

Les fonctions obtiennent toujours l'objet makefile transmis comme deuxième argument $_[1] :

sub f_f { $current_value = $_[1]->expand_variable( 'MAKE_VAR' ) }

Les commandes sont censées être appelées dans une action de règle, où l'objet makefile est
accessible via "$Mpp::Subs::rule->{MAKEFILE}":

sub c_cmd { $current_value = $Mpp::Subs::rule->{MAKEFILE}->expand_variable( 'MAKE_VAR' ) }

Utilisez makepp_variables en ligne à l'aide des services onworks.net