makepp - Online in de cloud

PROGRAMMA:

NAAM

makepp - Compatibele maar verbeterde vervanging voor make

KORTE INHOUD

makepp [ -e ] [ -C dir ] [ -F makefile] [ -F makefile_of_dir ]
[ -J n] [ -k ] [ -m methode ] [ --noremake-makefiles ]
[ --nuwaarschuw ] [ -q ] [ -R dir] [ --traditioneel-recursief-maken ]
[ -v ] [ --versie ] [ VAR=waarde ... ] [ doel ...]

mpp [-opties] [ VAR=waarde ... ] [ doel ...]

PRODUCTBESCHRIJVING

Makepp, een bouwprogramma met een aantal functies die betrouwbare builds en
eenvoudiger build-bestanden, is een drop-in vervanging voor GNU make. Het ondersteunt bijna alle
syntaxis die door GNU wordt ondersteund, en kan worden gebruikt met makefiles die zijn geproduceerd door hulpprogramma's zoals
als automerk. Het heet makepp (of maak++) omdat het met speciale ondersteuning is ontworpen
voor C++, dat sindsdien is uitgebreid naar andere talen zoals Swig of embedded SQL. Ook
zijn relatie met maken is analoog aan de relatie van C++ met C: het is bijna 100%
achterwaarts compatibel, maar voegt een aantal nieuwe functies en veel betere manieren om te schrijven toe
maakbestanden.

Makepp heeft een uitgebreide testsuite doorstaan ​​en wordt in verschillende grote projecten gebruikt. Als je hebt
eventuele problemen met de nieuwste CVS-versie, roep maar, en we zullen proberen het snel op te lossen. Makepp
werkt met elke versie van Perl sinds 5.8.

De volgende handleidingpagina's bevatten meer informatie over het gebruik van makepp:

Tutorial
Hoe een make-bestand te schrijven. Dit is vooral bedoeld voor iemand die weinig of geen geld heeft
ervaring met het gebruik van elke implementatie van make.

Compilatie-tutorial
Wat de Unix-compilatieopdrachten doen.

Releaseberichten
Wat veranderde er bij elke release.

onverenigbaarheden
Wat werkt er anders tussen GNU make en makepp.

Versnellen
Verschillende tips om makepp veel sneller te laten werken.

Perl-prestaties
Diverse tips voor het maken van Perl-programmering (in uw makefiles en elders).
sneller.

Kookboek
Snelle antwoorden op "Hoe kan ik...?" of "Wat is de beste manier om...?"

FAQ Snelle antwoorden op vragen waar mensen tegenaan zijn gelopen.

Bouw algoritme
Hoe het build-algoritme van makepp op fundamentele manieren verschilt van traditioneel make.

Cache bouwen
Een build-cache is een map waarin de resultaten van eerdere builds worden opgeslagen, voor het geval dat het geval is
opnieuw nodig in dezelfde map, of in een aparte build in een andere map.

Bouwcontrolemethoden
Hoe makepp beslist wanneer te bouwen.

Ingebouwde opdrachten
Krachtige, efficiënte opdrachten overal beschikbaar waar makepp 2.0 of nieuwer is.

Ingebouwde regels
Voor heel eenvoudige programma's heb je misschien helemaal geen makefile nodig! Dit zijn de ingebouwde
regels waar Makepp van op de hoogte is.

Compatibiliteit
Waar en en met welke versie van Perl makepp werkt.

Het uitbreiden
Hoe u functies aan makepp kunt toevoegen door uw eigen Perl-code te schrijven.

Functies
Functies voor tekstmanipulatie en diverse andere doeleinden.

Vindplaatsen
Repositories zijn een techniek die zowel het bouwen van varianten als het centraal houden ervan vereenvoudigt
reeks bronnen.

Reglement
Regels opgeven om bestanden te bouwen.

Zandbakken
Sandboxen gebruiken om de build te verdelen.

Het scannen
Hoe makepp scant op afhankelijkheden zoals include-bestanden.

handtekeningen
Hoe makepp beslist wanneer bestanden zijn gewijzigd.

verklaringen
Aanvullende richtlijnen om makepp te controleren.

Variabelen
Variabelen gebruiken om regels te vereenvoudigen.

makep, mpp
Commandoregelsyntaxis van het hoofdhulpprogramma.

makeppclean, mppc
Een efficiënt stand-alone opschoonscript om bestanden te verwijderen die zijn gegenereerd door makepp.

makeppgraph, mppg
Een zelfstandig hulpprogramma om afhankelijkheden en de redenen daarvoor grafisch te analyseren
herbouwen.

makeppinfo, mppi
Een zelfstandig hulpprogramma om de build-informatie die makepp over elk onthoudt, leesbaar te dumpen
bestand.

makepplog, mppl
Een zelfstandig hulpprogramma om afhankelijkheden en de redenen voor opnieuw opbouwen te analyseren.

makeppreplay, mppr
Een zelfstandig hulpprogramma om dingen te herhalen die Makepp heeft gedaan, maar dan veel sneller.

Index
Alle trefwoorden, functies en operators in makepp.

Voordelen
Automatisch scannen op onder meer bestanden
Makepp scant automatisch op onder meer bestanden. Hierdoor zijn er geen hulpmiddelen meer nodig, zoals
afhankelijk maken. De scanner van Makepp werkt zelfs als de meegeleverde bestanden nog niet bestaan
gebouwd moeten worden. (Dit geldt ongeacht waar op het include-pad ze vandaan komen,
in tegenstelling tot programma's die afhankelijk zijn van de "-MM -MG" optie van gcc.) Makepp heeft een flexibel systeem
om dit te doen, gebaseerd op het scannen van de build-opdracht; je kunt het aanpassen
andere talen of bouw opdrachten door een Perl-subroutine te schrijven.

Beter systeem voor hiërarchische builds
Makepp heeft een beter systeem voor het afhandelen van builds waarbij meerdere mappen betrokken zijn
meerdere makefiles. De traditionele techniek is dat make zichzelf aanroept
recursief in elke directory. Afhankelijk van hoe ingewikkeld de onderlinge afhankelijkheden zijn
zijn, zijn soms meerdere recursieve passages nodig. Dit maakt de makefiles erg
ingewikkeld als ze een correcte constructie garanderen. Het echte probleem is dat tenzij
Afhankelijkheden zijn triviaal (bijvoorbeeld slechts één bibliotheekbestand), het is bijna onmogelijk om dat te doen
druk nauwkeurig de afhankelijkheden van doelen uit in één makefile in termen van doelen uit
het andere make-bestand. Unix-make is niet slim genoeg om te beseffen dat dit een doel in één is
makefile is afhankelijk van een bestand dat een doel is in een makefile op een lager niveau; het kan niet duren
build-opdrachten uit het makefile op een lager niveau terwijl het probeert het doel in te bouwen
het makefile op het hoogste niveau. De gebruikelijke oplossing is dus om alles te bouwen wat kan zijn
gebouwd met de makefiles op een lager niveau, in de hoop dat dat voldoende is om alles te bouwen
dat is nodig voor het makefile op het hoogste niveau.

Makepp laadt alle benodigde makefiles in één keer, dus er is geen probleem mee
situaties waarin een bestand van de ene makefile afhankelijk is van een bestand dat door een andere makefile is geproduceerd
maakbestand. Makepp-cd's worden automatisch naar de map verplaatst die het make-bestand ervoor bevat
het uitvoeren van een opdracht vanuit een makefile, zodat elke makefile onafhankelijk kan worden geschreven
zonder kennis van de build-directory op het hoogste niveau. Maar als toegang tot de root van uw
build tree is belangrijk (bijvoorbeeld omdat daar uw include-map zich bevindt),
je kunt het makefile in die map een speciale naam geven. Dan geeft makepp je het pad
naar die map in een variabele.

Makepp kan ook uitzoeken waar alle makefiles voor het hele project zich bevinden
wordt verteld of elk makefile zich in dezelfde map bevindt als de bestanden waarin het hoort
produceren. Dit kan makefiles ook aanzienlijk vereenvoudigen.

Voor meer details over het bouwen met meerdere mappen, zie 'Tips voor meerdere
mappen" in makepp_cookbook.

Betrouwbare wildcards
Makefiles kunnen op betrouwbare wijze jokertekens gebruiken, omdat jokertekens overeenkomen met beide bestanden
bestaan, or bestanden die nog niet bestaan, maar makepp weet hoe te bouwen. Dus zelfs voor a
programma met tientallen modules, zou je hele makefile eenvoudig zoiets kunnen lezen als
deze:

CXX = g++
CXXFLAGS = -g

%.o: %.c
$(CXX) $(CXXFLAGS) -c $(invoer) -o $(uitvoer)

mijn_programma: *.o
$(CXX) $(invoer) -o $(uitvoer)

en dit zal werken, zelfs als er nog geen van de ".o"-bestanden is gebouwd.

Betrouwbare builds: onthoudt de build-opdracht
Makepp houdt de build-opdrachten bij, zodat als de compilatie-opties veranderen, files
worden automatisch opnieuw opgebouwd. Dit is belangrijk om correcte builds te garanderen. (Dit idee
is afkomstig uit het hulpprogramma "cons" van Bob Sidebothem, dat werd beschreven in Perl
Tijdschrift uit 1998 en verkrijgbaar bij CPAN.)

Om te illustreren waarom dit belangrijk is, beschouwen we de volgende structuurdefinitie:

klasse ABC {
int x;
#ifndef SPECIAL_OPTION
int y;
#stop als
int z;
};

Stel nu dat u besluit de optie "SPECIAL_OPTION" in te schakelen door toe te voegen
"-DSPECIAL_OPTION" naar de opdrachtregel. Een hercompilatie van alles is nodig, maar
een traditioneel Unix-merk zal dit niet detecteren en zal alleen bronbestanden opnieuw compileren
die daadwerkelijk veranderd zijn. Als gevolg hiervan zullen sommige van uw modules worden gecompileerd met
-DSPECIAL_OPTION, en anderen niet. Na een zeer frustrerende foutopsporingssessie kun je
zullen ontdekken dat alles wat gedaan hoeft te worden, is alles opnieuw op te bouwen. Dan zul je
curse make en hopelijk overstappen naar een verbeterde implementatie ervan, zoals makepp. Bij
tenminste, dat is wat ik deed.

Nog een voorbeeld: stel dat u aan een project werkt dat redelijk goed verloopt
gedebugd, dus het wordt meestal gecompileerd met "-O2". Nu kom je een bug tegen die je nodig hebt
te bekijken in de debugger. Code die met optimalisatie is samengesteld, is moeilijk te onderzoeken
in de debugger, dus je wilt je code opnieuw compileren zodat je ernaar kunt kijken. Als
uw makefile is ingesteld om de compileropties in de gebruikelijke variabelen op te slaan, dat kan
doe gewoon dit:

makepp CFLAGS=-g CXXFLAGS=-g

en makepp weet dat de opdrachtregel voor alle modules is gewijzigd. Wanneer dan
je hebt je bug gevonden, typ gewoon

makepp

en het zal opnieuw worden gecompileerd met optimalisatie. U hoeft niet "make clean" te typen wanneer
u wijzigt de bouwopties.

Sommige makefiles (bijvoorbeeld die voor de Linux-kernel) doen er ongelooflijk veel aan om ze te forceren
opnieuw compileren wanneer het compileercommando verandert. Met makepp is het geregeld
automatisch, u hoeft niets te doen.

Betrouwbare builds: exacte matching van handtekening
Standaard zorgt makepp er niet alleen voor dat alle doelen nieuwer zijn dan alle
afhankelijkheden; als je een afhankelijkheid vervangt door een ouder bestand, weet makepp dat dit het geval is
om het doel opnieuw op te bouwen, eenvoudigweg omdat het invoerbestand is gewijzigd. Dit is een andere
belangrijke functie om correcte builds te garanderen, die is overgenomen van het hulpprogramma "cons".

Slimme handtekeningberekeningen
Sommige wijzigingen aan bronbestanden vereisen feitelijk geen herbouw. Bijvoorbeeld als
je verandert gewoon een commentaarregel, of als je een code opnieuw inspringt, is er niets bijzonders
reden om een ​​compilatie te forceren. Voor C/C++-compilatie bepaalt makepp of a
bestand moet opnieuw worden gecompileerd door een cryptografische controlesom van de inhoud van het bestand te berekenen,
het negeren van opmerkingen en witruimte, in plaats van naar de bestandstijd te kijken.

Dit is met name handig als u bestanden hebt opgenomen die zijn gegenereerd door bestanden die
veranderen, en toch veranderen de gegenereerde include-bestanden zelf zelden. Stel je voor
een ingewikkelde yacc-grammatica in je programma hebt, met een build-regel als deze:

y.tab.c y.tab.h: parser.y
yacc -d parser.y

Normaal gesproken wordt elke keer dat u zelfs maar een kleine wijziging aanbrengt in "parser.y", elk bestand dat
hangt af van "y.tab.h" moet opnieuw worden opgebouwd omdat de bestandstijd van "y.tab.h" is gewijzigd.
De meeste wijzigingen aan "parser.y" zullen echter niet daadwerkelijk de inhoud van "y.tab.h" veranderen
(behalve eventueel een commentaar), dus al dat hercompileren is niet nodig.

Vindplaatsen
Makepp kan automatisch bestanden uit een andere directorystructuur (de
"repository") indien nodig in de huidige buildboom. (Dit idee is ook overgenomen uit
het "cons"-programma.) Dit heeft verschillende interessante toepassingen:

Variant bouwt
Stel dat u uw programma heeft samengesteld met optimalisatie aan en foutopsporing
uit. Nu duikt er een bug op en moet je alles opnieuw compileren met debuggen
ingeschakeld. Zodra u de bug echter heeft gevonden, schakelt u de foutopsporing uit en
optimalisatie weer aan, en bij de meeste make-programma's zou je ze allemaal opnieuw moeten compileren
nogmaals de bronnen, zelfs degenen die niet veranderden. De procedure zou eruitzien
soortgelijk:

% makepp CFLAGS=-O2 # Compileer alles.
# oeps, bug hier ontdekt
% makepp CFLAGS=-g # Compileert alles opnieuw.
gdb mijn_programma
# ...vind de bug
% makepp CFLAGS=-O2 # Compileert alles een derde keer opnieuw.

Met makepp kun je eenvoudigweg naar een lege map cd'en en je origineel specificeren
map als opslagplaats. Hierdoor worden nieuwe objectbestanden in het lege bestand gemaakt
directory, terwijl uw oude objectbestanden intact blijven. Nu kun je de bug vinden
in de map die met debug is gecompileerd, repareer het in uw originele bronnen en ga dan
terug naar uw oorspronkelijke map. Nu alleen de paar bestanden die je daadwerkelijk hebt gewijzigd
moeten opnieuw worden samengesteld.

De hele procedure zou er als volgt uitzien:

% makepp CFLAGS=-O2 # Compileer alles.
# oeps, bug hier ontdekt
% mkdir-foutopsporing
% cd-foutopsporing
% makepp -R .. CFLAGS=-g # Compileren met foutopsporing ingeschakeld, maar
# plaats objecten in de foutopsporingssubmap.
% gdb mijn_programma
# ...vind de bug
% cd .. # Terug naar de originele map.
% makepp CFLAGS=-O2 # Compileert alleen die bestanden opnieuw
# dat je veranderd bent.

Als er veel modules zijn, kan dit een enorme tijdsbesparing opleveren.

Ontwikkelteam met gemeenschappelijke bronnen
Stel dat u een team ontwikkelaars heeft dat aan een standaardset bronnen werkt. Elk
De ontwikkelaar brengt onafhankelijke wijzigingen aan, maar hoeft geen kopie te hebben van het
hele bronboom. Met behulp van de repository's van makepp kunt u elke ontwikkelaar de beschikking geven
kopieert alleen de bestanden die hij heeft gewijzigd. Makepp zal automatisch en
maak tijdelijk symbolische links voor de andere bestanden die niet zijn gewijzigd
naar de overeenkomstige bestanden in de repository. Het kan dit zelfs als object doen
bestanden die in de repository bestaan ​​en niet opnieuw hoeven te worden gecompileerd in de
individuele directory van de ontwikkelaar.

Garandeer correcte regels
Als uw regels iets doen waarover u makepp niet hebt verteld, wordt de repository
het mechanisme weet niet hoe het die dingen moet ophalen. Dus iets dat normaal bouwt
maar mislukt vanuit een repository, vertelt u dat u uw regels moet corrigeren.

Automatische gevolgtrekking van de benodigde ".o"-bestanden
Makepp kan vaak precies afleiden welke objecten daadwerkelijk noodzakelijk zijn, zonder dat dit het geval is
expliciet verteld. Als u deze functie gebruikt, wordt een van uw bronbestanden opgenomen
"xx.h", en er is een bestand met de naam "xx.o" dat makepp weet te maken, en vervolgens makepp
voegt "xx.o" toe aan de linkopdrachtregel. Ik gebruik nu in veel gevallen geen niet-gedeelde bibliotheken
plaatsen waar ik vroeger was, omdat makepp automatisch de modules kan uitkiezen die ik nodig heb.

Correcte afhandeling van aliassen voor directory's
Makepp zal niet in de war raken door zachte links naar een directory of door een ander familielid
bestandsnamen die naar hetzelfde bestand verwijzen. Alle mappaden naar een bestand worden herkend,
waaronder foo, ./foo, ../src/foo, /auto_mnt/somedisk/bob/src/foo en
/gebruikers/bob/src/foo.

Bestandsnamen met speciale tekens
Makepp kan bestandsnamen ondersteunen met dubbele punten, spaties of andere speciale tekens
problemen veroorzaken voor het traditionele merk. Omring de bestandsnaam gewoon met aanhalingstekens. (Zien
"Speciale tekens" in makepp_rules voor details.)

Uitbreidbare tekstuele substitutiefuncties
Makepp kan willekeurige Perl-subroutines gebruiken voor tekstvervanging in het makefile.
Als u Perl kent, wordt u helemaal niet beperkt door de ingebouwde set makepp's
tekstmanipulatiefuncties.

U kunt ook eenvoudig Perl-code in uw makefile schrijven. Je kunt Make manipuleren
variabelen met de volledige kracht van de gehele Perl-taal. Zie makepp_variables voor
details.

Registratie van bouwbeslissingen
Standaard maakt makepp een logbestand zichtbaar met makepplog, mppl dat een
beschrijving van elk bestand dat het probeerde te bouwen, welke regel werd gebruikt om het te bouwen, wat
het hing ervan af, en (als het bestand opnieuw werd opgebouwd) waarom. Dit kan uiterst nuttig zijn voor
debuggen van een makefile - als je je afvraagt ​​waarom makepp heeft besloten een bestand opnieuw op te bouwen, of waarom
Dat is niet het geval. U kunt gewoon in het logbestand kijken waar de beslissingen worden uitgelegd.

Verbeterde ondersteuning voor parallelle builds
Makepp ondersteunt parallelle compilaties, maar (in tegenstelling tot andere make-implementaties) is dit wel het geval
mengt geen uitvoer van afzonderlijke processen die tegelijkertijd worden uitgevoerd.

Synoniemen voor cryptische variabelen
Makepp ondersteunt gemakkelijker te onthouden synoniemen voor de cryptische make-variabelen $@, $^ en
$<. Zie makepp_variables voor details.

Gebruik makepp online met behulp van onworks.net-services