makefile Handledning
Komma igång med makefile

Anmärkningar

versioner

Grundläggande Makefile

Överväg att skriva en "hej värld!" program i c. Låt oss säga att vår källkod finns i en fil som heter source.c, nu för att köra vårt program måste vi kompilera den, vanligtvis på Linux (med gcc) skulle vi behöva skriva $> gcc source.c -o output där output är namnet på den körbara som ska genereras. För ett grundläggande program fungerar detta bra men när program blir mer komplexa kan vårt kompileringskommandot också bli mer komplex. Det är här en Makefile kommer in, makefiler tillåter oss att skriva ut en ganska komplex uppsättning regler för hur man ska kompilera ett program och sedan enkelt kompilera det genom att skriva märke på kommandoraden. Här är till exempel ett möjligt exempel Makefile för hej wold-exemplet ovan.

Grundläggande Makefile

Låter skapa en grundläggande Makefile och spara den i vårt system i samma katalog som vår källkod med namnet Makefile . Observera att den här filen måste namnges Makefile, men huvudstaden M är valfri. Som sagt är det relativt standard att använda en capitol M.

output: source.c
    gcc source.c -o output

Observera att det finns exakt en flik före gcc-kommandot på den andra raden (detta är viktigt i makefiler). När denna Makefile har skrivits varje gång användartyperna gör (i samma katalog som Makefile) kommer att kontrollera om source.c har ändrats (kontrollerar tidsstämpeln) om den har modifierats senare än output kommer den att köra kompilationsregeln på följande rad.

Variabler i Makefiles

Beroende på projektet kanske du vill introducera några variabler i din make-fil. Här är ett exempel Makefile med variabler närvarande.

CFLAGS = -g -Wall

output: source.c
    gcc $< $(CFLAGS) -o $@

Låt oss nu utforska vad som hände här. I den första raden förklarade vi en variabel med namnet CFLAGS som innehåller flera vanliga flaggor som du kanske vill överföra till kompilatorn. Observera att du kan lagra så många flaggor som du vill i denna variabel. Sedan har vi samma rad som tidigare berätta för att kontrollera source.c för att se om det har ändrats mer nyligen än output, i så fall kör det kompilationsregeln. Vår kompilationsregel är mestadels densamma som tidigare men den har förkortats genom att använda variabler, $< -variabeln är inbyggd i fabrikat (kallas en automatisk variabel se https://www.gnu.org/software/make/manual/ html_node / Automatic-Variables.html ) och den står alltid för källan så i detta fall source.c . $(CFLAGS) är vår variabel som vi definierade tidigare, men observera att vi var tvungna att lägga variabeln i parentes med en $ framför som denna $(someVariable) . Det här är syntaxen för att säga Make att utöka variabeln till vad du skrev tidigare. Slutligen har vi $ @ -symbolen, än en gång är detta en variabel inbyggd i märke, och den står helt enkelt för målet för kompileringssteget, så i detta fall står det för output .

Rena

Make clean är ett annat användbart koncept för att lära sig om att skapa filer. Låter modifiera Makefilen från ovan

CFLAGS = -g -Wall
TARGETS = output

output: source.c
    gcc $< $(CFLAGS) -o $@

clean:
    rm $(TARGETS)

Som ni ser har vi helt enkelt lagt till en regel till vår Makefile och en ytterligare variabel som innehåller alla våra mål. Detta är en något vanlig regel att ha i makefiler eftersom det gör att du snabbt kan ta bort alla binära filer som du producerade helt enkelt genom att skriva $> make clean . Genom att skriva make clean ber du make-programmet att köra rena regeln och sedan gör kommer att köra rm-kommandot för att ta bort alla dina mål.

Jag hoppas att den här korta översikten över att använda fabrikat hjälper dig att påskynda ditt arbetsflöde, Makefiles kan bli väldigt komplicerade, men med dessa idéer bör du kunna komma igång med att använda make och få en bättre förståelse för vad som händer i andra programmerare Makefiles . För mer information om att använda göra en utmärkt resurs är https://www.gnu.org/software/make/manual/ .

Definiera regler

Snabbstart

En regel beskriver när och hur vissa filer (regelens mål ) skapas. Det kan också tjäna till att uppdatera en målfil om någon av filerna som krävs för dess skapande (måls förutsättningar ) är nyare än målet.

Regler följer syntaxen nedan: (Observera att kommandon som följer en regel är indragna av en flik )

targets: prerequisites
        <commands>

där mål och förutsättningar är filnamn eller speciella reserverade namn och kommandon (om de finns) utförs av ett skal för att bygga / återuppbygga mål som är föråldrade.

För att utföra en regel kan man helt enkelt köra make kommandot i terminalen från samma katalog där Makefile finns. Att köra make utan att ange målet kommer att utföra den första regeln som definieras i Makefilen . I regel kallas den första regeln i Makefile ofta alla eller standard , och listar vanligtvis alla giltiga build-mål som förutsättningar.

make endast kör regeln om målet är föråldrat, vilket innebär att antingen det inte finns eller dess modifieringstid är äldre än någon av dess förutsättningar. Om listan med förutsättningar är tom kommer regeln endast att köras när den först åberopas för att bygga målen. Men när regeln inte skapar en fil och målet är en dummyvariabel, kommer regeln alltid att köras.

foo.o: foo.c
    cc -c $< -o $@

bar.o: bar.c
    cc -c $< -o $@

%.o: %.c
    cc -c $< -o $@

Implicita regler

Implicit regler berätta make hur man använder vanliga metoder för att bygga vissa typer av mål-filer, som används mycket ofta. make använder målfilnamnet för att bestämma vilken implicit regel som ska åberopas.

Exempel på mönsterregel som vi såg i föregående avsnitt behöver inte faktiskt deklareras i en Makefile eftersom make har en implicit regel för C-sammanställning. I följande regel kommer foo.o förutsättningarna foo.o och bar.o att byggas med den implicita regeln för C-sammanställning, innan foo byggs.

foo : foo.o bar.o
    cc -o foo foo.o bar.o $(CFLAGS) $(LDFLAGS)

En katalog över implicita regler och variablerna som används av dem kan hittas här .

generisk regel för att gzip en fil

om en katalog innehåller två filer:

$ ls
makefile
example.txt

och makefile innehåller följande text

%.gz: %
    gzip $<

då kan du få example.txt.gz genom att skriva in skalet

$ make -f makefile example.txt.gz

Makefile består av bara en regel som instruerar make hur man skapar en fil vars namn slutar med .gz om det finns en fil med samma namn men .gz suffix.

makefile Hello World

C: \ makefile:

helloWorld :
[TAB]echo hello world

kör resultat:

C:\>make
echo hello world
hello world

Obs: [TAB] ska ersättas av en faktisk flik, stackoverflow ersätter flikar med mellanslag, och mellanslag används inte på samma sätt som flikar i en makefil.