makepp_functions - En ligne dans le Cloud

PROGRAMME:

Nom

makepp_functions -- Fonctions dans makepp

DESCRIPTION

A: nom_de_fichier_absolu,
nom_de_fichier_absolu_nolink,
abspath,
ajouter un préfixe,
ajoute un suffixe,
et, B: nom de base, C: appel, D: d,
dir_noslash, E: Erreur, F: fichiersubst,
L’attache
filtre_sortie,
filter_out_dirs,
trouver un fichier,
trouver_premier_vers_le_haut,
trouver_programme,
trouver une chaîne,
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: généré uniquement,
uniquement_non-cibles,
cibles_de_réponse_uniquement,
seulement_sale,
cibles_uniquement,
ou,
origine, P: patsubst,
perle,
faux,
pré-construire,
impression, R: chemin réel,
nom_de_fichier_relatif,
relatif à, S: le filtre
Trier,
bande,
subst,
suffixe, T: temporaire, W: Attention,
caractère générique,
mot,
liste de mots,
mots, X: xarg

Toute expression du format « $(nom) », où « nom » n'est pas le nom d'une variable, ou
« $(name arg1 arg2 arg3) » est interprété comme un appel de fonction. Le nom peut contenir des lettres.
traits de soulignement ou traits d'union ; pour éviter toute confusion, vous pouvez utiliser des traits d'union ou des traits de soulignement
interchangeables, car les traits d'union internes sont convertis en traits de soulignement. L'évaluation de ces
Une expression invoque simplement une sous-routine Perl. Si « nom » est précédé de « & », elle exécute la
commande ou script intégré de ce nom dans le processus makepp, et renvoie la commande standard
sortie. Ceci nécessite que Perl soit compilé pour PerlIO. Si le nom ne désigne pas une fonction
elle se transforme en une invocation d'appel.

Comme pour les variables, vous avez le choix entre « $(nom ...) » et « ${nom ...} ». Si vous le souhaitez,
intégrer la même parenthèse, elle doit être appariée, l'autre n'a pas d'importance : "$(name
...(){..." 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 sauts de ligne sont
Ils sont alors traités comme des espaces, sauf peut-être dans « define ». Il existe également la syntaxe « $[name ...] ».
ou $[[name ...]], qui est évalué lors de la lecture du makefile, avant de comprendre les règles
et d'autres constructions.

Makepp possède plusieurs fonctions intégrées qui peuvent s'avérer utiles. Il prend en charge la quasi-totalité des
Fonctions textuelles de GNU make (voir la documentation de GNU make pour plus de détails), et certaines de ses
Vous pouvez définir des sous-routines Perl pour effectuer ce que vous voulez. Voir l'instruction « sub ».
et la section sur l'extension de makepp pour plus de détails.

Conditionnel Les fonctions
et condition1[,condition2[,condition3...]]
La fonction « and » fournit une opération « AND » de « court-circuit ». Chaque argument est
développé, dans l'ordre. Si un argument se développe en une chaîne vide, le traitement s'arrête et
Le résultat du développement est une chaîne vide. Si tous les arguments sont développés en une chaîne non
chaîne vide alors 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 instructions « ifeq », etc. Si la chaîne n'est pas vide (c'est-à-dire
condition est vraie), le deuxième argument (la clause « then ») est renvoyé (après
extension de variable) ; si la chaîne est vide, le troisième argument (la clause « else ») est
revenu.

Par exemple,

CFLAGS := $(si $(filtre gcc egcc, $(CC)), -g -Wall, -g)

définit CFLAGS comme étant « -g -Wall » si la variable CC est « gcc » ou « egcc », et « -g »
sinon. (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 « or » fournit une opération « OU » de « court-circuit ». Chaque argument est développé.
dans l'ordre. Si un argument se développe en une chaîne non vide, le traitement s'arrête et le
Le résultat du développement est cette chaîne. Si, après le développement de tous les arguments,
ils sont faux (vides), alors le résultat du développement est la chaîne vide.

Fichier et Nom de fichier Les fonctions
nom_de_fichier_absolu fichiers
abspathique fichiers
Convertit les noms de fichiers relatifs en noms absolus sans . or ... Par exemple,
"$(absolute_filename xyz.c)" peut renvoyer "/usr/src/our_project/subdir/xyz.c".

nom_de_fichier_absolu_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 le dernier point. 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 partie finale
barre oblique. 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.

fichiersubst modèle, remplacer, gentils
Effectue une substitution de motif sur les noms de fichiers. Cette méthode diffère de patsubst en ce sens que
il fonctionnera correctement lorsque des noms alternatifs pour les répertoires sont donnés (à condition que
ils précèdent le signe de pourcentage). Par exemple,

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

fonctionnera avec filesubst mais pas avec patsubst.

filtre_sortie_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é
spécifié. Cela peut être utile pour trouver des binaires ou des fichiers d'inclusion. 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))

Cela localise le fichier tcl.h en recherchant dans 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
est placé dans le chemin d'inclusion.

trouver_programme prénom
Renvoie le premier programme de la liste présent dans le chemin. Ceci est utile.
lorsqu'il existe plusieurs programmes équivalents qui peuvent être utilisés et que vous souhaitez simplement
Choisissez-en un. Par exemple, voici la définition par défaut de plusieurs termes courants.
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 = $(find_program f77 g77 fort77)
CXX = $(find_program 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 ne produit généralement pas de fichier Makefile fonctionnel, mais
aura tendance à améliorer les 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 le remplacera par not-found.
Sinon, le shell tenterait d'exécuter le fichier source et l'erreur résultante
le message pourrait ê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 système de fichiers différent. (Cette dernière exigence vise à éviter les problèmes avec
automounters ou systèmes de fichiers réseau bloqués.) Si vous avez 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 l'option « include »
déclaration):

TOP_LEVEL_INCLUDE_DIR := $(find_upwards inclut)
# Recherche un répertoire contenant 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 la localisation du répertoire de niveau supérieur.
d'une construction. Il est souvent 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 selon les niveaux
de l'arborescence. Vous pouvez également 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 fichier « LICENSE » se trouve uniquement dans le répertoire principal. Vous pouvez alors procéder comme suit :

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

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

(Notez que l'instruction « include » recherche automatiquement les fichiers vers le haut, il n'y a 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 » interrompra la construction avec un message d'erreur.

Si vous spécifiez plusieurs fichiers, find_upwards recherchera le premier, puis
le deuxième, et ainsi de suite. Autrement dit,

$(find_upwards fichier1 fichier2)

équivaut à

$(find_upwards fichier1) $(find_upwards fichier2)

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

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

premier_disponible file1 file2 ...
Renvoie le premier fichier d'une liste existante ou pouvant être créée. Ceci peut être utile pour
adapter vos makefiles pour qu'ils fonctionnent sur plusieurs machines ou réseaux différents, où
Les fichiers importants peuvent être situés à différents endroits. Par exemple, voici une ligne de
un de mes makefiles :

TCL_LIB = $(first_available
/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 emplacements ci-dessus, en s'arrêtant au
Le premier trouvé. La commande link inclut ensuite $(TCL_LIB) pour obtenir le
bibliothèque Tcl appropriée.

infer_linker file1 file2 ...
Étant donné une liste de fichiers objets, commencez par les créer si ce n'est pas déjà fait. Ensuite, recherchez-les.
qu'ils dépendent d'une source Fortran, C++ ou C et renvoient le code correspondant
compilateur (qui sait mieux comment 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. Je l'utilise pour
sélectionner 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
Makepp peut sélectionner les modules pertinents pour vous. Ainsi, seuls
les modules concernés sont compilés.

L'algorithme de Makepp pour déduire les dépendances des objets dépend de la convention selon laquelle
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 »). Ainsi, l'algorithme de Makepp pour
l'inférence des dépendances d'objets commence par un ou quelques objets dont nous savons qu'ils doivent être
lié au programme. Il examine les fichiers inclus avec « #include » dans
ces sources et essaie de trouver les fichiers objets correspondants pour chacune des inclusions
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/dirs/**/*.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 quelques fichiers objets dont on sait qu'ils sont requis (les caractères génériques sont
autorisé ici). La seconde est une liste d'objets possibles (normalement, vous utiliseriez un
(caractère générique ici) qui pourrait être lié si nécessaire. La valeur de retour de ce
la 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
qui sont requis par les objets du premier argument.

Par exemple, supposons que « main.o » provienne de « main.cpp », qui inclut « my_class.h ».
« $(infer_objects) » recherche les fichiers portant le nom « my_class.o ». Si c'est le cas,
Si le fichier 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 contient 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. Aucun nom.
pointer vers le même fichier est renvoyé deux fois, même avec des chemins relatifs différents,
dans une exécution de 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 de l'exécution de makepp, exécutez all
les fichiers renvoyés par cette fonction sont supprimés, s'ils existent (à l'exception de ceux
renvoyé par cette fonction dans le code Perl exécuté dans une règle).

N'importe quel nombre de « X » majuscules à la fin de l'argument est remplacé par autant
Lettres et chiffres aléatoires. Plus il y en a, moins il y a de risques de 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 plusieurs 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). En l'absence d'argument, le préfixe par défaut est
"tmp." dans le répertoire courant.

Notez que vous ne souhaitez pas donner un tel nom aux cibles et dépendances des règles.
le résultat serait correct, mais il serait recréé à chaque fois que vous exécuteriez 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
Compte A Compte B : :build_check ignore_action
produire-As-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 :

exporter TMPFILE ;= $(mktemp)
Compte A Compte B :
produire-As-et-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 $(entrée) -o $(mktemp)
&sed bar $(mktemp /) -o $(output) # Opérer sur la sortie de &grep

notdir noms de fichiers
Renvoie la partie non-répertoire du ou des noms de fichiers, c'est-à-dire tout ce qui suit le dernier
barre oblique s'il y en a une, ou le nom de fichier entier sinon.

généré uniquement 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 de cible propres (bien que bien sûr « makeppclean » soit le
variante préférée) :

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

uniquement_non-cibles noms de fichiers
Renvoie uniquement les noms de fichiers de la liste qui ne sont pas la cible d'une règle (soit
règles explicites ou modèles). Vous pouvez spécifier un caractère générique (voir « $(wildcard ) »
pour plus de détails sur les caractères génériques de Makepp). Ceci peut être utilisé pour générer un
cible de distribution, par exemple :

.PHONY : distribution

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

Dans ce cas, "$(only_nontargets *)" renvoie tous les fichiers du répertoire courant
qui n'est pas visé par une règle. L'éditeur « $(filter_out %~, ...) » est supprimé.
sauvegardes.

Similaire à « only_targets » (voir ci-dessus), « only_nontargets » ne connaît que les cibles qui
ont déjà été définies. Ce problème ne se pose que si vous les 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 garantir qu'il n'y a pas de dépendances sur ces fichiers,
sans forcer une construction propre de toutes les cibles :

(chasse d'eau bidon) :
&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
fichier. Makepp n'a pas une telle fonction intégrée car makepp est (et probablement
devrait rester) agnostique en matière de contrôle des sources.

cibles_uniques noms de fichiers
Renvoie uniquement les noms de fichiers de la liste qui sont réellement les cibles d'une règle
(règles explicites ou modèles). Vous pouvez spécifier des caractères génériques (y compris ceux de makepp)
caractère générique spécial, « ** » dans les noms de fichiers. (Voir la fonction « $(wildcard ) » pour plus d'informations.
Détails. Ceci peut être utilisé pour une cible propre, par exemple :

.PHONY : propre

nettoyer:
&rm -f $(cibles_uniquement *)

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

Un autre endroit où cela peut être utile est d'éviter d'inclure des éléments périmés. .o fichiers dans votre
construire. Par exemple, si vous construisez 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 les fichiers correspondants .o fichiers,
le .o Les fichiers seront toujours là. Cela signifie qu'ils seront toujours intégrés
la bibliothèque, même si elles ne sont plus utiles. 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 Paisible vous
invoquer « cibles-uniques ». Si « cibles_uniques » 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ée jusqu'à l'exécution de la règle. Cependant, si vous l'évaluez, essayez de l'évaluer.
plus tôt dans le makefile avec une variable « := » comme ceci :

TOUTES_CIBLES := $(seulement_cibles *)

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 plutôt l'instruction « load_makefile » ou le chargement implicite du makefile.)

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

RÉPERTOIRE := .
SOUS-RÉP. := ..
FNAME := $(DIR)/../otherdir/$(SUBDIR)/files
X := $(nom_de_fichier_relatif $(FNAME))

If sabrer est vrai (généralement 1), les noms de fichiers renvoyés contiennent forcément une barre oblique
en ajoutant "./" si nécessaire, afin de pouvoir l'utiliser comme nom d'exécutable sans
s'inquiéter du fait que le chemin de recherche de commande remplace 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
environnement, cela se produit également pour /cygdrive/c or /c), un chemin absolu sera
est revenu à la place.

relatif à file1 file2 fichier3[, annuaire]
Renvoie le nom des fichiers par rapport au répertoire spécifié. Ceci 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 $(relatif à $(sortie), ..) $(relatif à ., ..)

suffixe noms...
Extrait le suffixe de chaque nom de fichier dans les noms. Si le nom de fichier contient un point,
Le suffixe est tout ce qui commence par le dernier point. Sinon, le suffixe est le
Chaîne vide. Cela signifie souvent que le résultat sera vide si le nom 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 gentils
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
La volonté peut être affectée par la règle. Une règle n'est pas exécutée si seules ses caractéristiques temporaires
les objectifs sont dépassés.

générique modèle
Renvoie les noms triés de tous les fichiers correspondant au modèle donné qui existent, ou ceux
fichiers qui n'existent pas encore mais qui peuvent être créés selon les règles connues de Makepp
au moment où il évalue l'expression. Sur ce dernier point, il diffère
à partir de 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
caractère générique « ** » qui correspond à n’importe quel nombre de répertoires intermédiaires. (Cette idée a été
volé à partir de zsh.) Par exemple, "**/*.c" correspond à tous les .c fichiers dans la source entière
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. Le
Le caractère générique « ** » ne suivra pas les liens symboliques vers les répertoires à aucun niveau, ni ne
tenter d'accéder à des répertoires existants mais illisibles. Également des 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, gentils
Ajoute la chaîne de préfixe à chaque mot. Ceci est principalement destiné à GNU make.
compatibilité ; en utilisant une extension de style rc, cela peut être fait de 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, gentils
Ajoute la chaîne de suffixe à chaque mot. Ceci est principalement destiné à GNU make.
compatibilité ; en utilisant une extension de style rc, cela peut être fait de manière plus lisible
comme ça:

X_OLD_STYLE := $(ajoute le suffixe .o, $(MODULES))
X_NEW_STYLE := $(MODULES).o

Appelez-nous variable[, mots]...
La fonction « call » est unique en ce sens qu'elle peut être utilisée pour considérer variable en tant que
fonction paramétrée. Vous pouvez lui assigner une expression complexe. variable et utilise
« appeler » pour étendre son contenu à différentes valeurs paramétrées par gentils plus tard. Dans
d'autres systèmes de fabrication, une variable qui est utilisée principalement 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 pleine expansion.

Il n'y a pas de limite au nombre d'arguments avec lesquels une macro peut être « appelée » ou au nombre
paramètres qu'une macro peut attendre. Si vous passez plus d'arguments à « call » comme macro
Si nécessaire, tous les arguments excédentaires seront rejetés. Si vous passez moins d'arguments qu'un
macro attendue, tous les paramètres excédentaires s'effondrent dans la chaîne vide.

Tout 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 = $(si $2,$(appeler $1,$(premier mot $2)) $(appeler $0,$1,$(appeler le reste,$2)))
downcase = ${makeperl lc("$1")}

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

Maintenant, « $(DCWORDS) » contient « tous ces mots sont en majuscules ». Au fait : cela ne fait rien.
différence, que nous accédions aux arguments via $1, "${1}" or "$(1)" dans 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 ce sont
équivalent:

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

Il peut sembler discutable de savoir si « $[call] » devrait également étendre 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'insérer "$[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 avez une macro pour définir une
règle, vous voulez que des expressions comme "$(output)" soient visibles lorsque la règle est analysée, donc
vous devez les protéger de « l'appel » :

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, gentils
Renvoie tous les mots de la liste correspondant aux motifs. Ces motifs peuvent être simplement différents.
des mots ou des caractères génériques de nom de fichier (c'est-à-dire que « * », « ? » et « [az] » sont reconnus), ou ils peuvent
avoir un caractère « % », ce qui signifie qu'il correspond à n'importe quelle chaîne à ce point (identique à « * »).

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

Par exemple :

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

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

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

premier mot gentils
Renvoie le premier mot.

plan 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 à son tour et renvoie le
résultats. La première variante est du code Perl brut, tandis que la seconde variante transmet d'abord
le code Perl via l'expansion de variables de type Make. Les mots sont développés dans les deux
Cas.

Les mots sont dans $_ et sont renvoyés sauf si vous annulez la définition de $_. Ceci est prévu pour
Modifications difficiles à gérer par « patsubst ». Seule la première virgule sert de séparateur.
tous les autres sont considérés comme faisant partie du code perl.

# Changer de mot. Doublez les parenthèses pour autoriser les parenthèses dans le code Perl, 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 $$_ = 'échec')
# Vous pouvez éliminer des candidats :
Y = $(map $(VALEURS), indéfini $_ si /no_good/)

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

patsubst modèle, remplacer, gentils
Effectue une substitution sur chaque mot de la liste. Le caractère « % » correspond à n'importe quel mot.
chaîne. Un exemple illustre bien ce point :

OBJS = $(patsubst %.c, object_dir/%.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 par ordre lexical et supprime les doublons.

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

subst de, à, texte
Effectue un remplacement textuel sur le texte text : 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 "fEEt on the strEEt".

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

liste de mots liste d'index, gentils
liste de mots premierindex, dernierindex, gentils
Dans le premier formulaire, vous fournissez une liste d'indices (en comptant à partir de 1 au début ou
(à partir de -1 à la fin) pour sélectionner les mots souhaités. Dans le second formulaire,
spécifiez la plage de mots que vous souhaitez renvoyer.

gentils texte
Renvoie le nombre de mots dans texte.

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

Cet exemple simple définit la variable fichiers à la liste de tous les fichiers dans le
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 (sauf pour le réglage de « dirs ») que l'exemple suivant :

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

Lorsque le texte est compliqué, vous pouvez améliorer sa 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 « = » pour définir un
variable à expansion récursive, de sorte que sa valeur contienne un appel de fonction réel à
être ré-extensible sous le contrôle de foreach ; une variable simplement étendue 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 résultat « rien ». Le premier texte est envoyé vers STDOUT, le second vers STDERR.
le troisième interrompt en outre le traitement.

pré-construire objectifs
a prendre une objectifs
Renvoie son argument textuellement, mais construit d'abord tous les fichiers listés. Ceci est utile.
Lorsqu'un fichier donné est requis pour l'évaluation d'une expression make. Cela se produit généralement.
lorsque vous avez une build où l'ensemble des fichiers impliqués est calculé par un shell
commandes. Par exemple,

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

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

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

liste_de_fichiers ;= $(&cat $(pré-construit liste_de_fichiers))

mon_programme1 : ao $(liste_fichiers)

mon_programme2 : bo $(liste_fichiers)

Si au lieu de cela vous spécifiiez simplement "$(&cat file_list)", alors makepp ne forcerait pas
La liste de fichiers doit être mise à jour avant l'exécution de la commande shell. Utilisation de « $(prebuild ) »
est la meilleure façon de résoudre ce problème. Vous pourriez être tenté d'essayer d'autres solutions, comme
ce:

mon_programme : liste_de_fichiers $(&cat liste_de_fichiers)

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

cibles_phonétiques_uniquement 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 bidons) : $(only_phony_targets */**/tests)

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

perl code perl
maquillage code perl
Évalue le code Perl dans un bloc et renvoie le résultat. La première variante est du Perl brut.
code, tandis que la deuxième variante passe d'abord le code Perl via une 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 code Perl en dehors des chaînes entre guillemets simples ou doubles. Vous pouvez toutefois 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) # une variable Make et une variable Perl
VAR = $((perl if( ... ) { ... }))

faux gentils
Indique que la liste de mots sont en fait de fausses cibles et renvoie la liste des
Cibles. Son utilisation est prévue comme suit :

$(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
Affiche le texte et le renvoie. Ceci est particulièrement utile pour le débogage, lorsque vous n'en avez pas besoin.
comprendre pourquoi la substitution de variables produit le résultat escompté. Par exemple,

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

imprimera le résultat de l'appel « patsubst ».

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

imprimera le dernier argument de l'appel « patsubst ».

coquille shell-commande
Renvoie la sortie de la commande shell donnée, avec les nouvelles lignes remplacées 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. Vous pouvez toutefois la 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 qui commencent chacune par le caractère spécifié
commande, et terminez avec autant d'éléments de la liste que possible sans dé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, vous voudrez 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
est vide. Dans ce cas, il serait préférable d'utiliser la commande intégrée &rm,
car les arguments des commandes intégrées ne sont limités que par la mémoire de Perl :

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

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

manifeste:
&rm -f $@
&toucher $@
$(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
l'expansion des variables d'exportation, les messages d'erreur ou d'avertissement signaleront le numéro de ligne 0.

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