makepp_incompatibilitys - En ligne dans le Cloud

PROGRAMME:

Nom

makepp_incompatibilitys -- Incompatibilités entre makepp et GNU make

DESCRIPTION

Makepp a été conçu pour être aussi proche que possible de GNU make
(<http://www.gnu.org/software/make/manual/make.html>). Outils automatiques GNU
(<http://www.gnu.org/software/automake/manual/automake.html>), CMake
(<http://www.cmake.org/>), Premake (http://industriousone.com/premake> et voir remarque
ci-dessous) ou les systèmes de construction hérités fabriqués à la main devraient être constructibles avec makepp. C'est tellement
vous pouvez soit migrer des projets sans effort. Ou si vous ne voulez pas profiter de tout
les avantages de makepp (par exemple pour que d'autres puissent toujours construire votre projet avec GNU make) pendant que vous
profitez de l'avantage de la fiabilité pour votre développement.

Cependant, en raison de la différence de philosophie, certains make's GNU ou POSIX make
(<http://pubs.opengroup.org/onlinepubs/009695399/utilities/make.html>) les fonctionnalités ne peuvent pas être
prise en charge. Quelques-uns n'ont pas été mis en œuvre parce que nous n'avons pas eu le temps. La plupart
les différences par rapport à GNU make sont assez techniques et ne causent que rarement des problèmes. Hélas le
les contournements des défauts de la marque traditionnelle deviennent de plus en plus complexes,
et donnent du fil à retordre à makepp.

En un mot, s'il ne se construit pas immédiatement, essayez :

makepp --no-warn makepp_simple_concaténation=1 makepp_percent_subdirs=1 \
--build-check=target_newer --last-chance-rules --no-remake-makefiles

Si cela réussit, vous pouvez essayer d'éliminer ces arguments un par un. Mais si cela échoue,
essayez d'ajouter :

--fabrication-récursive-traditionnelle

Si cela échoue également, le système de construction a besoin de quelques ajustements pour coopérer avec makepp. Même
si certaines options décrites ici rendent quelque chose de constructible, il est toujours recommandé de s'adapter
légèrement les choses, de sorte qu'elles deviennent immédiatement compatibles avec les deux marques.

Forcer PLUS POSIX or GNU faire compatibilité

Voici quelques possibilités de ligne de commande pour faire fonctionner de nombreux systèmes de build hérités
sans modif. Ils font que makepp émule précisément le comportement de GNU make.

Compatibilité via le option: "--build-check=target_newer"
Par défaut, makepp tentera de reconstruire toutes les cibles si l'une des dépendances a
changé depuis la dernière construction, ou si la commande a changé (voir makepp_build_check pour
des détails). C'est normalement ce que vous voulez. Parfois, cependant, vous ne voulez pas que la cible
à reconstruire s'il a été modifié en dehors du contrôle de makepp (par exemple, en éditant
ou en exécutant un programme manuellement pour créer le fichier). Vous pouvez forcer makepp à utiliser le
algorithme make traditionnel, qui ne reconstruit que si l'une des cibles est plus récente que le
dépendances, en ajoutant cette option à la ligne de commande.

Compatibilité via le option: "--dont-build=config.status"
Il existe des packages qui essaient de s'auto-configurer, ou de faire d'autres choses, que gmake
ignore à moins qu'on ne le lui demande, comme :

config.status : configurer
./config.status --recheck

configurer : configure.in aclocal.m4
autoconf

La plupart des gens n'ont même pas installé "autoconf", donc tout faire consciencieusement en
les règles, comme makepp, échoueront. Cette option empêche que, si vous découvrez ce que
de ne pas construire.

Compatibilité via le option: "--les-règles-de-la-dernière-chance"
Les règles par défaut (règles de modèle sans dépendances de modèle) ne sont normalement pas prises en charge.
Makepp instancie toutes les règles basées sur les fichiers existants, afin qu'il soit au courant de chaque
fichier qui pourrait être généré. Hélas de cette façon il ne sait pas instancier un motif
règle sans dépendance de modèle. Le mécanisme :last_chance y remédie partiellement.
Lorsque cela est suffisant pour les makefiles hérités, cette option permet de l'activer globalement.

Compatibilité via le option: "--pas d'avertissement"
Celui-ci n'améliore pas le résultat. Makepp donnera des messages d'avertissement pour beaucoup de choses
que la marque Unix traditionnelle accepte sans broncher. C'est parce qu'il y a
de meilleures façons de les faire avec makepp. Si ces avertissements vous ennuient, vous pouvez les désactiver
avec cette option.

Compatibilité via le option: "--hybrid-recursive-make"
Les invocations récursives de make sont souvent considérées comme une pratique dangereuse (voir « Mieux
système de constructions hiérarchiques" dans makepp pour plus de détails), mais ils sont extrêmement courants dans
makefiles existants. Makepp prend en charge le make récursif pour la compatibilité descendante ; pour les nouveaux
makefiles, il est préférable d'utiliser l'instruction "load_makefile" ou l'implicite de makepp
mécanisme de chargement du makefile.

Afin de pouvoir utiliser des référentiels pour les versions de variantes et d'aider à rendre récursif
invocations de make safer, makepp ne s'invoque normalement pas de manière récursive
même si tu le dis. Au lieu de cela, un sous-processus communique avec le processus parent, et
la construction réelle est effectuée par le processus parent.

Cela fonctionne dans la plupart des cas, mais vous ne pouvez pas invoquer plusieurs makefiles à partir du même
répertoire, par exemple, ce qui suit ne fonctionnera pas :

cible : dépendances
$(MAKE) -f other_makefile cibles

Dans ce cas, makepp remarque qu'il charge un deuxième makefile et se plaint. Avec cette option
à la place, il reviendra à la manière traditionnelle de construire à partir de makefiles supplémentaires dans
un processus makepp distinct chacun.

Remarque : techniquement, le chargement de plusieurs makefiles ne poserait aucun problème, mais ils ont généralement le
mêmes noms de cibles bidons. Garder cela à part signifierait une refonte complète de makepp
internes. Cependant, cela fonctionnera, mais ce n'est pas équivalent :

cible : dépendances
cd subdir && $(MAKE) -f other_makefile cibles

Compatibilité via le option: "--traditionnel-récursif-faire"
Parfois, l'option précédente ne suffit pas, surtout si les invocations récursives utilisent
choix contradictoires. Makepp n'utilise qu'un seul ensemble d'options globales, donc un sous-make n'est pas
autorisé à les modifier, car cela concernerait également d'autres makefiles.

L'ajout de cette option à la ligne de commande a les effets secondaires indésirables suivants :

· Les commandes récursives ne s'exécutent pas en interne en parallèle, même si le parent le fait.
Contrairement à gmake, il n'y a pas de coordination globale du nombre de processus. Cette volonté
pas être implémenté car cette façon de travailler n'est pas un objectif de conception de makepp.

· Les processus make récursifs ne connaissent rien aux référentiels.

· Chaque processus make récursif produit son propre fichier journal, dans le répertoire où il est appelé
au lieu de produire un fichier journal pour l'ensemble de la construction.

· Étant donné que makepp construit généralement plus que le make traditionnel, et que de nombreux
les systèmes de construction fournissent des appels récursifs dans toutes les directions, cela peut conduire à des
récursivité. Makepp tirera le frein après 50 tours et vous dira comment augmenter
cela, au cas où vous auriez vraiment une imbrication aussi profonde.

Même avec l'option "--traditional-recursive-make", les variables d'environnement
"MAKEOVERRIDES" et "MFLAGS" ne sont pas configurés et ignorés, donc les makefiles qui dépendent de
ceux-ci ne fonctionneront pas.

A Préfaire généré Makefile n'est qu'un emballage amusant à une invocation de sous-marque dans le même
annuaire. Si vous avez une cible de projet XYZ il aura une ligne comme

@${MAKE} --no-print-directory -C . -f XYZ.make

Dans ce cas, vous pouvez éviter l'option "--traditional-recursive-make" en appelant directement
makepp avec ce "-f XYZ.make" option.

Compatibilité sans le option: "--emplois=n"
Les makefiles hérités ne répertorient parfois pas toutes les dépendances, en se basant sur l'ordre de
exécution pour les faire à temps. Dans cette situation, makepp peut réussir à appeler une règle avant
ses dépendances ont toutes été faites. Alors les résultats peuvent être meilleurs avec moins, voire pas
exécution parallèle.

Compatibilité via le variable: "makepp_simple_concaténation=1"
La substitution de style Rc est la manière par défaut que makepp effectue la substitution de variable dans le texte
car il casse très rarement les makefiles hérités et est souvent utile dans les nouveaux
makefiles. Cependant, il introduit des incompatibilités occasionnelles dans la substitution de
variables non entourées d'espaces. Par exemple,

INCLUDE_PREFIX := -I/some/include/dir -I
INCLUDE := $(INCLUDE_PREFIX)/autre/include/dir

définira "INCLUDES" sur "-I/some/include/dir/other/include/dir -I/other/include/dir" si rc-
la substitution de style est activée, alors que GNU make le définirait sur
"-I/certains/include/dir -I/other/include/dir". Par exemple, lors de la compilation de Redis 2.6.5, il essaie de
lancez "printfgcc". Une concaténation si amusante de deux commandes est une indication forte que
cette variable est nécessaire pour se replier pour faire de la sémantique.

Il existe également une incompatibilité dans la gestion des espaces dans une variable :

nul :=
T := -o $(null) # T contient -o suivi d'un espace.
OUTFILE = $(T)fichier de sortie

définira "OUTFILE" sur "-ooutfile" si la substitution de style rc est activée, alors que GNU make
le définirait sur "-o outfile".

Ces deux incompatibilités sont supprimées en définissant le "makepp_simple_concaténation"
variable. Notez, cependant, que même avec "makepp_simple_concaténation", makepp reste
traite les espaces blancs de manière incompatible dans certaines situations :

T := -o # Ne supprime pas ce commentaire.

GNU make définit "T" pour contenir "-o" suivi d'un espace, alors que makepp supprime le
espace de fuite de toute façon. Si vous voulez l'espace de fin, vous devez définir
"makepp_simple_concaténation" et définissez également "T" en utilisant la technique impliquant un mannequin
variable telle que "null", comme indiqué ci-dessus.

Solution option "--no-remake-makefiles"
L'open source typique nécessite d'appeler "configure" pour créer les makefiles. Mais alors ces
les makefiles peuvent contenir des règles pour recréer le makefile, en appelant une commande. Makepp va
avec plaisir, respectez-le et mettez-le à jour conformément à la règle. Mais parfois c'est nocif, alors
sautez-le.

Compatibilité via le variable: "makepp_percent_subdirs=1"
Par défaut, "%" dans une règle de modèle ne correspond pas aux répertoires. Cela signifie qu'une règle comme
ce:

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

ne sera pas appliqué aux fichiers comme "../shared/xyz.c". Si vous voulez qu'il corresponde aux fichiers dans
sous-répertoires aussi, puis définissez la variable "makepp_percent_subdirs=1" sur la ligne de commande
ou près du début d'un makefile.

Compatibilité via le sûr, heureux et sain variable: $MAKEPP_IGNORE_OPTS
Parfois, les invocations récursives héritées transmettent des options que makepp ne comprend pas.
Espérons que l'option n'est pas importante, mais elle empêche makepp de s'exécuter. Avec ça
variable d'environnement, vous pouvez demander à makepp d'ignorer silencieusement certaines options. La valeur
doit être une liste d'options séparées par des espaces, qui peut se décliner en 4 variantes :

--Long=x
Une option longue qui attend un argument. Ce fait doit être déclaré par les égaux
signe, bien que l'utilisation réelle puisse également être séparée par un espace, soit "--long=bla" ou
"--long bla".

--Long
Une option longue sans argument.

-sx Une option courte qui attend un argument. Ce fait doit être déclaré en ajoutant
quelque chose directement après l'option, bien que l'utilisation réelle puisse également être séparée par
espace, soit "-sbla" ou "-s bla".

-s Une option courte sans argument.

Par exemple, remplacez l'option -R de makepp par un sans argument et acceptez le débogage de gmake
option avec un argument :

export MAKEPP_IGNORE_OPTS='-R --debug=x'

Incompatibilités qui exigent Makefile change

· Les makefiles qui appellent explicitement make empêchent makepp de tout construire lui-même.
Hélas, le propre "ExtUtils::MakeMaker" de Perl valide la seconde des deux formes de
cette erreur jusqu'à la version 6.56 (Perl 5.12.1) :

sous-répertoire :
sous-répertoire cd ; Fabriquer

FAIRE = faire

· La définition de la variable "VPATH" sur une valeur appelle implicitement "vpath % value". "vpath"
les instructions sont émulées avec le mécanisme de référentiel. Alors, où gmake remplace
le chemin d'accès au fichier trouvé dans le vpath, makepp le liera à la place symboliquement à
là où c'est nécessaire. Ainsi makepp fournira une chaîne non modifiée, qui est généralement
Pas de problème.

Les cibles dans un vpath ne sont pas prises en charge. (Gmake les considère s'ils sont plus récents que
leurs dépendances, mais sinon, la cible sera recréée dans le répertoire courant
-- plutôt incohérent.) La désactivation de vpaths n'est pas prise en charge.

· Une règle de modèle présente plus tard dans un makefile remplace celle qui est présente plus tôt.
C'est à l'envers de GNU make.

· L'ensemble des règles implicites intégrées est quelque peu différent de ceux de GNU make,
bien que les noms de variables soient largement compatibles. Les règles intégrées doivent
compiler avec succès des programmes C/C++/Fortran, et en fait peut être capable de deviner le
bibliothèques appropriées dans certains cas aussi. Prise en charge de Modula-2 et RatFor et d'autres rares
langues n'est délibérément pas présent, car je n'arrêtais pas de rencontrer des problèmes avec GNU
make lorsque j'ai accidentellement réutilisé les extensions pour ces langues.

· Un préfixe d'action "+" est ignoré en silence.

· Les membres de l'archive ne sont pas pris en charge, ni les variables automatiques associées
$%, "$(%D)" et "$(%F)".

· Il n'y a pas de support SCCS.

· Les espaces blancs de début et de fin dans les affectations de variables sont ignorés (même si le
un espace est suivi d'un commentaire). Pour plus de détails sur la gestion des espaces
incompatibilités, voir "Espaces blancs dans les variables" dans makepp_variables.

· Makepp n'essaie pas de reconstruire les fichiers inclus avec l'instruction "include" à moins que
le makefile contient une règle pour les construire avant que l'instruction include ne soit vue.
(Cependant, il tentera de reconstruire le makefile lui-même.) Ceci est normalement utilisé pour
la gestion inclut les dépendances de fichiers et n'est pas aussi utile avec makepp car vous ne
besoin de le faire de toute façon.

· La variable "SHELL" est actuellement partiellement ignorée. Makepp utilise toujours / Bin / sh
à moins que /usr/xpg4/bin/sh or /sbin/xpg4/sh est trouvé ou à moins que vous n'exportiez le "SHELL"
variable dans votre makefile. Mais si vous le faites, l'analyseur de commande pourrait ne pas être complètement
comprendre ce que fait votre commande shell. Sous Windows Strawberry ou ActiveState Perl
vous devez à la place définir votre variable SHELL before appeler makepp.

· Les dépendances de quoi que ce soit sur le Makefile fonctionnent toujours, mais sont généralement inutiles.
Ceci est généralement utilisé pour forcer une reconstruction lorsque les options de compilation changent. Makepp sait
lorsque les commandes de construction ont changé sans rien de spécial dans le makefile ; il stocke
ceci fichier par fichier. Si vous modifiez le makefile, il sait exactement quel
les fichiers ont besoin d'être recompilés.

· Les fichiers intermédiaires ne sont pas supprimés. (Parce que makepp insiste pour que tous les fichiers
que les dates soient les mêmes que lors de la dernière génération, les fichiers intermédiaires doivent tous être
présent ou bien des reconstructions se produiront.) Il n'y a pas de statut spécial accordé à
fichiers intermédiaires.

· La seule cible spéciale prise en charge est ".PHONY" et partiellement ".SUFFIXES". Les
restants sont simplement engorgés.

Plus précisément, GNU make a les cibles spéciales suivantes :

.SUFFIXES
Makepp ignore ".SUFFIXES" sauf pour le cas particulier de ".SUFFIXES" sans
dépendances, comme ceci :

.SUFFIXES :

qui lui dit de ne charger aucune de ses règles par défaut.

.INTERMÉDIAIRE, .SECONDAIRE, .PRÉCIEUX
Aucun statut particulier n'est accordé aux fichiers intermédiaires et ces cibles ne sont donc pas
significatif.

.IGNORER
Cette cible est ignorée. Si vous voulez ignorer les erreurs, mettez le mot "ignore_error"
(ou un signe moins) devant la commande dont l'état de sortie doit être ignoré.

.SILENCIEUX
Cette cible est ignorée. Si vous voulez que les commandes ne fassent pas écho, mettez le mot "noecho"
(ou le caractère "@") devant la commande qui n'est pas censée être répercutée,
ou utilisez l'option "--silent" pour makepp.

.DELETE_ON_ERROR
.EXPORT_ALL_VARIABLES
.NOEXPORTATION
.POSIX
.DÉFAUT
Ces cibles ne sont pas prises en charge et sont simplement ignorées.

· Les fonctions GNU make "eval", "flavor" et "value" ne sont actuellement pas supportées. Tu
peut réaliser la même chose que eval d'une manière plus simple avec "$[...]"
extension de variable ou de fonction.

· Les règles du double deux-points ne sont pas entièrement prises en charge. (Ils ne peuvent pas être : dans le paradigme de makepp,
il ne peut pas y avoir plus d'une façon de mettre à jour une cible.) Actuellement, chaque
la règle des deux points pour une cible donnée ajoute simplement sa chaîne de commande et sa dépendance
list à la chaîne de commande et à la liste de dépendances pour cette cible. Par exemple, si vous
écrire cela:

un B
&chat b -oa

# Plus tard dans votre makefile :
un :: c
&cat c -o >>a

c'est exactement comme si tu avais écrit

a : bc
&chat b -oa
&cat c -o >>a

Ce n'est certainement pas à cela que sont destinées les règles du double deux-points, et ce ne sera pas toujours le cas.
fonctionne, mais cela fonctionne pour des cibles comme « propre » ou pour tout ce qui
ExtUtils::MakeMaker met dans ses makefiles. Ne comptez pas dessus pour autre chose
que les makefiles hérités.

· La fonction "$(wildcard )" correspond non seulement aux fichiers qui existent, mais aussi aux fichiers qui
n'existent pas encore, mais qui ont une règle que makepp a vu à l'époque le
La fonction "$(wildcard )" est évaluée.

· L'instruction "define" est prise en charge, mais la gestion du "@" qui la précède est effectuée
différemment. Actuellement dans makepp, "@" devant une variable qui a un multi-ligne
value supprimera uniquement l'écho de la première ligne. Par exemple,

définir des lignes d'écho
&echo line1 -o $@
&echo line2 -o>>$@
endéf

x:
@$(lignes d'écho)

ne supprimera pas l'impression de "&echo line2" comme il le fait dans GNU make; ce sera seulement
supprimer l'impression de "&echo line1".

· Makepp ne prend pas en charge les variables d'environnement suivantes (il ne les configure pas,
et il les ignore simplement):

REMPLACEMENTS
MFLAG

Incompatibilités in de commander of expression avec des données
· Dans makepp, les actions de règle sont étendues avant que toutes les dépendances ne soient garanties
a été construit. Vous pouvez contourner ce problème en modifiant des règles telles que :

foo : bar
genfoo < $ (barre à chat shell)

pour ça:

foo : bar
genfoo < `bar à chat`

ou ceci, qui fera le fichier lors de l'expansion :

foo : bar
genfoo < $(&cat $(make bar))

Ceci est préférable ici, car le fichier répertorié dans barre est aussi une dépendance de cette
règle, et makepp peut maintenant l'attraper lors de l'analyse lexicale de la redirection.

· Bien que je n'aie pas vu cela utilisé, GNU make permet ce qui suit :

deux points = :
a$(deux points) b
écho $^

Makepp développe "$(colon)" trop tard pour que cela fonctionne. Cependant, il offre la
syntaxe alternative "$[colon]", qui peut faire beaucoup plus que GNU make, car c'est
étendu très tôt.

"$(FAIRE)" Au cours de cette réunion, Matthew a obtenu de précieux conseils et Linda lui a demandé de la tenir au courant de ses progrès. comprendre espaces
Dans un makepp désinstallé ou si la plate-forme ne semble pas prendre en charge le démarrage d'un script Perl
par nombre magique ou avec "--traditional-recursive-make" cette variable inclura au moins
un espace. Ce n'est pas un problème lorsque vous l'utilisez comme commande. Mais en le passant comme un
paramètre sans guillemets à un script (comme le fait le système de construction Perl 5.14.0), il le déchirera
séparés en paramètres séparés, ce qui prête à confusion. Donc, en tant que paramètre, il est plus sûr de
citez-le comme '$(MAKE)'. qui ne rompt pas la compatibilité descendante.

Spécifique à la cible missions ne le font pas propager
Les variables spécifiques à la cible de Makepp sont légèrement différentes de celles de GNU make en ce sens qu'elles
ne s'appliquer qu'à la règle pour le fichier mentionné, et non à l'un de ses prédécesseurs ; voir
Affectations spécifiques à la cible.

Parenthèses or bretelles ne le font pas nid
Makepp termine les expressions à la première parenthèse ou accolade correspondante. Au lieu de cela

$(unefonction ... ( ) ...) # GNU make style

vous devez utiliser l'un ou l'autre de ces

${une fonction ... ( ) ...} # GNU rend compatible
$((une fonction ... ( ) ...)) # Extension Makepp

Cela sera probablement corrigé dans la version 2.1, peut-être en option.

Mineurs des notes bonus
Les dépendances de modèle ne correspondent pas aux cibles factices
%.un B; ...
$(phony xb) : ; ... # ne fournit pas de moyen de construire xa

Les commentaires n'ont pas de lignes de continuation
# C'est \
PAS un commentaire de 2 lignes

Command en ligne incompatibilités

Makepp prend en charge quelques-unes des options de ligne de commande les plus utiles de make. Ce qui suit, cependant,
ne sont pas pris en charge :

-d ou --debug
-F -
Les objets makefile internes de Makepp sont liés à des objets fichier, il ne peut donc pas gérer
stdin.

-i
-l ou --load-average ou --max-load
-m L'option "-m" de Makepp concerne la sélection de la méthode de signature, alors que GNU make
ignore -m.

-p ou --print-data-base
-q ou --question
-R ou --no-builtin-variables
L'option "-R" de Makepp fait en fait quelque chose de complètement différent.

-S --no-keep-going ou --stop
L'option "--stop" arrête (met en veille) makepp après avoir appris toutes les règles, donc vous
peut continuer l'édition.

-t ou --touch
-w ou --print-directory
Cela se produit automatiquement.

--warn-variables-undéfinies

Certains d'entre eux peuvent être facilement pris en charge si quelqu'un s'en soucie.

Variable incompatibilités

Makepp recherche dans $PATH une commande correspondante à renvoyer pour des variables telles que "$(CC)" ou
"$(CXX)", tandis que GNU make a des valeurs par défaut statiques. Makepp donne également la préférence à "gcc" et
"g++" alors que, étonnamment, GNU make renvoie "cc" pour le premier, mais la même chose pour le
dernier. Vous pouvez les remplacer dans le makefile, sur la ligne de commande ou en exportant un
variable du même nom avant d'appeler makepp.

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