makepp_functions - En ligne dans le Cloud

PROGRAMME:

Nom

makepp_functions -- Fonctions dans makepp

DESCRIPTION

A: nom_fichier_absolu,
Absolute_filename_nolink,
abspathique,
ajouter un préfixe,
ajoute suffixe,
et, B: nom de base, C: appel, D: d,
dir_noslash, E: Erreur, F: fichiersubst,
filtre,
filtrer,
filtre_out_dirs,
trouver un fichier,
find_first_upwards,
trouver_programme,
chaîne de recherche,
trouver_vers le haut,
premier_disponible,
premier mot,
pour chaque, I: si,
si vrai,
infer_linker,
inférer_objets,
Info, J: rejoindre, M: Fabriquer,
faire une carte,
makeperl,
carte,
"mktemp", N: pasdir, O: only_generated,
only_nontargets,
only_phony_targets,
only_stale,
uniquement_cibles,
ou,
origine, P: patsubst,
perle,
faux,
pré-construire,
impression, R: chemin réel,
nom_fichier_relatif,
relatif à, S: coquille,
Trier,
bande,
subst,
suffixe, T: temporaire, W: Attention,
caractère générique,
mot,
liste de mots,
mots, X: xarg

Toute expression au format "$(nom)", où "nom" n'est pas le nom d'une variable, ou
"$(nom arg1 arg2 arg3)" est interprété comme un appel de fonction. Le nom peut contenir des lettres,
des traits de soulignement ou des tirets ; pour éviter toute confusion, vous pouvez utiliser des tirets ou des traits de soulignement
de manière interchangeable, car les tirets internes sont convertis en traits de soulignement. Évaluer de tels
une expression invoque simplement un sous-programme Perl. Si "nom" est précédé de "&", il exécute le
commande intégrée ou script de ce nom dans le processus makepp, et renvoie le standard
sortir. Cela nécessite que perl soit construit pour PerlIO. Si le nom ne nomme pas une fonction
il se transforme en une invocation d'appel.

Comme pour les variables, vous avez le choix entre "$(nom ...)" ou "${nom ...}". Si tu veux
insérez la même parenthèse, elle doit être appariée, l'autre n'a pas d'importance : "$(nom
...(){..." ou "${name ...{}(...}". (Cependant, pour map et perl, la première parenthèse fermante se termine
l'expression.) Le doublement permet aux arguments de s'étendre sur plusieurs lignes. Les nouvelles lignes sont
puis traités comme des espaces, sauf peut-être dans "define". Il y a aussi la syntaxe "$[nom ...]"
ou $[[name ...]], qui est évalué lors de la lecture du makefile, avant de grokker les règles
et d'autres constructions.

Makepp a un certain nombre de fonctions intégrées qui peuvent être utiles. Il prend en charge la quasi-totalité des
Les fonctions textuelles de GNU make (voir la documentation de GNU make pour plus de détails), et certaines de ses
posséder. Vous pouvez définir des sous-routines Perl pour faire ce que vous voulez. Voir la déclaration "sous"
et la section sur l'extension de makepp pour plus de détails.

Conditionnel Les fonctions
ainsi que condition1[,condition2[,condition3...]]
La fonction et fournit une opération ET de "court-circuit". Chaque argument est
élargi, dans l'ordre. Si un argument se développe en une chaîne vide, le traitement s'arrête et
le résultat de l'expansion est la chaîne vide. Si tous les arguments se développent en un non-
chaîne vide, le résultat du développement est le développement du dernier argument.

if chaîne, résultat-si-chaîne-non-vide[, résultat-si-chaîne-vide]
si vrai chaîne, résultat-si-chaîne-vrai[, résultat-si-chaîne-faux]
Une alternative aux déclarations "ifeq", etc. Si la chaîne n'est pas vide (c'est-à-dire que le
condition est vraie), le deuxième argument (la clause "then") est renvoyé (après
expansion variable); si la chaîne est vide, le troisième argument (la clause "else") est
revenu.

Par exemple,

CFLAGS := $(if $(filtre gcc egcc, $(CC)), -g -Mur, -g)

définit CFLAGS comme étant "-g -Wall" si la variable CC est soit "gcc" soit "egcc", et "-g"
autrement. (C'est ce que font les règles de construction par défaut.)

"iftrue" est similaire à "if", sauf que la chaîne 0 est traitée comme vide.

or condition1[,condition2[,condition3...]]
La fonction ou fournit une opération OU de "court-circuit". Chaque argument est développé,
en ordre. Si un argument se développe en une chaîne non vide, le traitement s'arrête et le
le résultat de l'expansion est cette chaîne. Si, une fois tous les arguments développés, tous les
elles sont fausses (vides), alors le résultat de l'expansion est la chaîne vide.

Déposez votre dernière attestation ainsi que Nom de fichier Les fonctions
nom_fichier_absolu fichiers
abspathique fichiers
Convertit les noms de fichiers relatifs en absolus sans . or ... Par exemple,
"$(absolute_filename xyz.c)" peut renvoyer "/usr/src/our_project/subdir/xyz.c".

Absolute_filename_nolink fichiers
chemin réel fichiers
Comme Absolute_filename, mais garantit que les liens symboliques sont résolus.

nom de base noms de fichiers
Le nom de base est le nom complet du fichier (avec le répertoire), moins le texte après et
y compris la dernière période. Par exemple, "$(basename myfile/version-1.0-module.c)" est
"monfichier/version-1.0-module"

dir noms de fichiers
Extrait la partie répertoire de chaque fichier dans la liste des noms de fichiers, y compris la fin
sabrer. Renvoie "./" s'il n'y a pas de répertoire dans le nom de fichier.

dir_noslash nom de fichier
Identique à "$(dir )" sauf qu'il ne renvoie pas la barre oblique de fin.

sous-fichier modèle, remplacer, des mots
Effectuez une substitution de modèle sur les noms de fichiers. Cela diffère de patsubst en ce que
il fonctionnera correctement lorsque des noms alternatifs pour les répertoires sont donnés (tant que
ils précèdent le signe pourcentage). Par exemple,

$(filesubst ./src/%.c, %.o, $(wildcard src/*.c))

fonctionnera avec filesubst mais pas avec patsubst.

filtre_out_dirs noms de fichiers
Renvoie tous les noms de fichiers qui ne font pas référence à des répertoires.

trouver un fichier nom de fichier, chemin
Recherche un fichier dans le chemin spécifié, ou dans la variable d'environnement PATH si rien n'est
spécifié. Cela peut être utile pour trouver des binaires ou inclure des fichiers. Par exemple,

TCL_INCLUDE := -I$(dir_noslash $(findfile tcl.h, \
/usr/local/stow/tcl-8.4.5-nothread/include\
/usr/include/tcl8.4 /usr/include/tcl\
/net/na1/tcl8.4a3/include /net/na1/tcl8.4a3/include))

Ceci localise le fichier tcl.h en recherchant tous les répertoires ci-dessus. L'absolu
le chemin d'accès au fichier est renvoyé. Ensuite, "$(dir_noslash )" extrait ce répertoire, et il
est placé dans le chemin d'inclusion.

trouver_programme prénom
Renvoie le premier programme de la liste qui se trouve dans le PATH. C'est utile
lorsqu'il y a plusieurs programmes équivalents qui peuvent être utilisés, et que vous voulez juste
choisissez l'un d'eux. Par exemple, voici la définition par défaut de plusieurs
variables que makepp fournit si vous n'en mettez pas dans votre makefile :

CC = $(find_program gcc egcc pgcc c89 cc) # et plus, selon la machine
F77 = $(trouver_programme f77 g77 fort77)
CXX = $(trouver_programme g++ c++ pg++ cxx CC aCC)

Si aucun des programmes n'est trouvé, "$(find_program )" renvoie la chaîne not-found, et
enregistre ce qui n'a pas été trouvé. Cela n'aboutira généralement pas à un makefile fonctionnel, mais il
aura tendance à produire de meilleurs messages d'erreur. Par exemple, si vous faites quelque chose comme
ce:

%.o : %.c
$(CC) $(entrées) -o $(sorties)

et makepp ne trouve pas de compilateur C dans la liste ci-dessus, il remplacera not-found.
Sinon, le shell tenterait d'exécuter le fichier source et l'erreur résultante
le message peut être vraiment étrange.

trouver_vers le haut nom de fichier
Recherche un fichier du nom donné dans le répertoire ., .., ../ ..../../.., Etc,
jusqu'à ce que le fichier soit trouvé ou que le répertoire racine soit atteint ou que le répertoire soit localisé
sur un autre système de fichiers. (Cette dernière exigence est d'éviter des problèmes avec
des montages automatiques ou des systèmes de fichiers réseau bloqués.) Si vous disposez d'un Fichier RootMakepp, c'est aussi
une barrière qui empêche de chercher plus haut.

Par exemple, si vous avez un projet avec plusieurs niveaux de sous-répertoires, vous pouvez
inclure ce fragment commun dans tous les makefiles (par exemple, en utilisant le "include"
déclaration):

TOP_LEVEL_INCLUDE_DIR := $(find_upwards inclut)
# Recherche un répertoire qui contient le
# inclut le sous-répertoire.

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

Un autre problème que "find_upwards" peut aider à résoudre est de localiser le répertoire de niveau supérieur
d'une construction. Souvent, il est utile de définir une variable comme celle-ci :

HAUT := ../../..

si vous avez des informations importantes situées uniquement dans le répertoire de niveau supérieur. Mais
c'est difficile à maintenir, car le nombre de ".." est différent pour différents niveaux
de l'arborescence des répertoires. Au lieu de cela, vous pouvez utiliser "find_upwards" pour localiser un fichier qui est
connu pour être présent uniquement dans le répertoire de niveau supérieur. Supposons, par exemple, que le
le fichier "LICENSE" se trouve uniquement dans le répertoire de niveau supérieur. Ensuite, vous pouvez faire ceci :

TOP := $(dir_noslash $(find_upwards LICENCE))

"$(find_upwards LICENSE)" renvoie le chemin complet du fichier de licence ;
"$(dir_noslash ...)" supprime le nom de fichier, ne renvoyant que le répertoire.

(Notez que l'instruction "include" recherche automatiquement les fichiers vers le haut, donc il
n'est pas nécessaire de faire quelque chose comme ça:

inclure $(find_upwards top_level_rules.mk)

Au lieu de cela, vous pouvez simplement faire

inclure top_level_rules.mk

et cela fonctionnera tout aussi bien.)

Si le fichier n'est pas trouvé, "find_upwards" annulera la construction avec un message d'erreur.

Si vous spécifiez plus d'un fichier, find_upwards recherchera le premier, puis
le second, et ainsi de suite. En d'autres termes,

$(trouver_vers le haut fichier1 fichier2)

équivaut à

$(find_upwards fichier1) $(find_upwards fichier2)

Si vous souhaitez rechercher l'un des fichiers, utilisez plutôt "find_first_upwards".

find_first_upwards file1 file2
Cette fonction se comporte comme "find_upwards" sauf qu'elle renvoie le premier fichier de n'importe quel
fichiers dans la liste qu'il trouve. Plus précisément, il vérifie le répertoire actuel pour
l'un des fichiers de la liste et renvoie le premier fichier qui existe ou qui peut être construit.
Si aucun des fichiers n'existe ou ne peut être construit dans ce répertoire, il vérifie .., puis
../ .., etc., jusqu'à ce qu'il atteigne le répertoire racine ou un répertoire qui est
situé sur un autre système de fichiers.

premier_disponible file1 file2
Renvoie le premier fichier d'une liste qui existe ou peut être construit. Cela peut être utile pour
adapter vos makefiles pour qu'ils fonctionnent sur plusieurs machines ou réseaux différents, où
les fichiers importants peuvent se trouver à différents endroits. Par exemple, voici une ligne de
un de mes makefiles :

TCL_LIB = $(première_disponible \
/usr/local/stow/tcl-8.4.5-nothread/lib/libtcl8.4.so \
/usr/lib/libtcl8.4.so /usr/lib/libtcl.so \
/net/na1/tcl8.4a3/lib/libtcl8.4.a \
/net/na1/tcl8.4a3/lib/libtcl8.4.sl)

Cette ligne vérifiera la bibliothèque Tcl dans tous les endroits ci-dessus, en s'arrêtant à la
le premier qu'il trouve. La commande link inclut alors $(TCL_LIB) donc on obtient le
bibliothèque Tcl appropriée.

inférer_lien file1 file2
Étant donné une liste de fichiers objets, construisez-les d'abord s'ils ne l'ont pas encore été. puis trouver
s'ils dépendent d'une source Fortran, C++ ou C et renvoient le
compilateur (qui sait mieux lier que "ld").

inférer_objets file1 file2 ..., modèle
$(infer_objects objet1.o objet2.o, *.o)

Si vous utilisez des conventions standard concernant les noms de fichiers d'en-tête, makepp est capable de
deviner quels fichiers ".o" ou ".lo" doivent être liés à votre programme. j'utilise ça pour
choisir des fichiers dans un répertoire de bibliothèque qui contient des modules utilisés dans de nombreux
programmes. Au lieu de créer un fichier de bibliothèque ".a" et de laisser l'éditeur de liens choisir le
modules pertinents, makepp peut sélectionner les modules pertinents pour vous. De cette façon, seulement
les modules pertinents sont compilés.

L'algorithme de Makepp pour déduire les dépendances d'objets dépend de la convention qui
l'implémentation de toutes les classes ou fonctions définies dans un fichier d'en-tête "xyz.h" sont
compilé dans un fichier objet appelé "xyz.o" (ou "xyz.lo"). Donc l'algorithme de makepp pour
déduire les dépendances d'objets commence par un ou quelques objets que nous savons devoir être
liés au programme. Il regarde quels fichiers ont été inclus avec "#include" dans
ces sources, et essaie de trouver les fichiers objets correspondants pour chacun des include
fichiers.

"$(infer_objects )" doit être mentionné dans la liste des dépendances d'un programme, comme
ce:

myprog : $(infer_objects main.o another_object.o, \
**/*.o /autre/bibliothèque/répertoires/**/*.o)
$(CXX) $(entrées) -o $(sortie) $(LIBS)

La fonction "$(infer_objects)" prend deux arguments (séparés par une virgule, comme indiqué).
Le premier est un ou plusieurs fichiers objets dont on sait qu'ils sont nécessaires (les caractères génériques sont
autorisé ici). La seconde est une liste d'objets possibles (normalement vous utiliseriez un
joker ici) qui pourraient être liés si nécessaire. La valeur de retour de ce
fonction est une liste qui contient d'abord tous les objets du premier argument, et
puis après ceux-ci, tous les objets supplémentaires qui étaient contenus dans le deuxième argument
requis par les objets du premier argument.

Par exemple, supposons que "main.o" vienne de "main.cpp", qui inclut "my_class.h".
"$(infer_objects)" recherche les fichiers portant le nom "my_class.o". Si exactement un tel
est trouvé, il est ajouté à la liste. (Si deux fichiers objets "my_class.o" sont trouvés
dans différents répertoires, un message d'avertissement est imprimé.) "infer_objects" également
examine "my_class.cpp" pour voir ce qu'il inclut, et quels fichiers objets supplémentaires sont
implicite.

mktemp
mktemp préfixe
mktemp préfixeXXX
mktemp/
Renvoie un nom de fichier temporaire imprévisible, qui n'existe pas actuellement. Sans nom
pointer vers le même fichier est renvoyé deux fois, même avec des chemins relatifs différents,
en une seule exécution makepp (sauf éventuellement avec make récursif traditionnel, ou si Perl
le code exécuté dans une action de règle appelle "f_mktemp"). À la fin du makepp, exécutez tout
les fichiers renvoyés par cette fonction sont supprimés, s'ils existent (là encore sauf ceux
renvoyé par cette fonction dans le code Perl exécuté dans une règle).

Tout nombre de "X" majuscules à la fin de l'argument est remplacé par autant de
lettres et chiffres aléatoires. Plus il y en a, moins cela risque d'entrer en collision
avec d'autres processus, donc si vous donnez un préfixe comme "/tmp/abc.", tu devrais en avoir assez
"X". S'il y a plus d'un X, le premier caractère provient de l'identifiant du processus. Si
il n'y en a pas, c'est comme s'il y en avait dix, ce qui est censé être suffisant (8.4e17
possibilités ou 3.7e15 sous Windows). S'il n'y a pas d'argument, le préfixe par défaut est
"tmp." dans le répertoire courant.

Notez que vous ne voulez pas donner un tel nom en tant que cibles de règle et dépendances. Les
le résultat serait correct, mais il serait recréé à chaque fois que vous exécutez makepp.

De plus, comme c'est toujours différent, vous ne devez l'utiliser dans une action de règle que si vous utilisez
":build_check ignore_action":

TMPFILE ;= $(mktemp) # 1 appel ; "=" signifierait 3 appels : 3 fichiers
A-count B-count : : build_check ignore_action
produire-comme-et-Bs >$(TMPFILE)
&grep -c /A/ $(TMPFILE) -o A-count
&grep -c /B/ $(TMPFILE) -o B-count

Ou vous devriez l'exporter et laisser le Shell l'évaluer :

export FICHIER TMP ;= $(mktemp)
Compte A Compte B :
product-As-and-Bs >$$TMPFILE # makepp ne voit pas la valeur var
fgrep -c A $$TMPFILE >A-count
fgrep -c B $$TMPFILE >B-count

La dernière forme répète la valeur de retour précédente, vous pouvez donc l'utiliser dans une règle de modèle :

%.x : %y
&grep foo $(input) -o $(mktemp)
&sed bar $(mktemp /) -o $(output) # Fonctionne sur la sortie de &grep

pasrép noms de fichiers
Renvoie la partie non-répertoire du ou des noms de fichier, c'est-à-dire tout après le dernier
slash s'il y en a un, ou le nom de fichier entier sinon.

uniquement_généré noms de fichiers
Renvoie uniquement les noms de fichiers de la liste qui ont été générés par makepp et non depuis
modifié, selon le fichier d'informations de construction.

Cette fonction est utile dans les règles cibles propres (bien que "makeppclean" soit bien sûr le
variante préférée):

$(faux nettoyage) :
&rm -f $(seulement_généré **/*)

only_nontargets noms de fichiers
Renvoie uniquement les noms de fichiers de la liste qui ne sont cibles d'aucune règle (soit
règles explicites ou de modèle). Vous pouvez spécifier un caractère générique (voir le "$(wildcard )"
pour plus de détails sur les jokers de makepp). Cela peut être utilisé pour générer un
cible de distribution, par exemple :

.PHONY : diffusion

Distribution:
&mkdir notre_produit-$(VERSION)
&cp $(filter-out %~, $(only_nontargets *)) our_product-$(VERSION)
tar cf - notre_produit-$(VERSION) | gzip -9c > notre_produit-$(VERSION).tar.gz

Dans ce cas, le "$(only_nontargets *)" renvoie tous les fichiers du répertoire courant
ce n'est pas la cible d'une règle. Le "$(filter_out %~, ...)" supprime l'éditeur
sauvegardes.

Semblable à "only_targets" (voir ci-dessus), "only_nontargets" ne connaît que les cibles qui
ont déjà été définis. Ce n'est un problème que si vous l'utilisez pour définir des variables
avec l'affectation ":=" ; si vous l'utilisez dans la liste des dépendances ou dans le corps d'un
règle, toutes les autres règles auront déjà été vues.

seulement_stale noms de fichiers
Renvoie uniquement les noms de fichiers de la liste qui ont été générés par makepp et non depuis
modifiés, selon le fichier d'informations de construction, mais ne sont plus la cible d'aucune règle.

Cette fonction est utile pour s'assurer qu'il n'y a pas de dépendances sur de tels fichiers,
sans forcer une construction propre de toutes les cibles :

$(faux flush) :
&rm -f $(only_stale **/*)

En fait, il est probablement préférable d'écrire un script qui appelle makepp pour générer
la liste des fichiers obsolètes, puis demandez à ce script de supprimer tous les fichiers répertoriés qui
ne sont pas actuellement sous contrôle de source, juste au cas où un fichier généré deviendrait une source
déposer. Makepp n'a pas une telle fonction intégrée car makepp est (et probablement
devrait rester) agnostique sur le contrôle de source.

uniquement_targets noms de fichiers
Renvoie uniquement les noms de fichiers de la liste qui sont en réalité les cibles d'une règle
(soit des règles explicites, soit des règles de modèle). Vous pouvez spécifier des caractères génériques (y compris makepp's
caractère générique spécial, "**") dans les noms de fichiers. (Voir la fonction "$(wildcard )" pour plus
des détails. Cela peut être utilisé pour une cible propre, par exemple :

.PHONY : propre

nettoyer:
&rm -f $(seulement_cibles *)

Maintenant, si vous tapez "makepp clean", il supprimera tout ce qu'il sait construire. Mais
ne créez pas de cible propre, utilisez plutôt "makeppclean" !

Un autre endroit où il peut être utile d'éviter d'inclure .o fichiers dans votre
construire. Par exemple, si vous créez une bibliothèque comme celle-ci :

mylib.a : *.o
&rm -f $(sortie)
$(AR) cr $(sortie) $(entrées)

et puis vous supprimez certains fichiers sources mais oubliez de supprimer le correspondant .o fichiers,
le .o les fichiers seront toujours là. Cela signifie qu'ils seront toujours intégrés dans
la bibliothèque malgré le fait qu'ils ne servent plus. Si vous modifiez votre
règle comme ceci :

mylib.a : $(only_targets *.o)
&rm -f $(sortie)
$(AR) cr $(sortie) $(entrées)

alors ce problème ne se produira pas.

Notez que cela ne concerne que les fichiers connus pour être des cibles at le fiable you
invoquer « uniquement des cibles ». Si "only_targets" apparaît dans les dépendances ou les actions d'un
règle, alors toutes les cibles possibles seront connues car les dépendances et les actions ne sont pas
évalué jusqu'à ce que la règle soit exécutée. Cependant, si vous évaluez, essayez de l'évaluer
plus tôt dans le makefile avec une variable ":=" comme celle-ci :

ALL_TARGETS := $(only_targets *)

cible1 : dépendance1
actes

cible2 : dépendance2
actes

alors "only_targets" ne connaîtra pas les règles suivantes.

De même, "only_targets" ne connaît pas les cibles produites dans les makefiles qui sont
chargé avec make récursif. (Mais vous ne devriez pas utiliser make récursif de toute façon ; utilisez
utilisez l'instruction "load_makefile" ou le chargement implicite de makefile à la place.)

nom_fichier_relatif file1 file2 fichier3[, sabrer]
Renvoie le nom de ces fichiers par rapport au répertoire courant (celui
makefile est dans). Cela peut également être utilisé pour nettoyer les "./" inutiles et autres indésirables de
le chemin:

REP := .
SOUS-REP := ..
FNAME := $(DIR)/../otherdir/$(SUBDIR)/fichiers
X := $(relative_filename $(FNAME))

If sabrer est vrai (généralement 1) les noms de fichiers renvoyés contiennent une barre oblique
en ajoutant "./" si nécessaire, afin que vous puissiez l'utiliser comme nom d'exécutable sans
se soucier du chemin de recherche de la commande remplaçant l'emplacement du répertoire.

Si le chemin passe par le répertoire racine, le parent de votre répertoire personnel ou
le "$(ROOT)" de votre système de build, ou sous Windows la racine d'un lecteur (selon le
l'environnement, cela se produit également pour /cygdrive/c or /c), un chemin absolu sera
retourné à la place.

relatif à file1 file2 fichier3[, annuaire]
Renvoie le nom de ces fichiers par rapport au répertoire spécifié. C'est
généralement utile lorsque, pour une raison quelconque, vous devez exécuter une commande à partir d'un
répertoire différent (répertoire courant par défaut) :

source_backup.tar :
cd .. && tar cf $(relative_to $(output), ..) $(relative_to ., ..)

suffixe noms...
Extrait le suffixe de chaque nom de fichier dans les noms. Si le nom du fichier contient un point,
le suffixe est tout commençant par la dernière période. Sinon, le suffixe est le
chaîne vide. Cela signifie souvent que le résultat sera vide lorsque les noms ne l'est pas,
et si les noms contiennent plusieurs noms de fichiers, le résultat peut contenir moins de noms de fichiers.

Par exemple,

$(suffixe src/foo.c src-1.0/bar.c hacks)

produit le résultat ".c .c".

temporaire des mots
Faites savoir à makepp que les cibles spécifiées peuvent être supprimées par la règle qui génère
eux. Similaire à "phony", sauf que makepp s'attend à ce qu'un vrai fichier de ce nom
sera peut-être affecté par la règle. Une règle n'est pas exécutée si seulement son
les cibles sont obsolètes.

générique modèle
Renvoie les noms triés de tous les fichiers correspondant au modèle donné qui existent, ou ceux
des fichiers qui n'existent pas encore mais peuvent être construits sur la base des règles que makepp connaît
au moment où il évalue l'expression. Sur ce dernier point il diffère
à partir des caractères génériques d'entrée de règle, qui s'appliquent même aux fichiers créés par des règles trouvées ultérieurement.

Makepp prend en charge tous les caractères génériques de shell habituels ("*", "?" et "[]"). Il a également un
joker "**" qui correspond à un nombre quelconque de répertoires intermédiaires. (Cette idée était
volé de zsh.) Par exemple, "**/*.c" correspond à tous les .c fichiers dans toute la source
arbre. "objects/**/*.o" correspond à tous les .o fichiers contenus n'importe où dans le
sous-répertoire objets ou l'un de ses sous-répertoires ou l'un de leurs sous-répertoires. Les
Le caractère générique "**" ne suivra pas les liens symboliques vers les répertoires à quelque niveau que ce soit, ni
tenter d'entrer dans des répertoires qui existent mais ne peuvent pas être lus. Aussi les fichiers et
les répertoires qui existent mais ne peuvent pas être lus ne seront pas renvoyés par "$(wildcard )".

Chaîne Les fonctions
ajouter un préfixe préfixe, des mots
Ajoute la chaîne de préfixe à chacun des mots. Ceci est principalement pour GNU make
compatibilité; en utilisant l'expansion de style rc, cela peut être fait d'une manière plus lisible
comme ça:

MODULES := abcd
X_OLD_STYLE := $(addprefix $(OBJDIR)/, $(addsuffix .o, $(MODULES)))
X_NEW_STYLE := $(OBJDIR)/$(MODULES).o # N'est-ce pas plus facile à lire ?

ajoute suffixe suffixe, des mots
Ajoute la chaîne de suffixe à chacun des mots. Ceci est principalement pour GNU make
compatibilité; en utilisant l'expansion de style rc, cela peut être fait d'une manière plus lisible
comme ça:

X_OLD_STYLE := $(addsuffix .o, $(MODULES))
X_NEW_STYLE := $(MODULES).o

Appelez-nous variable[, mots]...
La fonction "call" est unique en ce qu'elle peut être utilisée pour considérer variable en tant que
fonction paramétrée. Vous pouvez affecter une expression complexe à variable et utilise
"call" pour étendre son contenu à différentes valeurs paramétrées par des mots plus tard. Dans
d'autres systèmes de fabrication, une variable qui est principalement utilisée dans le but d'être étendue via
« appel », est appelé un macro.

Lors de l'expansion de la macro, les variables temporaires $1, $2, "..." se référer au
arguments donnés à "call" lors de son invocation. La variable $0 sera étendu à
le nom de la macro (c'est-à-dire variable) cet "appel" est actuellement en expansion.

Il n'y a pas de limite, avec combien d'arguments une macro peut être "appelée" ou combien
paramètres auxquels une macro peut s'attendre. Si vous passez plus d'arguments à "call" en tant que macro
besoin, tous les arguments dépassant seront rejetés. Si vous passez moins d'arguments qu'un
macro attendre, tous les paramètres dépassant s'effondrent dans la chaîne vide.

D'abord un exemple simple :

reste = $(liste de mots 2, $(mots $(1)),$(1))
liste = ABCDE
mais d'abord := $(call rest,$(list))

Ici, la variable "$(butfirst)" contiendra la liste "BCDE".

Et maintenant un exemple plus complexe pour montrer ce qui est possible :

reste = $(liste de mots 2,$(mots $(1)),${1})
mymap = $(if $2,$(call $1,$(firstword $2)) $(call $0,$1,$(call rest,$2)))
downcase = ${makeperl lc("$1")}

UCWORDS = TOUS CES MOTS SONT EN MAJUSCULES
DCWORDS := $(appelez mymap,downcase,$(UCWORDS))

Maintenant, "$(DCWORDS)" contient "tous ces mots sont en majuscule". Au fait : ça ne fait pas
différence, si nous accédons aux arguments via $1, "${1}" or "$(1)" au sein d'une macro.

Vous pouvez utiliser directement la variable comme s'il s'agissait d'une fonction, s'il n'y a pas
fonction de ce nom. Ceci est converti en interne en "appel", donc ceux-ci sont
équivalent:

discussion = Le 0 $ s'est transformé en 1 $ 2 $.
direct = $(discussion et argument)
appelé = $(appel discussion,un,argument)

Il peut sembler discutable de savoir si "$[call]" doit également développer le "$[]" de la macro
expressions, ou si une fonction doit toujours faire la même chose, peu importe comment elle
est appelé. Ce dernier a été choisi, car avec la syntaxe make normale, il serait
impossible d'obtenir "$[1], $[2]..." dans une variable (ils seraient remplacés par rien,
avant même que l'affectation n'ait lieu.) Par conséquent, si vous disposez d'une macro pour définir un
règle, vous voulez que des expressions telles que "$(output)" soient vues lorsque la règle est analysée, donc
vous devez les protéger des "appels":

définir ma règle
2 1 USD: XNUMX USD
macommande $$(entrée) -o $$(sortie)
endéf
$[marègle monentrée,masortie]

une fonction filtre motifs, des mots
Renvoie tous les mots de la liste qui correspondent aux modèles. Les modèles peuvent simplement être d'autres
mots ou caractères génériques de nom de fichier (c'est-à-dire, "*", "?" et "[az]" sont reconnus), ou ils peuvent
ont un caractère "%", ce qui signifie qu'il correspond à n'importe quelle chaîne à ce stade (identique à "*").

filtrer motifs, des mots
Renvoie tous les mots de la liste qui ne correspondent pas aux modèles. Les motifs peuvent simplement être
d'autres mots, ou des caractères génériques de nom de fichier (c'est-à-dire, "*", "?" et "[az]" sont reconnus), ou
ils peuvent avoir un caractère "%", ce qui signifie qu'ils correspondent à n'importe quelle chaîne à ce stade (identique à
"*").

Par exemple :

libproduction.a : $(filter_out test_*, $(wildcard *.o))

mettra tout .o fichiers qui existent ou peuvent être construits, à l'exception de ceux commençant par tester_,
développement libproduction.a.

chaîne de recherche trouve, in
Retour trouver, s'il s'agit d'une sous-chaîne de in.

premier mot des mots
Retourne le premier mot.

Localisation mots, code perl
faire une carte mots, code perl
De la même manière que la carte de Perl, s'applique code perl à chaque mot à tour de rôle et renvoie le
résultats. La première variante est du code Perl simple, tandis que la deuxième variante passe d'abord
le perlcode via l'expansion des variables de style Make. Les mots sont développés dans les deux
Cas.

Les mots sont en $_ et sont renvoyés sauf si vous annulez $_. Ceci est destiné à
modifications pas facilement gérées par "patsubst". Seule la première virgule est un séparateur,
tous les autres sont considérés comme faisant partie du code perl.

# Changez de mots. Double parenthèses, pour autoriser les parenthèses dans perlcode, ou utilisez ${} :
X = $((carte $(VALEURS), s/(.+)-(.+)/$2-$1/))
# Vous pouvez utiliser des expressions make, mais vous devez alors utiliser $$ pour Perl $ :
Y = $(makemap $(VALUES), tr/$(OLDCHARS)/$(NEWCHARS)/ ou $$_ = 'failed')
# Vous pouvez éliminer des candidats :
Y = $(map $(VALUES), undef $_ if /no_good/)

rejoindre mots1, mots2
Faites une jointure par paires des premiers mots et des deuxièmes mots.

patsubst modèle, remplacer, des mots
Effectue une substitution sur chaque mot de la liste de mots. Un caractère "%" correspond à n'importe quel
chaîne de caractères. Ceci est mieux illustré par un exemple :

OBJS = $(patsubst %.c, rép_objet/%.o, $(C_SOURCES))

prend chaque fichier dans C_SOURCES et renvoie le nom d'un fichier objet dans object_dir.
Parfois, il est plus concis d'utiliser une référence de substitution, par exemple, ce qui précède pourrait
ont été écrits comme

OBJS = $(C_SOURCES :%.c=object_dir/%.o)

sort word1 word2 word3
Trie les mots dans l'ordre lexical et supprime les doublons.

bande un magnifique
Supprime les espaces blancs de début et de fin de la chaîne et remplace chaque interne
séquence d'un ou plusieurs caractères blancs avec un seul espace. Ainsi, "$(strip ab
c )" se traduit par "abc".

subst de,à,texte
Effectue un remplacement textuel sur le texte texte : chaque occurrence de from est remplacée
par à. Le résultat est substitué à l'appel de fonction. Par exemple,

$(subst ee,EE,pieds dans la rue)

remplace la chaîne "pied dans la rue".

mot n,texte
Renvoie le nle mot de texte. Les valeurs légitimes de n commencer à partir de 1 au début
ou vers l'arrière à partir de -1 à la fin. Si n est plus grand que le nombre de mots dans texte,
la valeur est vide.

liste de mots liste d'index, des mots
liste de mots premier indice, dernier index, des mots
Dans la première forme, vous fournissez une liste d'indices (en comptant à partir de 1 au début ou
en arrière à partir de -1 à la fin) pour sélectionner les mots que vous voulez. Dans la deuxième forme, vous
spécifiez la plage de mots que vous souhaitez renvoyer.

des mots texte
Renvoie le nombre de mots dans texte.

Divers Les fonctions
foreach var,liste,texte
Les deux premiers arguments, var ainsi que liste, sont développés avant toute autre chose ; Remarque
que le dernier argument, text, n'est pas développé en même temps. Alors pour chaque mot de
la valeur étendue de list, la variable nommée par la valeur étendue de var est définie sur
ce mot, et le texte est développé. Vraisemblablement, le texte contient des références à cette variable,
son expansion sera donc différente à chaque fois.

Cet exemple simple définit la variable fichiers à la liste de tous les fichiers du
répertoires dans la liste dirs:

répertoires := abcd
fichiers := $(foreach dir,$(dirs),$(wildcard $(dir)/*))

Ici, le texte est "$(wildcard $(dir)/*)". La première répétition trouve la valeur "a" pour dir,
il produit donc le même résultat que "$(wildcard a/*)" ; la deuxième répétition produit
le résultat de "$(wildcard b/*)" ; et le troisième, celui de "$(wildcard c/*)".

Cet exemple a le même résultat (à l'exception du paramètre "dirs") que l'exemple suivant :

fichiers := $(caractère générique a/* b/* c/* d/*)

Lorsque le texte est compliqué, vous pouvez améliorer la lisibilité en lui donnant un nom, avec un
variable supplémentaire :

find_files = $(caractère générique $(dir)/*)
répertoires := abcd
fichiers := $(foreach dir,$(dirs),$(find_files))

Ici, nous utilisons la variable find_files de cette façon. Nous utilisons plain "=" pour définir un
variable à expansion récursive, de sorte que sa valeur contienne un appel de fonction réel à
être ré-élargi sous le contrôle de foreach ; une variable simplement développée ne ferait pas l'affaire,
puisque le caractère générique ne serait appelé qu'une seule fois au moment de la définition de find_files.

Remarque : Ne confondez pas cela avec la variable spéciale "$(foreach)".

info texte
avertissement texte
erreur texte
Texte de sortie renvoyant le rien. Le premier va à STDOUT, le second à STDERR,
le troisième interrompt également le traitement.

pré-construire objectifs
faire objectifs
Renvoie son argument textuellement, mais construit d'abord tous les fichiers répertoriés. C'est utile
lorsqu'un fichier donné est nécessaire lors de l'évaluation d'une expression make. Cela se produit généralement
lorsque vous avez une construction où l'ensemble des fichiers impliqués est calculé par un shell
commandes. Par exemple,

liste_fichier :
# commandes shell pour calculer une liste de fichiers à mettre dans le programme

my_program : $(&cat $(prebuild file_list))

Si vous avez besoin de la liste dans plusieurs règles, il serait plus efficace d'utiliser un
développer au plus une fois variable :

liste_fichiers ;= $(&cat $(liste_fichiers pré-construire))

mon_programme1 : ao $(liste_fichiers)

mon_programme2 : bo $(liste_fichiers)

Si à la place vous avez spécifié juste "$(&cat file_list)", alors makepp ne forcera pas
file_list doit être à jour avant d'exécuter la commande shell. Utilisation de "$(prebuild )"
est le meilleur moyen de résoudre ce problème. Vous pourriez être tenté d'essayer d'autres choses, comme
ce:

my_program : file_list $(&cat file_list)

mais cela ne fonctionnera pas car "$(&cat file_list)" est évalué avant que makepp ne tente de
construire "file_list".

only_phony_targets noms
Renvoie uniquement les noms de la liste qui sont de fausses cibles d'une règle (soit
règles explicites ou de modèle). Vous pouvez spécifier des caractères génériques (y compris les caractères spéciaux de makepp
caractère générique, "**") dans les noms de fichiers. (Voir la fonction "$(wildcard )" pour plus de détails.
Cela peut être utilisé pour regrouper des cibles, par exemple :

$(tests fictifs) : $(only_phony_targets */**/tests)

origine variable
Étant donné le nom d'une variable, vous indique d'où vient sa valeur.

perl code perl
maquillage code perl
Évalue perlcode dans un bloc et renvoie le résultat. La première variante est simple Perl
code, tandis que la deuxième variante passe d'abord le perlcode via la variable de style Make
vous propose d’explorer.

Notez que, comme pour toutes les fonctions, le délimiteur de fonction utilisé peut ne pas apparaître dans
le perlcode en dehors des chaînes entre guillemets simples ou doubles. Mais vous pouvez le doubler comme dans
le dernier exemple :

VAR = 1
VAR1 = ${perl ($VAR + 1) * 3}
VAR2 = $(perl do { $VAR *= 3 ; renvoie $VAR + 1 } si $VAR)
VAR3 = $(makeperl $(VAR1) * 3 + $$VAR) # un Make var et un Perl var
VAR = $((perl si( ... ) { ... }))

faux des mots
Indique que la liste de mots est en fait de fausses cibles et renvoie la liste des
cibles. Il est destiné à être utilisé comme ceci :

$(phony all): mon_programme

$(faux nettoyage) :
&rm -f *.o mon_programme

Vous pouvez également déclarer une ou plusieurs cibles comme fausses avec une ligne comme celle-ci n'importe où dans
votre makefile :

.PHONY : tout propre

impression texte
Sort le texte et le renvoie. Ceci est surtout utile pour le débogage, lorsque vous ne
comprendre pourquoi la substitution de variable a le résultat que c'est le cas. Par exemple,

XYZ := $(print $(patsubst %.c, %o, $(SOURCE_FILES)))

affichera le résultat de l'appel "patsubst".

XYZ := $(patsubst %.c, %o, $(print $(SOURCE_FILES)))

affichera le dernier argument de l'appel "patsubst".

coquille shell-commande
Renvoie la sortie de la commande shell donnée, avec les retours à la ligne remplacés par des espaces.

Notez que, comme pour toutes les fonctions, le délimiteur de fonction utilisé peut ne pas apparaître dans
la commande shell en dehors des chaînes entre guillemets simples ou doubles. Mais tu peux le doubler
comme dans le deuxième exemple :

date = $(shell date) # mieux : $(perl scalar localtime)
VAR = ${{shell f() { echo bonjour ; } ; F}}

xarg commande,arguments[,suffixe[,longueur]]
Renvoie une liste de commandes séparées par des sauts de ligne commençant chacune par le
commande, et terminez par autant d'éléments de la liste que possible sans passer
longueur (par défaut 1000) caractères.

Le but de ceci est d'éviter de dépasser la limite de longueur de commande sur votre système.
Par exemple, s'il y a beaucoup de fichiers générés, alors vous voudriez probablement que votre
cible propre (que vous ne devriez pas avoir, car "makeppclean" est plus efficace) pour
ressemble à quelque chose comme ça :

$(faux nettoyage) :
$(xargs $(RM), $(only_targets **/*))

Cela a également pour effet secondaire qu'aucune commande n'est générée si la liste
se trouve être vide. Mais dans ce cas, il serait préférable d'utiliser le &rm intégré,
car les arguments des commandes intégrées ne sont limités que par la mémoire de Perl :

$(faux nettoyage) :
&rm -f $(seulement_cibles **/*)

Si un troisième argument est spécifié, il est utilisé pour postfixer chaque commande. C'est
utile pour spécifier des redirecteurs, par exemple (bien qu'ici encore &echo aiderait) :

manifeste:
&rm -f $@
&touchez $@
$(xargs echo, $(only_nontargets **/*), >> $@)

Une partie de cette documentation est basée sur la documentation GNU make.

Veuillez noter que si une fonction est appelée pendant l'initialisation du makefile, par exemple le
l'expansion des variables d'exportation, les messages d'erreur ou d'avertissement rapporteront le numéro de ligne 0.

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