Gjøre

I sammenheng med programvareutvikling er Make et verktøy for å administrere avhengigheter, typisk de som eksisterer mellom filene som utgjør kildekoden til et program, for å styre deres rekompilering eller "generering" automatisk. Selv om det er sant at dens grunnleggende funksjon består i å automatisk bestemme hvilke deler av et program som må kompileres på nytt og utføre de nødvendige kommandoene for å gjøre det, er det også sant at Make kan brukes i ethvert scenario der det er nødvendig, i noen måte å automatisk oppdatere ett sett med filer fra et annet, hver gang det endres. [ 1 ]

Make er mye brukt på Unix / Linux - lignende operativsystemer . Som standard leser den instruksjonene for å bygge programmet eller annen handling fra makefilen. Instruksjonene som er skrevet i denne filen kalles avhengigheter.

Make-verktøyet brukes til oppgavene med å lage en kjørbar fil eller et program , for installasjonen, rensing av midlertidige filer i opprettelsen av filen, alt dette ved å spesifisere noen innledende parametere (som må være i makefilen) når du kjører den.

I tillegg til at dette er hovedmålet, brukes det til å automatisere andre oppgaver som å lage dokumenter i docbook -formatet , systemvedlikehold, ganske enkelt bruke eller lage make-filer som gjør disse oppgavene.

Strukturen til en makefil

Makefiles er tekstfilene som brukes til å administrere kompileringen av programmer. De kan forstås som manusene til filmen som gir lyst til å gjøre, eller databasen som informerer om avhengighetene mellom de ulike delene av et prosjekt. Alle Make-filer er ordnet i form av regler, som spesifiserer hva som må gjøres for å få en spesifikk modul. Formatet for hver av disse reglene er som følger:

mål: avhengigheter kommandoer

I "objektiv" definerer vi modulen eller programmet som vi ønsker å lage, etter kolon og på samme linje kan vi definere hvilke andre moduler eller programmer som er nødvendige for å oppnå "målet". Til slutt, i de neste og påfølgende linjene indikerer vi de nødvendige kommandoene for å utføre dette. Det er veldig viktig at kommandoene er atskilt med en tabulator fra begynnelsen av linjen. Noen redaktører som mcedit endrer faner til 8 tomme felter, og dette gjør at Make-filene som er generert på denne måten, ikke fungerer. Et eksempel på en regel kan være følgende:

spill: vindu.eller motor.eller bd.eller gcc –O2 –c game.c –o game.o gcc –O2 game.o window.o engine.o bd.o –o game

For å lage "spill" er det nødvendig at "window.o", "motor.o" og "bd.o" er opprettet (vanligvis vil det være en regel for hver av disse objektfilene i den samme Makefilen). I de følgende delene vil vi analysere syntaksen til Makefiles litt grundigere.

Kommentarer i makefiles

Make-filer kan gjøres lettere å forstå ved å kommentere dem. Alt fra tegnet "#" til slutten av linjen vil bli ignorert av make. Linjene som begynner med tegnet "#" vil for alle formål bli tatt som tomme linjer. Det anbefales sterkt å bruke kommentarer for å gi større klarhet til våre Makefiles. Vi kan til og med alltid legge til en overskrift med dato, forfatter og versjonsnummer for filen, for å utføre mer effektiv versjonskontroll.

Variabler

Det er veldig vanlig at det er variabler i makefile-filene, for å lette deres portabilitet til forskjellige plattformer og miljøer. Måten å definere en variabel på er veldig enkel, bare angi navnet på variabelen (vanligvis med store bokstaver) og dens verdi, som følger:

CC = gcc –O2

Når vi vil ha tilgang til innholdet i den variabelen, vil vi gjøre det slik:

$(CC) game.c –o spill

Merk at variabel ekspansjon kan føre til uendelige rekursive ekspansjonsproblemer, så denne syntaksen brukes noen ganger:

CC := gcc CC := $(CC) –O2

Ved å bruke “:=” i stedet for “=” unngår vi rekursiv ekspansjon og dermed alle problemene det kan forårsake.

I tillegg til variablene som er definert i selve Makefilen, er det mulig å bruke miljøvariablene, tilgjengelig fra kommandotolken. Dette kan gi opphav til formuleringer av denne stilen:

SRC = $(HJEM)/kilde spille: gcc $(SRC)/*.c –o spill

En spesiell type variabler er automatiske variabler, de som evalueres i hver regel. Disse variablene minner om variabler som brukes i BASH- skript . De viktigste er:

$@: Erstattet av navnet på målet for denne regelen. $*: Er erstattet av roten til et filnavn. $<: Erstattet av den første avhengigheten til denne regelen. $^: Erstattet med en mellomromseparert liste over hver av avhengighetene i denne regelen. $?:Erstattet med en mellomromseparert liste over hver av avhengighetene til denne regelen som er nyere enn målet for regelen. $(@D): Erstattet med underkatalogdelen av filbanen for et mål funnet i en underkatalog. $(@F): Erstattet av filnavndelen av filbanen for et mål i en underkatalog.

Virtuelle regler

Det er relativt vanlig at makefile-filene i tillegg til de vanlige reglene kan inneholde virtuelle regler, som ikke genererer en spesifikk fil, men tjener til å utføre en bestemt handling innenfor vårt programvareprosjekt. Normalt har disse reglene vanligvis et mål, men ingen avhengigheter. Det mest typiske eksemplet på denne typen regel er "clean"-regelen, som inkluderer nesten alle make-filer, som brukes til å "rense" kjørbare filer og objektfiler fra de nødvendige katalogene, med det formål å gjøre om alt neste gang som "make" er kalt:

ren: rm –f spill *.o

Dette vil føre til at når noen utfører "make clean", blir den tilhørende kommandoen utført og sletter "spill"-filen og alle objektfilene. Imidlertid, som vi allerede har sagt, har disse typer regler vanligvis ikke avhengigheter, så hvis det var en fil kalt "clean" inne i Makefile-katalogen, ville make vurdere at dette målet allerede er oppnådd, og det ville ikke utføre kommandoer tilknyttede:

$ touch clean $ gjøre rent make: `clean' er oppdatert.

For å unngå denne merkelige effekten, kan vi bruke et spesielt mål for fabrikat, .PHONY. Alle avhengighetene som vi inkluderer i dette målet vil ignorere tilstedeværelsen av en fil som samsvarer med navnet, og de tilsvarende kommandoene vil bli utført. Så hvis vår forrige makefile hadde lagt til følgende linje:

.PHONY : ren

ville ha unngått problemet ovenfor på en ren og enkel måte.

Implisitte regler

Ikke alle mål for en makefil trenger å ha en liste over tilknyttede kommandoer for å kunne utføres. Noen ganger defineres det regler som kun angir de nødvendige avhengighetene, og det er laget selv som bestemmer hvordan hvert av målene skal nås. La oss se det med et eksempel:

spill : game.o game.o : game.c

Med en Makefile som denne vil make se at for å generere "game" er det nødvendig å generere "game.o" på forhånd og for å generere "game.o" er det ingen kommandoer som kan gjøre det, derfor antar du at for å generere et filobjekt kompilerer bare kilden, og for å generere den endelige kjørbare, kobler du bare objektfilen. Dermed utfører den implisitt følgende regler:

cc –c game.c –o game.o cc game.o –o spill

Generering av den kjørbare, gjennom kall til standard kompilatoren.

Hovedregler

De implisitte reglene som vi nettopp har sett har sin grunn til å skyldes en rekke "mønsterregler" som er implisitt spesifisert i Make-filene. Vi kan omdefinere disse reglene, og til og med finne opp nye mønsterregler. Her er et eksempel på hvordan du redefinerer den implisitte regelen diskutert ovenfor:

 %.o: %.c $(CC) $(CFLAGS) $< -o $@

Det vil si at for ethvert mål som er en ".o" og som har en ".c" som avhengighet, vil vi utføre et kall til C-kompilatoren ($(CC)) med modifikatorene som er definert på det tidspunktet ( $(CFLAGS )), kompilerer den første regelavhengigheten ($<, ".c"-filen) for å generere selve målet ($@, ".o"-filen).

Påkalle make-kommandoen

Når vi påkaller make-kommandoen fra kommandolinjen, er det første som søkes etter en fil som heter "GNUmakefile", hvis den ikke finnes, søkes en fil som heter "makefile", og hvis den til slutt ikke blir funnet, kalles filen "makefile" søkes etter "Makefile" fil. Hvis ingen av disse tre filene blir funnet i den gjeldende katalogen, vil det oppstå en feil og vil ikke fortsette:

$make make: *** Ingen mål spesifisert og ingen makefil funnet. Høy.

Det er også flere måter å kalle make-kommandoen for å spore eller feilsøke Makefilen. Alternativene "-d", "-n" og "-W" er uttrykkelig angitt for dette. Et annet viktig alternativ er "-jN", der vi vil indikere for å gjøre at den kan kjøre opptil "N" prosesser parallelt, veldig nyttig for kraftige maskiner.

Makefileksempel

Den enkleste måten å forstå hvordan make fungerer er med et eksempel på makefil:

CC : = gcc CFLAGS: = -O2 MODULER = vindu.eller ledelse.eller db.eller spill .PHONY: ren installasjon alle : $( MODULER )  %.o : %.c $( CC ) $( CFLAGS ) –c $<.c –o $@ window.o : window.c bd.o : bd.c management.o : management.c window.o bd.o $( CC ) $( CFLAGS ) –c $<.c –o $@ $( CC ) $* -o $@ spill: game.c window.o bd.o management.o $( CC ) $( CFLAGS ) –c $<.c –o $@ $( CC ) $* -o $@ ren: rm –f $( MODULER ) installere: cp spill /usr/games/game

Merke-relaterte verktøy

Referanser

  1. ↑ Gratis manual for Make in PDF , av Gerardo Aburruzaga (professor ved University of Cádiz )

Bibliografi

Eksterne lenker