GNU Make-zelfstudie

GNU Make is een tool die helpt om uitvoerbare programma's uit de broncode te genereren en ook andere niet-bronbestanden van het project te verwerken. Make krijgt de logica van het bouwen van de uitvoerbare bestanden en het verwerken van andere niet-bronbestanden uit een bestand met de naam a makefile of een Makefile.

Waarom maken??

• Make is de de-facto tool voor het bouwen van uitvoerbare programma's van broncode in de wereld van open source.

• Met Make kunnen eindgebruikers uitvoerbare programma's bouwen zonder technische details te kennen over hoe ze moeten worden gebouwd.

• Alle details over het bouwen van uitvoerbare bestanden en het verwerken van niet-bronbestanden worden vermeld in de makefile - zodat het proces herhaalbaar wordt door alle mensen of systemen die een project proberen te bouwen.

• Als een codebase erg groot is, is het tijdrovend en problematisch om helemaal opnieuw een uitvoerbaar bestand te bouwen wanneer de verandering in de broncode erg klein is. Make zorgt daarvoor. Het houdt bij welke bestanden zijn gewijzigd en lost de afhankelijkheid dienovereenkomstig op om het specifieke deel van het programma opnieuw op te bouwen.

• Make is programmeertaal agnostisch. Het maakt niet uit welke programmeertaal of welk dialect je gebruikt. Makefile is een tekstbestand met shell-opdrachten die structureel zijn georganiseerd met afhankelijkheid en andere logica voor het bouwen van het programma en het beheren van andere niet-bronbestanden. Omdat het een heleboel shell-commando's is, kan het overal worden uitgevoerd waar shell-commando's worden uitgevoerd. Windows voert standaard geen Linux-shell-opdrachten uit, maar u kunt het doen met een gespecialiseerde versie ervan voor Windows.

• Tijdens het bouwen van uitvoerbare programma's worden veel tussenbestanden gemaakt die er niet hoeven te zijn als het bouwen klaar is. Zorg ervoor dat deze bestanden automatisch worden verwijderd. Het helpt het milieu schoon te houden en bespaart veel kostbare tijd.

Merk installeren

Maken alleen is niet genoeg om programma's te bouwen. Om programma's vanaf de broncode te bouwen, moeten compilers en andere hulpmiddelen op uw systeem zijn geïnstalleerd. We hebben dus de volledige reeks ontwikkelingstools nodig voor ons doel.

Om bronnen op Linux te compileren, is er een pakket genaamd "build-essential" op op Debian gebaseerde systemen (e.g. Ubuntu, Linux Mint, enz.) en "Development Tools" op Red Hat en CentOS.

Om dit te installeren op op Debian gebaseerde systemen:

apt-get install build-essentieel

Om dit te installeren op CentOS en Red Hat run:

yum groupinstall "Ontwikkeltools"

Aan de slag met Makefile

Laten we beginnen door te schrijven a Hallo Wereld programma met de programmeertaal C.

De belangrijkste functie van ons C-programma bevindt zich binnenin hallomain.c. De inhoud van het bestand moet er als volgt uitzien:

#include  int main()  my_fun(); retourneer 0;  

Deze code bevat het headerbestand hellofun.h die de verklaring bevat van een functie genaamd hello_fun(). De inhoud van hellofun.h is:

ongeldig my_fun();

De definitie van my_fun() leeft in hellofun.c:

#include  #include  void my_fun()  printf("Hallo wereld!\n"); terug; 

Dit is een heel eenvoudig programma en we zouden het kunnen compileren met gcc met slechts één commandoregel. Maar echte programma's zijn niet zo eenvoudig en zo klein als dit. Dingen worden heel snel complex.  Hieronder ga ik het benodigde makefile-script schrijven voor het compileren van dit hello world-programma. Ik zal verschillende delen ervan in volgende paragrafen uitleggen.

hellomain: hellomain.c hellofun.c gcc -o hallo hallomain.c hallomain.c -I.

Bewaar deze code in een bestand met de naam makefile (zonder enige bestandsextensie). Zet het bestand in de map waar de C-bestanden staan. Richt uw opdrachtregel in deze map. Schrijf make op de opdrachtregel en druk op enter. Er wordt een uitvoerbaar bestand met de naam hallo gegenereerd in de huidige map. U kunt het resultaat verifiëren door het uitvoerbare bestand uit te voeren met de volgende opdracht:.

./Hallo

Uitgangen:

Hallo Wereld!

Regels, doelen en afhankelijkheden

Een makefile-script is een verzameling regels. De regels instrueren Make hoe een doel of uitvoer van bronbestanden of andere bestanden te bouwen. De regel specificeert ook afhankelijkheden van het doel. De afhankelijkheidsregels moeten eerst worden uitgevoerd, afhankelijk van of dat al is verwerkt door naar de tijdstempels te kijken. In ons voorbeeld makefile hierboven hebben we een regel met de naam hallomain en zijn afhankelijkheden. De doelnaam wordt gescheiden door een dubbele punt uit de afhankelijkheidslijst. De shell-commando's die worden uitgevoerd, staan ​​in de volgende regel:. De shell-opdrachten moeten beginnen met een tab-teken.

Als u geen parameter opgeeft met het make-commando, wordt het eerste doel uitgevoerd. In ons voorbeeld hebben we geen enkele parameter gespecificeerd en we hadden hallomain als het eerste en enige doelwit.

Variabelen

Variabelen zijn een geweldige manier om waarde één keer te schrijven en meerdere keren te gebruiken zonder de waarde keer op keer te herhalen. Het helpt ons onze code DROOG te houden (Do Not Repeat Yourself). Als u ooit een waarde in het hele script moet wijzigen, hoeft u dat alleen maar op één plaats te wijzigen om de verandering overal weer te geven als u variabele gebruikt.

In ons voorbeeld gebruikten we gcc als de compiler, maar het kan zijn dat we de compiler moeten wijzigen in iets anders. Dus we kunnen de compilernaam in een variabele houden. We kunnen de compilervlaggen ook in een andere variabele houden om die opnieuw te gebruiken. Voor het instellen van een waarde aan een variabele gebruiken we het gelijkteken (=) en om die variabele te lezen gebruiken we $(variable_name).

CC=gcc CFLAGS=-I. hellomain: hellomain.c hellofun.c $(CC) -o hallo hallo.c hallomain.c $(KLEUREN)

Het milieu schoonmaken

Het kan zijn dat we onze omgeving vaak moeten schoonmaken. Als we willen dat elk onderdeel van ons project helemaal opnieuw wordt opgebouwd, moeten we het schoonmaken. In ons eenvoudige voorbeeld is het enige bestand dat wordt gegenereerd de Hallo uitvoerbaar. Zonder dat handmatig te verwijderen, kunnen we dat verwijderen met make. Dus we kunnen daar een regel voor maken en het doel een naam geven als schoon.

CC=gcc CFLAGS=-I. hellomain: hellomain.c hellofun.c $(CC) -o hallo hallo.c hallomain.c $(CFLAGS) schoon: rm hallo

Het shell-commando in het schone doel is gewoon het eeuwenoude shell-commando rm. Voer nu vanaf de opdrachtregel uit:

schoon maken

Kijk naar de huidige map om te zien dat de Hallo uitvoerbaar bestand is verdwenen.

Ons voorbeeld uitbreiden om meer problemen op te lossen

In ons eenvoudige Hello World-compilatievoorbeeld hebben we een probleem dat we nog niet hebben opgelost. hallomain doel kijkt naar hellomian.c en hellofun.c tijdstempels van bestanden de volgende keer dat u het opnieuw probeert te compileren met maken of hallomain maken. Dus als je een van die twee bestanden wijzigt, worden ze opnieuw gecompileerd. Maar als je verandert? hellofun.h dan zal het niet opnieuw compileren. Dat is onverwacht!

Nogmaals, we hebben een gemiddeld niveau overgeslagen. We hebben de objectbestanden niet gegenereerd en het uitvoerbare bestand rechtstreeks gegenereerd. Maar achter de schermen worden de objectbestanden in een tijdelijke map gemaakt en verwijderd. We willen de objectbestanden genereren voordat we het uitvoerbare bestand bouwen. Deze keer noemen we het hoofddoel als alle

allemaal: hallomain.oh hellofun.o gcc hallomain.oh hellofun.o -o hallo hallomain.o: hallomain.c hellofun.h gcc -I. -c hallomain.c hellofun.o: hellofun.c hellofun.h gcc -I. -c hellofun.c schoon: rm -rf *.o rm hallo

Voer de make-opdracht opnieuw uit om te zien of uw programma succesvol is gebouwd of niet. Voer het uitvoerbare bestand hallo uit om het resultaat te verifiëren. Kijk naar de huidige map en je zult zien dat er objectbestanden worden gemaakt. We hebben nog een regel toegevoegd aan het schone doel om objectbestanden op te schonen. Dit makefile-script helpt bij het opnieuw compileren van het hello world-programma, zelfs als de hellofun.h bestand is gewijzigd.

Conclusie

Make is een van de meest essentiële tools voor linux-gebruikers en programmeurs. Als je een eindgebruiker bent, zal kennis van make je helpen veel kapotte dingen in je wereld van linux te repareren. Als je een programmeur bent, kun je gewoon niet weglopen door de code te schrijven en je gebruikers laten uitzoeken hoe ze die broncode kunnen compileren naar uitvoerbare bestanden. U moet een makefile-script maken voor de eindgebruikers, zodat ze geen raadspelletjes spelen om uw bron te compileren naar uitvoerbare bestanden.

Referenties

GNUMaak Project-startpagina
GNU Make-documentatie