pmake - En ligne dans le Cloud

PROGRAMME:

Nom

bfaire — maintenir les dépendances du programme

SYNOPSIS

bfaire [-BeikNnqrstWwX] [-C annuaire] [-D variable] [-d drapeaux] [-f makefile] [-I annuaire]
[-J Privé] [-j max_emplois] [-m annuaire] [-T filet] [-V variable] [variable=valeur]
[l'objectif ...]

DESCRIPTION

bfaire est un programme conçu pour simplifier la maintenance d'autres programmes. Son entrée est un
liste de spécifications quant aux fichiers dont dépendent les programmes et autres fichiers. Sinon -f
makefile l'option makefile est donnée, bfaire va essayer d'ouvrir 'makefile' puis 'Makefile' dans
afin de trouver les spécifications. Si le fichier '.dépendre' existe, il est lu (voir mkdep(1)).

Cette page de manuel est conçue comme un document de référence uniquement. Pour une description plus complète
of bfaire et makefiles, veuillez vous référer à Pfaire - A Tutoriel.

bfaire précédera le contenu du MARQUEFLAGS variable d'environnement à la ligne de commande
arguments avant de les analyser.

Les options sont les suivantes :

-B Essayez d'être rétrocompatible en exécutant un seul shell par commande et en
exécuter les commandes pour créer les sources d'une ligne de dépendance dans l'ordre.

-C annuaire
Changer pour annuaire avant de lire les makefiles ou de faire quoi que ce soit d'autre. Si
plusieurs -C les options sont spécifiées, chacune est interprétée par rapport à la précédente :
-C / -C etc équivaut à -C / Etc.

-D variable
Définir variable à 1, dans le contexte mondial.

-d [-]drapeaux
Activez le débogage et spécifiez les parties de bfaire sont d'imprimer le débogage
informations. À moins que les drapeaux ne soient précédés de '-', ils sont ajoutés à la MARQUEFLAGS
variable d'environnement et sera traité par tout processus make enfant. Par défaut,
les informations de débogage sont imprimées avec l'erreur standard, mais cela peut être modifié en utilisant
le F indicateur de débogage. La sortie de débogage est toujours sans tampon ; en plus, si
le débogage est activé mais la sortie de débogage n'est pas dirigée vers la sortie standard, alors
la sortie standard est tamponnée en ligne. Drapeaux est un ou plusieurs des éléments suivants :

A Imprimer toutes les informations de débogage possibles ; équivaut à spécifier tous les
les drapeaux de débogage.

a Imprimez des informations de débogage sur la recherche et la mise en cache des archives.

C Affiche les informations de débogage sur le répertoire de travail actuel.

c Imprimer des informations de débogage sur l'évaluation conditionnelle.

d Imprimez des informations de débogage sur la recherche de répertoires et la mise en cache.

e Imprimez des informations de débogage sur les commandes et les cibles ayant échoué.

F[+]nom de fichier
Spécifiez où la sortie de débogage est écrite. Ce doit être le dernier drapeau,
car il consomme le reste de l'argument. Si le personnage
immédiatement après que le drapeau 'F' soit '+', alors le fichier sera ouvert dans
mode d'ajout ; sinon le fichier sera écrasé. Si le nom du fichier est
'stdout' ou 'stderr' alors la sortie de débogage sera écrite dans le standard
descripteurs de sortie ou de sortie d'erreur standard respectivement (et le '+'
option n'a aucun effet). Sinon, la sortie sera écrite dans le nom
déposer. Si le nom du fichier se termine par '.%d', alors le '%d' est remplacé par le pid.

f Imprimer des informations de débogage sur l'évaluation de la boucle.

g1 Imprimez le graphique d'entrée avant de faire quoi que ce soit.

g2 Imprimez le graphique d'entrée après avoir tout fait, ou avant de quitter en cas d'erreur.

g3 Imprimez le graphique d'entrée avant de quitter en cas d'erreur.

j Imprimez des informations de débogage sur l'exécution de plusieurs shells.

l Imprimer les commandes dans les Makefiles, qu'elles soient ou non préfixées
par '@' ou d'autres indicateurs "silencieux". Également connu sous le nom de comportement "fort".

M Imprimez des informations de débogage sur les décisions du mode "méta" concernant les cibles.

m Imprimer des informations de débogage sur la création de cibles, y compris la modification
Rendez-vous.

n Ne supprimez pas les scripts de commandes temporaires créés lors de l'exécution de commandes.
Ces scripts temporaires sont créés dans le répertoire référencé par le
variable d'environnement TMPDIR, ou dans / Tmp si TMPDIR est désactivé ou défini sur le
chaîne vide. Les scripts temporaires sont créés par mkstemp(3), et ont
noms de la forme faireXXXXXX. REMARQUE: Cela peut créer de nombreux fichiers dans TMPDIR ou
/ Tmp, donc à utiliser avec précaution.

p Affichez les informations de débogage sur l'analyse du makefile.

s Imprimez des informations de débogage sur les règles de transformation de suffixe.

t Imprimez des informations de débogage sur la maintenance de la liste cible.

V Forcer le -V option pour imprimer les valeurs brutes des variables.

v Imprimer les informations de débogage sur l'affectation des variables.

x Exécutez les commandes shell avec -x donc les commandes réelles sont imprimées telles quelles
réalisé.

-e Spécifiez que les variables d'environnement remplacent les affectations de macros dans les makefiles.

-f makefile
Spécifiez un makefile à lire au lieu de la valeur par défaut 'makefile'. Si makefile est '-»,
l'entrée standard est lue. Plusieurs makefiles peuvent être spécifiés et sont lus dans le
ordre spécifié.

-I annuaire
Spécifiez un répertoire dans lequel rechercher les makefiles et les makefiles inclus. Les
répertoire makefile système (ou répertoires, voir le -m option) est automatiquement
inclus dans cette liste.

-i Ignorer la sortie non nulle des commandes shell dans le makefile. Équivaut à spécifier
»-' avant chaque ligne de commande dans le makefile.

-J Privé
Cette option devrait pas être spécifié par l'utilisateur.

When the j est en cours d'utilisation dans une construction récursive, cette option est transmise par un make à
l'enfant fait pour permettre à tous les processus de fabrication de la construction de coopérer pour éviter
surcharge du système.

-j max_emplois
Spécifiez le nombre maximum de travaux qui bfaire peut avoir en cours d'exécution à tout moment. Les
la valeur est enregistrée dans .FAIRE.DES TRAVAUX. Désactive le mode de compatibilité, sauf si le B le drapeau est
également précisé. Lorsque le mode de compatibilité est désactivé, toutes les commandes associées à un
cible sont exécutés dans une seule invocation de shell par opposition à la traditionnelle
appel du shell par ligne. Cela peut casser les scripts traditionnels qui changent
répertoires à chaque appel de commande, puis attendez-vous à démarrer avec un nouveau
environnement sur la ligne suivante. Il est plus efficace de corriger les scripts plutôt
que d'activer la rétrocompatibilité.

-k Continuer le traitement une fois que des erreurs sont rencontrées, mais uniquement sur les cibles qui le font
dépend pas de la cible dont la création a causé l'erreur.

-m annuaire
Spécifiez un répertoire dans lequel rechercher sys.mk et makefiles inclus via le
⟨filetDéclaration d'inclusion de style ⟩. Les -m L'option peut être utilisée plusieurs fois pour former un
chemin de recherche. Ce chemin remplacera le chemin d'inclusion système par défaut :
/usr/share/mk. De plus, le chemin d'inclusion du système sera ajouté à la recherche
chemin utilisé pour "filet"-style include instructions (voir le -I option).

Si un nom de fichier ou de répertoire dans le -m argument (ou l'environnement MAKESYSPATH
variable) commence par la chaîne ".../" puis bfaire recherchera le spécifié
fichier ou répertoire nommé dans la partie restante de la chaîne d'argument. La recherche
commence par le répertoire courant du Makefile puis remonte vers le
racine du système de fichiers. Si la recherche est réussie, le répertoire résultant
remplace la spécification ".../" dans le -m argument. Si elle est utilisée, cette fonction permet
bfaire pour rechercher facilement dans l'arborescence source actuelle des fichiers sys.mk personnalisés (par exemple,
en utilisant ".../mk/sys.mk" comme argument).

-n Afficher les commandes qui auraient été exécutées, mais ne les exécutez pas réellement
sauf si la cible dépend de la source spéciale .MAKE (voir ci-dessous).

-N Affiche les commandes qui auraient été exécutées, mais n'exécute en fait aucune
d'eux; utile pour déboguer les makefiles de niveau supérieur sans descendre dans
sous-répertoires.

-q N'exécutez aucune commande, mais quittez 0 si les cibles spécifiées sont à jour et
1, sinon.

-r N'utilisez pas les règles intégrées spécifiées dans le makefile du système.

-s Ne répercutez aucune commande lorsqu'elle est exécutée. Équivaut à spécifier '@' avant
chaque ligne de commande dans le makefile.

-T fichier de trace
Lorsqu'il est utilisé avec -j indicateur, ajoutez un enregistrement de trace à fichier de trace pour chaque travail commencé
et terminé.

-t Plutôt que de reconstruire une cible comme spécifié dans le makefile, créez-la ou mettez à jour
son heure de modification pour qu'il apparaisse à jour.

-V variable
Imprimé bfairel'idée de la valeur de variable, dans le contexte mondial. Ne pas construire
toutes les cibles. Plusieurs instances de cette option peuvent être spécifiées ; les variables seront
être imprimé un par ligne, avec une ligne vide pour chaque variable nulle ou indéfinie. Si
variable contient un '$' alors la valeur sera développée avant l'impression.

-W Traitez tous les avertissements pendant l'analyse du makefile comme des erreurs.

-w Imprimez les messages entrants et sortants du répertoire, pré et post-traitement.

-X N'exportez pas les variables transmises sur la ligne de commande à l'environnement individuellement.
Les variables passées sur la ligne de commande sont toujours exportées via le MARQUEFLAGS
variable d'environnement. Cette option peut être utile sur les systèmes qui ont une petite limite
sur la taille des arguments de commande.

variable=valeur
Définir la valeur de la variable variable à Plus-value. Normalement, toutes les valeurs transmises au
ligne de commande sont également exportés vers les sous-marques de l'environnement. Les -X drapeau
désactive ce comportement. Les affectations de variables doivent suivre les options pour POSIX
compatibilité mais aucune commande n'est appliquée.

Il existe sept types de lignes différents dans un makefile : les spécifications de dépendance de fichier,
commandes shell, affectations de variables, instructions include, directives conditionnelles, boucles for,
et commentaires.

En général, les lignes peuvent être continuées d'une ligne à l'autre en les terminant par une barre oblique inverse
('\'). Le caractère de fin de ligne et l'espace blanc initial sur la ligne suivante sont
compressé dans un seul espace.

DOSSIER DÉPENDANCE DONNÉES TECHNIQUES

Les lignes de dépendance se composent d'une ou plusieurs cibles, d'un opérateur et de zéro ou plusieurs sources.
Cela crée une relation dans laquelle les cibles « dépendent » des sources et sont généralement
créé à partir d'eux. La relation exacte entre la cible et la source est déterminée
par l'opérateur qui les sépare. Les trois opérateurs sont les suivants :

: Une cible est considérée comme obsolète si son heure de modification est inférieure à celle de n'importe quel
de ses sources. Les sources d'une cible s'accumulent sur les lignes de dépendance lorsque cette
l'opérateur est utilisé. La cible est supprimée si bfaire est interrompu.

! Les cibles sont toujours recréées, mais pas tant que toutes les sources n'ont pas été examinées et reconstituées.
créé si nécessaire. Les sources d'une cible s'accumulent sur les lignes de dépendance lorsque cette
l'opérateur est utilisé. La cible est supprimée si bfaire est interrompu.

:: Si aucune source n'est spécifiée, la cible est toujours recréée. Sinon, une cible est
considérée comme obsolète si l'une de ses sources a été modifiée plus récemment que la
cible. Les sources d'une cible ne s'accumulent pas sur les lignes de dépendance lorsque cette
l'opérateur est utilisé. La cible ne sera pas supprimée si bfaire est interrompu.

Les cibles et les sources peuvent contenir les valeurs génériques du shell '?', '*', '[]' et '{}'. Les
les valeurs '?', '*' et '[]' ne peuvent être utilisées que dans le cadre du composant final de la cible ou
source, et doit être utilisé pour décrire les fichiers existants. La valeur '{}' ne doit pas nécessairement être
utilisé pour décrire les fichiers existants. L'extension est dans l'ordre des répertoires, pas par ordre alphabétique comme
fait dans la coquille.

SHELL COMMANDES

A chaque cible peut être associée une ou plusieurs lignes de commandes shell, normalement utilisées
pour créer la cible. Chacune des lignes de ce script doit être précédé d'une tabulation. (Pour
raisons historiques, les espaces ne sont pas acceptés.) Alors que les cibles peuvent apparaître dans de nombreuses dépendances
lignes si vous le souhaitez, par défaut une seule de ces règles peut être suivie d'un script de création.
Si la '::' est utilisé, cependant, toutes les règles peuvent inclure des scripts et les scripts sont
exécutés dans l'ordre trouvé.

Chaque ligne est traitée comme une commande shell distincte, à moins que la fin de la ligne ne soit échappée avec un
barre oblique inverse ('\') auquel cas cette ligne et la suivante sont combinées. Si les premiers caractères
de la commande sont une combinaison de '@','+', ou '-', la commande est traitée spécialement. UNE
»@' fait que la commande n'est pas renvoyée avant son exécution. UNE '+' entraîne la commande à
être exécuté même lorsque -n est donné. Ceci est similaire à l'effet du .MAKE spécial
source, sauf que l'effet peut être limité à une seule ligne d'un script. UNE '-' dans
Le mode de compatibilité entraîne l'ignorance de tout état de sortie différent de zéro de la ligne de commande.

Quand bfaire est exécuté en mode travaux avec -j max_emplois, l'intégralité du script de la cible est transmise à
une seule instance du shell. En mode de compatibilité (hors travaux), chaque commande est exécutée dans un
processus séparé. Si la commande contient des méta-caractères du shell
('#=|^(){};&<>*?[]:$`\\n') il sera passé au shell ; autrement bfaire va tenter
exécution directe. Si une ligne commence par '-' et le shell a ErrCtl activé puis échec
de la ligne de commande sera ignoré comme en mode de compatibilité. Autrement '-' affecte le
tout le travail ; le script s'arrêtera à la première ligne de commande qui échoue, mais la cible
pas être réputé avoir échoué.

Les makefiles doivent être écrits de telle sorte que le mode de bfaire l'opération ne change pas leur
comportement. Par exemple, toute commande qui doit utiliser « cd » ou « chdir » sans potentiellement
le changement de répertoire pour les commandes suivantes doit être mis entre parenthèses afin qu'il s'exécute
dans un sous-shell. Pour forcer l'utilisation d'un shell, échappez les sauts de ligne afin de rendre le
script entier une seule commande. Par exemple:

éviter-chdir-effets-secondaires :
@echo Bâtiment $@ dans `pwd`
@(cd ${.CURDIR} && ${MAKE} $@)
@echo De retour dans `pwd`

assurer-un-shell-indépendamment du mode :
@echo Bâtiment $@ dans `pwd`; \
(cd ${.CURDIR} && ${MAKE} $@); \
echo Retour dans `pwd`

Depuis que bfaire vont chdir(2) à '.OBJDIR' avant d'exécuter des cibles, chaque processus enfant
commence par cela comme son répertoire de travail actuel.

VARIABLE CESSIONS

Les variables dans make ressemblent beaucoup aux variables dans le shell et, par tradition, consistent en tous
majuscules.

Variable affectation modificateurs
Les cinq opérateurs qui peuvent être utilisés pour affecter des valeurs aux variables sont les suivants :

= Attribuez la valeur à la variable. Toute valeur précédente est remplacée.

+= Ajoutez la valeur à la valeur actuelle de la variable.

?= Affectez la valeur à la variable si elle n'est pas déjà définie.

:= Affecter avec expansion, c'est-à-dire étendre la valeur avant de l'affecter à la variable.
Normalement, l'expansion n'est pas effectuée tant que la variable n'est pas référencée. REMARQUE: Les références
aux variables non définies sont pas étendu. Cela peut causer des problèmes lorsque la variable
des modificateurs sont utilisés.

!= Développez la valeur et transmettez-la au shell pour exécution et affectez le résultat au
variable. Toutes les nouvelles lignes dans le résultat sont remplacées par des espaces.

Tout espace blanc avant l'assigné Plus-value est retiré; si la valeur est ajoutée, un
un seul espace est inséré entre le contenu précédent de la variable et le
valeur.

Les variables sont développées en entourant le nom de la variable avec des accolades ('{}') ou
parenthèses ('()') et le précédant d'un signe dollar ('$'). Si le nom de la variable contient
une seule lettre, les accolades ou les parenthèses environnantes ne sont pas nécessaires. Ce plus court
la forme n'est pas recommandée.

Si le nom de la variable contient un dollar, le nom lui-même est développé en premier. Ceci permet
noms de variables presque arbitraires, mais les noms contenant dollar, accolades, parenthèses ou
Les espaces blancs sont vraiment à éviter !

Si le résultat du développement d'une variable contient un signe dollar ("$"), la chaîne est développée
nouveau.

La substitution de variable se produit à trois moments distincts, selon l'endroit où la variable est
utilisé.

1. Les variables dans les lignes de dépendance sont développées au fur et à mesure que la ligne est lue.

2. Les variables dans les commandes shell sont développées lorsque la commande shell est exécutée.

3. Les variables d'index de boucle « .for » sont développées à chaque itération de boucle. Notez que d'autres
les variables ne sont pas développées à l'intérieur des boucles, donc l'exemple de code suivant :

.pour moi en 1 2 3
un+= ${i}
j=${i}
b+= ${j}
.endpour

tout:
@écho ${a}
@écho ${b}

imprimera:

1 2 3
3 3 3

Parce que tandis que ${a} contient "1 2 3" après l'exécution de la boucle, ${b} contient "${j}
${j} ${j}" qui se développe en "3 3 3" car une fois la boucle terminée, ${j} contient "3".

Variable les classes
Les quatre classes différentes de variables (par ordre de priorité croissante) sont :

Variables d'environnement
Variables définies dans le cadre de bfairel'environnement.

Variables globales
Variables définies dans le makefile ou dans les makefiles inclus.

Variables de ligne de commande
Variables définies dans le cadre de la ligne de commande.

Variables locales
Variables définies spécifiques à une certaine cible.

Les variables locales sont toutes intégrées et leurs valeurs varient comme par magie d'une cible à l'autre. Ce
n'est actuellement pas possible de définir de nouvelles variables locales. Les sept variables locales sont comme
suit:

.ALLSRC La liste de toutes les sources pour cette cible ; aussi connu sous le nom '>".

.ARCHIVER Le nom du fichier d'archive ; aussi connu sous le nom '!".

.IMPSRC Dans les règles de transformation de suffixe, le nom/chemin de la source à partir de laquelle le
la cible doit être transformée (la source « implicite »); aussi connu sous le nom '<'. Ce
n'est pas défini dans des règles explicites.

.MEMBRE Le nom du membre de l'archive ; aussi connu sous le nom '%".

.OODATE La liste des sources de cette cible jugées obsolètes ; également connu
sous '?".

.PRÉFIXE Le préfixe du fichier de la cible, ne contenant que la partie du fichier, pas de suffixe
ou des composants de répertoire précédents ; aussi connu sous le nom '*'. Le suffixe doit être
l'un des suffixes connus déclarés avec .SUFFIXES ou ce ne sera pas
reconnu.

.CIBLE Le nom de la cible ; aussi connu sous le nom '@".

Les formes plus courtes ('>','!','<','%','?','*', et '@') sont autorisés pour l'arrière
compatibilité avec les makefiles historiques et les makefiles POSIX hérités et ne sont pas recommandés.

Des variantes de ces variables avec la ponctuation suivie immédiatement de « D » ou « F », par exemple
»$ (@D)', sont des formes héritées équivalentes à l'utilisation des modificateurs ':H' et ':T'. Ces formulaires sont
acceptés pour la compatibilité avec les makefiles AT&T System V UNIX et POSIX mais ne sont pas
recommandé.

Quatre des variables locales peuvent être utilisées dans les sources sur les lignes de dépendance car elles s'étendent
à la valeur appropriée pour chaque cible sur la ligne. Ces variables sont '.CIBLE','.PRÉFIXE»,
».ARCHIVER', et '.MEMBRE".

Supplémentaire intégré les variables
Par ailleurs, bfaire définit ou connaît les variables suivantes :

$ Un seul signe dollar '$', c'est-à-dire '$$' se développe en un seul signe dollar.

.ALLTARGETS La liste de toutes les cibles rencontrées dans le Makefile. Si évalué pendant
L'analyse du Makefile ne répertorie que les cibles rencontrées jusqu'à présent.

.CURDIR Un chemin vers le répertoire où bfaire a été exécuté. Se référer au descriptif
de « PWD » pour plus de détails.

.INCLUDFROMDIR
Le répertoire du fichier à partir duquel ce Makefile a été inclus.

.INCLUDDFROMFILE
Le nom de fichier du fichier à partir duquel ce Makefile a été inclus.

FAIRE Le nom qui bfaire a été exécuté avec (arg[0]). Pour la compatibilité bfaire
définit également .FAIRE avec la même valeur. La variable préférée à utiliser est la
variable d'environnement MAKE car elle est plus compatible avec les autres versions
of bfaire et ne peut pas être confondu avec la cible spéciale du même nom.

.MAKE.DEPENDFILE
Nomme le makefile (par défaut '.dépendre') à partir de laquelle les dépendances générées sont
lire.

.MAKE.EXPAND_VARIABLES
Un booléen qui contrôle le comportement par défaut du -V option.

.FAIRE.EXPORTER La liste des variables exportées par bfaire.

.FAIRE.DES TRAVAUX L'argument à la -j option.

.FAIRE.LE.PRÉFIXE.DE.TRAVAIL
If bfaire est exécuté avec j puis la sortie pour chaque cible est préfixée par un jeton
'--- cible ---' dont la première partie peut être contrôlée via
.FAIRE.LE.PRÉFIXE.DE.TRAVAIL. Si .FAIRE.LE.PRÉFIXE.DE.TRAVAIL est vide, aucun jeton n'est imprimé.
Par exemple : .MAKE.JOB.PREFIX=${.newline}---${.MAKE:T}[${.MAKE.PID}]
produire des jetons comme '---make[1234] target ---' ce qui facilite le suivi du
degré de parallélisme atteint.

MAKEFLAGS La variable d'environnement 'MAKEFLAGS' peut contenir tout ce qui peut être
spécifié sur bfairela ligne de commande de. Tout ce qui est spécifié sur bfairecommande de
est ajoutée à la variable 'MAKEFLAGS' qui est ensuite entrée dans le
environnement pour tous les programmes qui bfaire exécute.

.MAKE.NIVEAU La profondeur de récursivité de bfaire. L'instance initiale de bfaire sera 0, et
une valeur incrémentée est mise dans l'environnement pour être vue par le prochain
génération. Cela permet des tests comme : .if ${.MAKE.LEVEL} == 0 pour protéger
choses qui ne devraient être évaluées que dans l'instance initiale de bfaire.

.MAKE.MAKEFILE_PREFERENCE
La liste ordonnée des noms de makefile (par défaut 'makefile','Makefile') cette
bfaire cherchera.

.MAKE.MAKEFILES
La liste des makefiles lus par bfaire, ce qui est utile pour le suivi
dépendances. Chaque makefile n'est enregistré qu'une seule fois, quel que soit le nombre
de fois lu.

.MAKE.MODE Traité après avoir lu tous les makefiles. Peut affecter le mode qui bfaire fonctionne
in. Il peut contenir un certain nombre de mots-clés :

compat J'aime -B, met bfaire en mode "compat".

objectif Puts bfaire en mode "méta", où les méta-fichiers sont créés pour
chaque cible pour capturer l'exécution de la commande, la sortie générée et
if filemon(4) est disponible, les appels système qui sont de
intérêt pour bfaire. La sortie capturée peut être très utile lorsque
diagnostiquer les erreurs.

curdirOk= bf Normalement bfaire ne créera pas de fichiers .meta dans '.CURDIR'. Cette
peut être annulé en définissant bf à une valeur qui représente
Vrai.

env Pour le débogage, il peut être utile d'inclure l'environnement dans
le fichier .meta.

verbeux Si vous êtes en mode "méta", imprimez un indice sur la cible en cours de construction.
Ceci est utile si la construction s'exécute autrement en silence. Les
le message a imprimé la valeur de : .MAKE.META.PREFIX.

ignorer-cmd Certains makefiles ont des commandes qui ne sont tout simplement pas stables. Cette
mot-clé les fait ignorer pour déterminer si un
la cible est obsolète en mode "méta". Voir également .NOMETA_CMP.

silencieux = bf If bf est Vrai, lorsqu'un fichier .meta est créé, marquez la cible
.SILENCIEUX.

.FAIRE.META.BAILIWICK
En mode "méta", fournit une liste de préfixes qui correspondent aux répertoires
controlé par bfaire. Si un fichier qui a été généré en dehors de .OBJDIR mais
au sein dudit bailliage est manquant, la cible actuelle est considérée comme hors de
date.

.FAIRE.LE.META.CRÉÉ
En mode "méta", cette variable contient une liste de tous les fichiers méta mis à jour.
S'il n'est pas vide, il peut être utilisé pour déclencher le traitement de .CRÉER.DES.META.FILES.

.CRÉER.DES.META.FILES
En mode "méta", cette variable contient une liste de tous les fichiers méta utilisés
(mis à jour ou non). Cette liste peut être utilisée pour traiter les méta-fichiers à
extraire les informations de dépendance.

.MAKE.META.IGNORE_PATHS
Fournit une liste de préfixes de chemin qui doivent être ignorés ; parce que le
on s'attend à ce que le contenu change au fil du temps. La liste par défaut comprend : '/ dev
/ Etc / proc / Tmp / var / run / Var / tmp»

.MAKE.META.PREFIX
Définit le message imprimé pour chaque méta-fichier mis à jour en "méta verbose"
mode. La valeur par défaut est:
Bâtiment ${.TARGET:H:tA}/${.TARGET:T}

.MAKEOVERRIDES Cette variable est utilisée pour enregistrer les noms des variables affectées sur le
ligne de commande, afin qu'ils puissent être exportés dans le cadre de 'MAKEFLAGS'. Cette
le comportement peut être désactivé en attribuant une valeur vide à '.MAKEOVERRIDES»
dans un makefile. Des variables supplémentaires peuvent être exportées à partir d'un makefile en
en ajoutant leurs noms à '.MAKEOVERRIDES'. 'MAKEFLAGS' est réexporté
n'importe quand '.MAKEOVERRIDES' est modifié.

.MAKE.PATH_FILEMON
If bfaire a été construit avec filemon(4) support, ceci est réglé sur le chemin du
nœud de périphérique. Cela permet aux makefiles de tester cette prise en charge.

.FAIRE.PID L'ID de processus de bfaire.

.FAIRE.PPID L'ID de processus parent de bfaire.

.FAIRE.ÉCONOMISER_DOLLARS
la valeur doit être un booléen qui contrôle si '$$' est conservé lors de l'exécution
':=' affectations. La valeur par défaut est false, pour une compatibilité descendante. Régler
à vrai pour la compatibilité avec d'autres marques. Si défini sur false, '$$' devient
'$' selon les règles d'évaluation normales.

MAKE_PRINT_VAR_ON_ERROR
Quand bfaire s'arrête à cause d'une erreur, il imprime son nom et la valeur de
».CURDIR' ainsi que la valeur de toutes les variables nommées dans
»MAKE_PRINT_VAR_ON_ERROR".

.nouvelle ligne Cette variable reçoit simplement un caractère de nouvelle ligne comme valeur. Cette
permet des extensions à l'aide de la :@ modificateur pour mettre une nouvelle ligne entre les itérations
de la boucle plutôt qu'un espace. Par exemple, l'impression de
»MAKE_PRINT_VAR_ON_ERROR' pourrait être fait comme
${MAKE_PRINT_VAR_ON_ERROR:@v@$v='${$v}'${.newline}@}.

.OBJDIR Un chemin vers le répertoire où les cibles sont construites. Sa valeur est
déterminé en essayant de chdir(2) aux répertoires suivants dans l'ordre et
en utilisant la première correspondance :

1. ${MAKEOBJDIRPREFIX}${.CURDIR}

(Uniquement si 'MAKEOBJDIRPREFIX' est défini dans l'environnement ou sur la commande
ligne.)

2. ${MAKEOBJDIR}

(Uniquement si 'MAKEOBJDIR' est défini dans l'environnement ou sur la commande
ligne.)

3. ${.CURDIR}/obj.${MACHINE}

4. ${.CURDIR}/obj

5. /usr/obj/${.CURDIR}

6. ${.CURDIR}

L'expansion de la variable est effectuée sur la valeur avant qu'elle ne soit utilisée, donc
des expressions telles que
${.CURDIR:S,^/ usr / src,/var/obj,}
peut être utilisé. Ceci est particulièrement utile avec 'MAKEOBJDIR'.

».OBJDIR' peut être modifié dans le makefile via la cible spéciale '.OBJDIR".
Dans tous les cas, bfaire vont chdir(2) vers le répertoire spécifié s'il existe,
Et mettre '.OBJDIR' et 'PWD' dans ce répertoire avant d'exécuter des cibles.

.PARSEDIR Un chemin vers le répertoire du ' actuelMakefile' en cours d'analyse.

.PARSEFIL Le nom de base du courant 'Makefile' en cours d'analyse. Cette variable et
».PARSEDIR' sont tous deux définis uniquement tandis que le 'Fichiers Make' sont en cours d'analyse. Si
vous souhaitez conserver leurs valeurs actuelles, affectez-les à une variable en utilisant
affectation avec extension : (':=»).

.CHEMIN Une variable qui représente la liste des répertoires qui bfaire va chercher
pour les fichiers. La liste de recherche doit être mise à jour en utilisant la cible '.CHEMIN»
plutôt que la variable.

PWD Chemin alternatif vers le répertoire courant. bfaire définit normalement '.CURDIR' à
le chemin canonique donné par obtenir(3). Cependant, si la variable d'environnement
'PWD' est défini et donne un chemin vers le répertoire courant, puis bfaire ensembles
».CURDIR' à la valeur de 'PWD' à la place. Ce comportement est désactivé si
'MAKEOBJDIRPREFIX' est défini ou 'MAKEOBJDIR' contient une transformation de variable.
'PWD' est défini sur la valeur '.OBJDIR' pour tous les programmes qui bfaire
exécute.

.TARGETS La liste des cibles explicitement spécifiées sur la ligne de commande, le cas échéant.

VPATH séparés par des deux-points (« : ») listes de répertoires qui bfaire recherchera des fichiers.
La variable est prise en charge pour la compatibilité avec les anciens programmes make uniquement, utilisez
».CHEMIN' au lieu.

Variable modificateurs
L'expansion de variable peut être modifiée pour sélectionner ou modifier chaque mot de la variable (où un
« mot » est une séquence de caractères délimitée par des espaces). Le format général d'une variable
l'extension est la suivante :

${variable[:modifier[:...]]}

Chaque modificateur commence par un deux-points, qui peut être échappé par une barre oblique inverse ('\').

Un ensemble de modificateurs peut être spécifié via une variable, comme suit :

modificateur_variable=modifier[:...]
${variable :${modifier_variable}[:...]}

Dans ce cas, le premier modificateur de modifier_variable ne commence pas par deux points, car
qui doit apparaître dans la variable de référencement. Si l'un des modificateurs du
modifier_variable contient un signe dollar ("$"), ceux-ci doivent être doublés pour éviter le début
vous propose d’explorer.

Les modificateurs pris en charge sont :

:E Remplace chaque mot de la variable par son suffixe.

:H Remplace chaque mot de la variable par tout sauf le dernier composant.

:Mmodèle
Sélectionnez uniquement les mots qui correspondent modèle. Les caractères génériques standard du shell
('*', '?' et '[]') peuvent être utilisés. Les caractères génériques peuvent être échappés avec un
barre oblique inverse ('\'). En conséquence de la façon dont les valeurs sont divisées en mots, appariées et
puis rejoint, une construction comme
${VAR:M*}
normalisera l'espacement entre les mots, en supprimant tous les espaces de début et de fin, et
convertir plusieurs espaces consécutifs en espaces simples.

:Nmodèle
C'est identique à ':M', mais sélectionne tous les mots qui ne correspondent pas modèle.

:O Classez chaque mot dans la variable par ordre alphabétique. Pour trier les mots dans l'ordre inverse, utilisez le
»:O:[-1..1]' combinaison de modificateurs.

:Bœuf Randomiser les mots dans la variable. Les résultats seront différents à chaque fois que vous vous référez
à la variable modifiée ; utiliser l'affectation avec expansion (':=') pour empêcher de tels
comportement. Par exemple,

LISTE = uno due tre quattro
RANDOM_LIST=${LIST:Ox}
STATIC_RANDOM_LIST : = ${LIST : Ox}

tout:
@echo "${RANDOM_LIST}"
@echo "${RANDOM_LIST}"
@echo "${STATIC_RANDOM_LIST}"
@echo "${STATIC_RANDOM_LIST}"
peut produire une sortie similaire à :

quattro due tre uno
tre due quattro uno
en raison d'un quattro trois
en raison d'un quattro trois

:Q Cite chaque méta-caractère du shell dans la variable, afin qu'il puisse être passé en toute sécurité
par des invocations récursives de bfaire.

:R Remplace chaque mot de la variable par tout sauf son suffixe.

:heure gm
La valeur est une chaîne de format pour strftime(3), en utilisant le courant heure de gm (3).

:hacher
Calculez un hachage 32 bits de la valeur et encodez-le sous forme de chiffres hexadécimaux.

:heure locale
La valeur est une chaîne de format pour strftime(3), en utilisant le courant heure locale (3).

:ta Essayez de convertir la variable en un chemin absolu en utilisant chemin réel(3), en cas d'échec, le
la valeur est inchangée.

:tl Convertit la variable en lettres minuscules.

:tsc
Les mots de la variable sont normalement séparés par un espace lors du développement. Ce modificateur
définit le séparateur sur le caractère c. Si c est omis, aucun séparateur n'est utilisé.
Les échappements communs (y compris les codes numériques octaux) fonctionnent comme prévu.

:tu Convertit la variable en lettres majuscules.

:tW La valeur est traitée comme un mot unique (contenant peut-être du blanc incrusté
espacer). Voir également ':[*]".

:tw La valeur est traitée comme une séquence de mots délimités par des espaces blancs. Voir
également ':[@]".

:S/ancienne_chaîne/nouvelle_chaîne/[1gW]
Modifier la première occurrence de ancienne_chaîne dans la valeur de la variable, en la remplaçant par
nouvelle_chaîne. Si un 'g' est ajouté à la dernière barre oblique du motif, toutes les occurrences dans
chaque mot est remplacé. Si un '1' est ajouté à la dernière barre oblique du motif, seul
le premier mot est affecté. Si un « W » est ajouté à la dernière barre oblique du motif,
alors la valeur est traitée comme un seul mot (contenant éventuellement un espace blanc incorporé).
If ancienne_chaîne commence par un caret ('^'), ancienne_chaîne est ancré au début de
chaque mot. Si ancienne_chaîne se termine par un signe dollar ("$"), il est ancré à la fin de
chaque mot. À l'intérieur nouvelle_chaîne, une esperluette ('&') est remplacée par ancienne_chaîne (sans pour autant
tout '^' ou '$'). N'importe quel caractère peut être utilisé comme délimiteur pour les parties du
chaîne de modification. Les caractères d'ancrage, esperluette et délimiteur peuvent être échappés avec
une barre oblique inverse ('\').

L'expansion variable se produit de manière normale à l'intérieur des deux ancienne_chaîne et nouvelle_chaîne
à la seule exception qu'une barre oblique inverse est utilisée pour empêcher l'expansion d'un dollar
signe ("$"), pas un signe dollar précédent comme d'habitude.

:C/modèle/remplacement/[1gW]
Le manuel de formation :C le modificateur est exactement comme le :S modificateur sauf que les anciennes et nouvelles chaînes,
au lieu d'être de simples chaînes, sont une expression régulière étendue (voir regex(3))
un magnifique modèle et le edchaîne de style (1) remplacement. Normalement, la première occurrence
du motif modèle dans chaque mot de la valeur est remplacé par remplacementL’
Le modificateur « 1 » fait que la substitution s'applique à au plus un mot ; le modificateur 'g'
fait en sorte que la substitution s'applique à autant d'instances du modèle de recherche modèle as
apparaissent dans le ou les mots dans lesquels il se trouve ; le modificateur 'W' fait que la valeur est
traité comme un seul mot (contenant éventuellement un espace blanc intégré). Notez que '1' et
« g » sont orthogonaux ; le premier spécifie si plusieurs mots sont potentiellement
affecté, ce dernier si des substitutions multiples peuvent potentiellement se produire dans chaque
mot affecté.

Quant au :S modificateur, le modèle et remplacement sont soumis à une dilatation variable
avant d'être analysé comme des expressions régulières.

:T Remplace chaque mot de la variable par son dernier composant.

:u Supprimez les mots en double adjacents (comme uniq(1)).

:?true_string:fausse_chaîne
Si le nom de la variable (pas sa valeur), lorsqu'il est analysé comme une expression conditionnelle .if,
évalue à vrai, renvoie comme valeur le true_string, sinon retournez le
fausse_chaîne. Puisque le nom de la variable est utilisé comme expression, :? doit être le premier
modificateur après le nom de la variable elle-même - qui, bien sûr, contiendra généralement
extensions variables. Une erreur courante consiste à essayer d'utiliser des expressions telles que
${NUMBERS:M42:?match:non}
qui teste réellement défini (NUMBERS), pour déterminer si des mots correspondent à "42", vous devez
utilisez quelque chose comme :
${"${NUMBERS:M42}" != "":?match:no}.

:ancienne_chaîne=nouvelle_chaîne
Il s'agit de la substitution de variable de style AT&T System V UNIX. ça doit être le dernier
modificateur spécifié. Si ancienne_chaîne or nouvelle_chaîne ne contiennent pas la correspondance de modèle
caractère % alors on suppose qu'ils sont ancrés à la fin de chaque mot, donc seulement
des suffixes ou des mots entiers peuvent être remplacés. Autrement % est la sous-chaîne de ancienne_chaîne
être remplacé dans nouvelle_chaîne.

L'expansion variable se produit de manière normale à l'intérieur des deux ancienne_chaîne et nouvelle_chaîne
à la seule exception qu'une barre oblique inverse est utilisée pour empêcher l'expansion d'un dollar
signe ("$"), pas un signe dollar précédent comme d'habitude.

:@Temp@un magnifique@
C'est le mécanisme d'extension de boucle de la marque OSF Development Environment (ODE).
Contrairement à .pour l'expansion des boucles se produit au moment de la référence. Attribuer Temp à chaque mot
dans la variable et évaluer un magnifique. La convention ODE est que Temp devrait commencer et
terminer par un point. Par exemple.
${LINKS :@.LINK.@${LN} ${TARGET} ${.LINK.}@}

Cependant une variable à un seul caractère est souvent plus lisible :
${MAKE_PRINT_VAR_ON_ERROR:@v@$v='${$v}'${.newline}@}

:Unouveauval
Si la variable n'est pas définie nouveauval est la valeur. Si la variable est définie, le
la valeur existante est renvoyée. Il s'agit d'une autre fonction de création d'ODE. C'est pratique pour le réglage
CFLAGS par cible par exemple :
${_${.TARGET :T}_CFLAGS :U${DEF_CFLAGS}}
Si une valeur n'est requise que si la variable n'est pas définie, utilisez :
${VAR:D:Unnewval}

:Dnouveauval
Si la variable est définie nouveauval est la valeur.

:L Le nom de la variable est la valeur.

:P Le chemin du nœud qui porte le même nom que la variable est la valeur. Si non
nœud existe ou que son chemin est nul, le nom de la variable est utilisé. Afin de
ce modificateur pour fonctionner, le nom (nœud) doit au moins apparaître à droite d'un
dépendance.

:!cmd!
La sortie de la course cmd est la valeur.

:sh Si la variable n'est pas vide, elle est exécutée comme une commande et la sortie devient la nouvelle
valeur.

:: =str
La variable reçoit la valeur str après remplacement. Ce modificateur et son
les variations sont utiles dans des situations obscures telles que vouloir définir une variable lorsque
les commandes shell sont analysées. Ces modificateurs d'affectation se développent toujours à rien,
donc si apparaissant dans une ligne de règle par eux-mêmes devrait être précédé de quelque chose à garder
bfaire heureux.

Le '::' permet d'éviter les fausses correspondances avec le style AT&T System V UNIX := modificateur et
puisque la substitution se produit toujours le :: = la forme est vaguement appropriée.

::?=str
Pour ce qui est de :: = mais seulement si la variable n'a pas déjà de valeur.

::+=str
Ajouter str à la variable.

::!=cmd
Attribuer la sortie de cmd à la variable.

:[gamme]
Sélectionne un ou plusieurs mots de la valeur, ou effectue d'autres opérations liées au
façon dont la valeur est divisée en mots.

Normalement, une valeur est traitée comme une séquence de mots délimités par des espaces blancs. Certains
les modificateurs suppriment ce comportement, faisant en sorte qu'une valeur soit traitée comme un seul mot
(contenant peut-être un espace blanc intégré). Une valeur vide, ou une valeur qui consiste
entièrement d'espaces blancs, est traité comme un seul mot. Aux fins de la ':[]»
modificateur, les mots sont indexés à la fois vers l'avant en utilisant des entiers positifs (où l'index 1
représente le premier mot), et vers l'arrière en utilisant des entiers négatifs (où index -1
représente le dernier mot).

Le manuel de formation gamme est soumis à une expansion variable, et le résultat élargi est alors
interprété comme suit :

indice Sélectionne un seul mot de la valeur.

Commencer..fin
Sélectionne tous les mots de Commencer à fin, inclus. Par exemple, ':[2..-1]' sélectionne
tous les mots du deuxième au dernier mot. Si Commencer est supérieure fin,
puis les mots sont sortis dans l'ordre inverse. Par exemple, ':[-1..1]' sélectionne tout
les mots du dernier au premier.

* Les modificateurs suivants traitent la valeur comme un seul mot (éventuellement
contenant un espace blanc intégré). Analogue à l'effet de "$*" à Bourne
coquille.

0 Signifie la même chose que ':[*]".

@ Les modificateurs suivants traitent la valeur comme une séquence de mots délimités
par un espace blanc. Analogue à l'effet de "$@" dans Bourne shell.

# Renvoie le nombre de mots dans la valeur.

COMPRENDRE DÉCLARATIONS, CONDITIONNELS ET POUR LES CANADIENS BOUCLES

Inclusion de makefile, structures conditionnelles et boucles for rappelant la programmation C
langue sont fournis dans bfaire. Toutes ces structures sont identifiées par une ligne commençant par
un seul point ('.'). Les fichiers sont inclus avec soit .comprendre ⟨filet⟩ ou .comprendre
"filet". Les variables entre les chevrons ou les guillemets doubles sont développées pour former le fichier
Nom. Si des crochets angulaires sont utilisés, le makefile inclus devrait être dans le système
répertoire makefile. Si des guillemets doubles sont utilisés, le répertoire du makefile et tout
répertoires spécifiés à l'aide de -I sont recherchées avant le répertoire makefile du système.
Pour la compatibilité avec d'autres versions de bfaire 'include file ...' est également accepté.

Si l'instruction include est écrite comme .-comprendre ou comme .sinclude puis erreurs de localisation et/ou
les fichiers d'ouverture d'inclusion sont ignorés.

Si l'instruction include est écrite comme .include non seulement les erreurs de localisation et/ou d'ouverture
inclure les fichiers ignorés, mais les dépendances obsolètes dans le fichier inclus seront simplement ignorées
comme .MAKE.DEPENDFILE.

Les expressions conditionnelles sont également précédées d'un seul point comme premier caractère d'une ligne.
Les conditionnels possibles sont les suivants :

.Erreur message
Le message est imprimé avec le nom du makefile et le numéro de ligne, puis
bfaire va sortir.

.exportation variable ...
Exporte la variable globale spécifiée. Si aucune liste de variables n'est fournie, toutes les variables globales
sont exportés à l'exception des variables internes (celles qui commencent par '.'). Ce n'est pas
affecté par le -X flag, doit donc être utilisé avec prudence. Pour la compatibilité avec
d’autres bfaire les programmes 'export variable=value' sont également acceptés.

Ajout d'un nom de variable à .FAIRE.EXPORTER équivaut à exporter une variable.

.export-env variable ...
Identique à '.export', sauf que la variable n'est pas ajoutée à .FAIRE.EXPORTER.
Cela permet d'exporter vers l'environnement une valeur différente de celle utilisée
by bfaire intérieurement.

.export-littéral variable ...
Identique à '.export-env', sauf que les variables de la valeur ne sont pas développées.

. Infos message
Le message est imprimé avec le nom du makefile et le numéro de ligne.

.undef variable
Annulez la définition de la variable globale spécifiée. Seules les variables globales peuvent être non définies.

.unexport variable ...
Le contraire de '.export'. Le global spécifié variable sera retiré de
.FAIRE.EXPORTER. Si aucune liste de variables n'est fournie, toutes les variables globales ne sont pas exportées, et
.FAIRE.EXPORTER supprimée.

.unexport-env
Désexportez tous les globals précédemment exportés et effacez l'environnement hérité de
le parent. Cette opération provoquera une fuite de mémoire de l'environnement d'origine, donc
doit être utilisé avec parcimonie. Tester pour .MAKE.NIVEAU étant 0, aurait du sens. Aussi
notez que toutes les variables qui proviennent de l'environnement parent doivent être
explicitement conservé si vous le souhaitez. Par exemple:

.si ${.MAKE.LEVEL} == 0
CHEMIN := ${CHEMIN}
.unexport-env
.export CHEMIN
. Endif

Conduirait à un environnement contenant uniquement 'PATH', qui est le minimum utile
environnement. En fait, '.MAKE.LEVEL' sera également poussé dans le nouvel environnement.

.Attention message
Le message précédé de 'Attention:' est imprimé avec le nom du makefile
et le numéro de ligne.

.si [!]expression [opérateur expression ...]
Tester la valeur d'une expression.

.ifdef [!]variable [opérateur variable ...]
Tester la valeur d'une variable.

.ifndef [!]variable [opérateur variable ...]
Tester la valeur d'une variable.

.ifmake [!]l'objectif [opérateur l'objectif ...]
Testez la cible en cours de construction.

.ifnmake [!] l'objectif [opérateur l'objectif ...]
Testez la cible en cours de construction.

.autre Inversez le sens du dernier conditionnel.

.elif [!] expression [opérateur expression ...]
Une combinaison de '.autre' suivie par '.si".

.elifdef [!]variable [opérateur variable ...]
Une combinaison de '.autre' suivie par '.ifdef".

.elifndef [!]variable [opérateur variable ...]
Une combinaison de '.autre' suivie par '.ifndef".

.elifmake [!]l'objectif [opérateur l'objectif ...]
Une combinaison de '.autre' suivie par '.ifmake".

.elifnmake [!]l'objectif [opérateur l'objectif ...]
Une combinaison de '.autre' suivie par '.ifnmake".

. Endif Fin du corps du conditionnel.

Le manuel de formation opérateur peut être l'un des suivants :

|| OU logique.

&& ET logique ; de priorité plus élevée que « || ».

Comme en C, bfaire n'évaluera un conditionnel que dans la mesure nécessaire pour déterminer son
valeur. Les parenthèses peuvent être utilisées pour modifier l'ordre d'évaluation. L'opérateur booléen '!»
peut être utilisé pour nier logiquement un conditionnel entier. Il est plus prioritaire que
»&&".

La valeur de expression peut être l'un des suivants :

défini Prend un nom de variable comme argument et évalue à vrai si la variable a été
Défini.

a prendre une Prend un nom de cible comme argument et évalue à vrai si la cible était
spécifié dans le cadre de bfairela ligne de commande de ou a été déclaré la cible par défaut
(soit implicitement, soit explicitement, voir .PRINCIPALE) avant la ligne contenant le
conditionnel.

vide Prend une variable, avec des modificateurs possibles, et évalue à vrai si l'expansion
de la variable se traduirait par une chaîne vide.

existe Prend un nom de fichier comme argument et prend la valeur true si le fichier existe. Les
fichier est recherché sur le chemin de recherche du système (voir .CHEMIN).

l'objectif Prend un nom de cible comme argument et évalue à vrai si la cible a été
Défini.

commandes
Prend un nom de cible comme argument et évalue à vrai si la cible a été
défini et a des commandes qui lui sont associées.

Expression peut également être une comparaison arithmétique ou de chaîne. L'expansion variable est effectuée
des deux côtés de la comparaison, après quoi les valeurs intégrales sont comparées. Une valeur est
interprété comme hexadécimal s'il est précédé de 0x, sinon il est décimal ; nombres octaux
ne sont pas pris en charge. Les opérateurs relationnels C standard sont tous pris en charge. Si après
expansion variable, soit le côté gauche ou droit d'un '==' ou '!=' l'opérateur n'est pas un
valeur intégrale, puis une comparaison de chaînes est effectuée entre les variables étendues. Sinon
l'opérateur relationnel est donné, on suppose que la variable étendue est comparée
contre 0 ou une chaîne vide dans le cas d'une comparaison de chaînes.

Quand bfaire évalue l'une de ces expressions conditionnelles, et il rencontre un (blanc-
espace séparé) mot qu'il ne reconnaît pas, l'expression "make" ou "defined" est
qui lui est appliqué, selon la forme du conditionnel. Si la forme est '.ifdef»,
».ifndef', ou '.si' l'expression "définie" est appliquée. De même, si la forme est
».ifmake' ou '.ifnmake, le' L'expression "faire" est appliquée.

Si la condition est vraie, l'analyse du makefile continue comme avant. Si ça
est évalué à faux, les lignes suivantes sont ignorées. Dans les deux cas, cela continue jusqu'à ce qu'un
».autre' ou '. Endif' est trouvé.

Les boucles for sont généralement utilisées pour appliquer un ensemble de règles à une liste de fichiers. La syntaxe d'un
la boucle for est :

.pour variable [variable ...] in expression
faire-règles⟩
.endpour

Après le pour expression est évalué, il est divisé en mots. A chaque itération du
boucle, un mot est pris et affecté à chaque variable, dans l'ordre, et ces les variables sommes-nous
substitué dans le faire des règles à l'intérieur du corps de la boucle for. Le nombre de mots doit
sortir même; c'est-à-dire, s'il y a trois variables d'itération, le nombre de mots fournis
doit être un multiple de trois.

COMMENTAIRES

Les commentaires commencent par un caractère dièse ("#"), n'importe où sauf dans une ligne de commande shell, et
continuer jusqu'à la fin d'une nouvelle ligne sans échappement.

SPÉCIALITÉS SOURCES (LES ATTRIBUTS)

.EXEC Target n'est jamais obsolète, mais exécute toujours les commandes de toute façon.

.IGNORER Ignorez les erreurs des commandes associées à cette cible, exactement comme si
ils étaient tous précédés d'un tiret ('-').

.FABRIQUÉ Marquez toutes les sources de cette cible comme étant à jour.

.FAIRE Exécutez les commandes associées à cette cible même si le -n or -t les options étaient
spécifié. Normalement utilisé pour marquer récursif bfaires.

.BUT Créez un méta-fichier pour la cible, même s'il est marqué comme .FAUX, .FAIRE, ou
.SPÉCIAL. Utilisation en conjonction avec .FAIRE est le cas le plus probable. Dans "méta"
mode, la cible est obsolète si le méta-fichier est manquant.

.NOMETA Ne créez pas de méta-fichier pour la cible. Les méta-fichiers ne sont pas non plus créés pour
.FAUX, .FAIRE, ou .SPÉCIAL cibles.

.NOMETA_CMP
Ignorez les différences dans les commandes lorsque vous décidez si la cible est obsolète. C'est
utile si la commande contient une valeur qui change toujours. Si le nombre de
les commandes changent, cependant, la cible sera toujours obsolète. Le même effet
s'applique à toute ligne de commande qui utilise la variable .OODATE, qui peut être utilisé pour
cet objectif même lorsqu'il n'est pas autrement nécessaire ou souhaité :

sauter-comparer-pour-certains :
@echo cela sera comparé
@echo ce ne sera pas ${.OODATE:M.NOMETA_CMP}
@echo cela sera également comparé

Le manuel de formation :M pattern supprime toute expansion de la variable indésirable.

.NOPATH Ne recherchez pas la cible dans les répertoires spécifiés par .CHEMIN.

.NOTMAIN Normalement bfaire sélectionne la première cible qu'il rencontre comme cible par défaut à
construit si aucune cible n'a été spécifiée. Cette source empêche cette cible d'être
choisi.

.OPTIONNEL
Si une cible est marquée avec cet attribut et bfaire je ne sais pas comment créer
cela, il ignorera ce fait et supposera que le fichier n'est pas nécessaire ou existe déjà.

.FAUX La cible ne correspond pas à un fichier réel ; il est toujours considéré comme
obsolète et ne sera pas créé avec le -t option. Suffixe-transformation
les règles ne s'appliquent pas à .FAUX cibles.

.PRÉCIEUX
Quand bfaire est interrompu, il supprime normalement toutes les cibles partiellement réalisées. Cette
source empêche la suppression de la cible.

.RECURSIF
synonyme de .FAIRE.

.SILENCIEUX N'écho à aucune des commandes associées à cette cible, exactement comme si elles
tous étaient précédés d'un arobase ("@").

.UTILISATION Transformez la cible en bfaireversion d'une macro. Lorsque la cible est utilisée comme
source pour une autre cible, l'autre cible acquiert les commandes, les sources et
attributs (sauf pour .UTILISATION) de la source. Si la cible a déjà des commandes,
le .UTILISATION les commandes de la cible leur sont ajoutées.

.UTILISER AVANT
Exactement comme .UTILISATION, mais ajoutez le .UTILISER AVANT cible des commandes à la cible.

.ATTENDRE If .ATTENDRE apparaît dans une ligne de dépendance, les sources qui la précèdent sont faites avant
les sources qui lui succèdent dans la lignée. Étant donné que les dépendants des fichiers ne sont pas
fait jusqu'à ce que le dossier lui-même puisse être fait, cela empêche également les personnes à charge d'être
construits à moins qu'ils ne soient nécessaires pour une autre branche de l'arborescence des dépendances. Donc donné :

x: a .ATTENDRE b
écho x
a:
faire écho à un
b : b1
écho b
b1 :
écho b1

la sortie est toujours 'a', 'b1', 'b', 'x'.
L'ordre imposé par .ATTENDRE n'est pertinent que pour les marques parallèles.

SPÉCIALITÉS CIBLES

Les cibles spéciales ne peuvent pas être incluses avec d'autres cibles, c'est-à-dire qu'elles doivent être la seule cible
spécifié.

.COMMENCER Toutes les lignes de commande attachées à cette cible sont exécutées avant que quoi que ce soit d'autre ne soit
terminé.

.DÉFAUT
C'est une sorte de .UTILISATION règle pour toute cible (qui n'a été utilisée que comme source) qui
bfaire ne peut pas trouver une autre façon de créer. Seul le script shell est utilisé.
Le manuel de formation .IMPSRC variable d'une cible qui hérite .DÉFAUTles commandes de est définie sur le
le propre nom de la cible.

. FIN Toutes les lignes de commande attachées à cette cible sont exécutées après que tout le reste est
terminé.

.ERREUR Toutes les lignes de commande attachées à cette cible sont exécutées lorsqu'une autre cible échoue.
Le manuel de formation .ERROR_TARGET La variable est définie sur la cible qui a échoué. Voir également
MAKE_PRINT_VAR_ON_ERROR.

.IGNORER Marquez chacune des sources avec le .IGNORER attribut. Si aucune source n'est spécifiée,
c'est l'équivalent de spécifier le -i option.

.INTERROMPRE
If bfaire est interrompu, les commandes pour cette cible seront exécutées.

.PRINCIPALE Si aucune cible n'est spécifiée lorsque bfaire est invoqué, cette cible sera construite.

.FAIRE DES FLAGS
Cette cible fournit un moyen de spécifier des indicateurs pour bfaire lorsque le makefile est utilisé.
Les drapeaux sont comme s'ils étaient tapés dans le shell, bien que le -f l'option n'aura aucun effet.

.NOPATH Appliquer le .NOPATH attribuer à toutes les sources spécifiées.

.PAS PARALLÈLE
Désactivez le mode parallèle.

.NO_PARALLEL
synonyme de .PAS PARALLÈLE, pour la compatibilité avec d'autres variantes de pmake.

.OBJDIR La source est une nouvelle valeur pour '.OBJDIR'. S'il existe, bfaire vont chdir(2) à lui
et mettre à jour la valeur de '.OBJDIR".

.ORDRE Les cibles nommées sont faites en séquence. Cet ordre n'ajoute pas de cibles au
liste des cibles à faire. Puisque les personnes à charge d'une cible ne se construisent pas
jusqu'à ce que la cible elle-même puisse être construite, à moins que « a » ne soit construit par une autre partie de la
graphe de dépendance, ce qui suit est une boucle de dépendance :

.ORDER: ba
b : un

L'ordre imposé par .ORDRE n'est pertinent que pour les marques parallèles.

.CHEMIN Les sources sont des répertoires dans lesquels il faut rechercher des fichiers non trouvés dans le
répertoire actuel. Si aucune source n'est spécifiée, toute source spécifiée précédemment
les répertoires sont supprimés. Si la source est le spécial .DOTLAST cible, alors le
le répertoire de travail actuel est recherché en dernier.

.CHEMIN.suffixe
J'aime .CHEMIN mais s'applique uniquement aux fichiers avec un suffixe particulier. Le suffixe doit
ont déjà été déclarés avec .SUFFIXES.

.FAUX Appliquer le .FAUX attribuer à toutes les sources spécifiées.

.PRÉCIEUX
Appliquer le .PRÉCIEUX attribuer à toutes les sources spécifiées. Si aucune source n'est
spécifié, le .PRÉCIEUX L'attribut est appliqué à chaque cible du fichier.

.COQUILLE Définit le shell qui bfaire utilisera pour exécuter des commandes. Les sources sont un ensemble de
champ=valeur paires.

prénom Il s'agit de la spécification minimale, utilisée pour sélectionner l'un des
spécifications de la coque ; sh, kshet csh.

chemin Spécifie le chemin d'accès au shell.

aErrCtl Indique si le shell prend en charge la sortie en cas d'erreur.

choisissez La commande pour activer la vérification des erreurs.

ignorer La commande pour désactiver la vérification des erreurs.

echo La commande pour activer l'écho des commandes exécutées.

calme La commande pour désactiver l'écho des commandes exécutées.

une fonction filtre La sortie à filtrer après avoir émis le calme commander. C'est typiquement
identique à calme.

errDrapeau L'indicateur à transmettre au shell pour activer la vérification des erreurs.

échoFlag L'indicateur à transmettre au shell pour activer l'écho de commande.

nouvelle ligne Le littéral de chaîne pour passer le shell qui se traduit par une seule nouvelle ligne
caractère lorsqu'il est utilisé en dehors de tout guillemet.
Exemple :

.SHELL : name=ksh path=/bin/ksh hasErrCtl=true \
check="set -e" ignore="set +e" \
echo="set -v" quiet="set +v" filter="set +v" \
echoFlag=v errFlag=e nouvelle ligne="'\n'"

.SILENCIEUX Appliquer le .SILENCIEUX attribuer à toutes les sources spécifiées. Si aucune source n'est spécifiée,
le .SILENCIEUX L'attribut est appliqué à chaque commande du fichier.

.VICIÉ Cette cible est exécutée lorsqu'un fichier de dépendance contient des entrées obsolètes, ayant .ALLSRC
défini sur le nom de ce fichier de dépendance.

.SUFFIXES
Chaque source spécifie un suffixe pour bfaire. Si aucune source n'est spécifiée, toute
les suffixes spécifiés précédemment sont supprimés. Il permet la création de suffixe-
règles de transformation.

Exemple :

.SUFFIXES : .o
.co:
cc -o ${.TARGET} -c ${.IMPSRC}

ENVIRONNEMENT

bfaire utilise les variables d'environnement suivantes, si elles existent : MACHINE, MACHINE_ARCH,
MACHINE_MULTIARCH, MAKE, MAKEFLAGS, MAKEOBJDIR, MAKEOBJDIRPREFIX, MAKESYSPATH, PWD et
TMPDIR.

MAKEOBJDIRPREFIX et MAKEOBJDIR ne peuvent être définis que dans l'environnement ou sur la ligne de commande pour
bfaire et non en tant que variables makefile ; voir la description de '.OBJDIR' pour plus de détails.

Utiliser pmake en ligne en utilisant les services onworks.net