GNU lager opplæring

GNU Make er et viktig verktøy for å bygge og administrere prosjektene, spesielt der prosjektet inneholder forskjellige filer som er bygget med forskjellige verktøy. I så fall lokaliserer GNU makefilen for det prosjektet, da filen spesifiserer de nødvendige avhengighetene mellom forskjellige filer i det gitte prosjektet og kommandoene som kreves for å bygge prosjektet.

GNU Make er designet for å håndtere store prosjekter. Den bestemmer seksjonene i et program som må kompileres etter en gitt handling og tilbyr kommandoene for å kompilere seksjonene på nytt. Dagens innlegg gir en praktisk guide for å forstå alt om GNU-merke.

Forstå en makefil

GNU Make leser makefilen til et prosjekt for å avgjøre hva det skal gjøre for å bygge og administrere prosjektet. En makefil har tre viktige komponenter: mål, forutsetning og oppskrift.

EN mål representerer filen som “gjøre”Kommando kan generere. Målet kan avhenge av forutsetningene og kan også være en handling som skal utføres. Ideelt sett fremhever målet filen som skal bygges når vi utfører "gjøre”Kommando.

EN forutsetning representerer filen som skal brukes som inngang for å lage målet. Et mål kan avhenge av flere forutsetninger.

EN oppskrift er en handling eller kommando som utføres av “gjøre”For å kompilere målet når forutsetningen endres. Oppskriften kan inneholde forskjellige kommandoer på samme eller forskjellige linjer. EN Tab Space går foran hver nye oppskriftslinje, og redaktøren reiser en feil hvis du savner å legge til fanen Tab.

De oppskrift fungerer som en serie skallkommandoer som starter med et fane -tegn. Her er et eksempel på en enkel makefile som fremhever mål, forutsetninger og oppskrift:

Den medfølgende makefilen består av en regel i oppskriften. Merk at bruk av den første regelen i makefilen som standardregel. Så i en slik makefil, “gjøre”Bruker gcc -o velkommen flott.c Som regel for å bygge og administrere prosjektet. Regelen spesifiserer at for at du skal lage filen for å generere Velkommen fil, vi må kjøre kommandoen som bruker flott.c som innspill for å opprette Velkommen fil.

Igjen, ikke alle regler har en forutsetning. For eksempel, hvis du har en makefil for å slette mellomfilene som opprettes når du bygger en fil, vil en slik regel ikke ha noen forutsetning. Ta en titt på følgende eksempel:

I dette tilfellet sletter regelen alle filene som inneholder en *.o Utvidelse. Dermed er det ikke nødvendig med en forutsetning i et slikt tilfelle at det ikke er nødvendig.

Jobber med en makefil

Det første eksemplet er et enkelt C -prosjekt med to C -filer og en overskriftsfil. Vi lager en funksjon som skriver ut en velkomstmelding og inneholder en ekstern overskriftsfil i prosjektet vårt.

Her er hovedfunksjonen:

Våre overskriftsfiler ser ut som følgende:

La oss nå lage en makefil som kompilerer prosjektfilene for å opprette en kjørbar fil i den gjeldende katalogen. Ideelt sett utfører vi følgende kommando for å bygge prosjektet:

$ gcc -o Greatmake Mainfunc.C Func1.C -i.

I det følgende bildet kan vi merke hvordan kompileringene bygger prosjektet med hell. Hvis vi kjører den opprettede kjørbare filen, får vi ønsket utgang.

Hvordan kan vi representere det samme og bruke en makefil i stedet? Her er tingen: Selv om du direkte samler prosjektet på kommandolinjen fungerer bra, kommer problemet inn når du bytter datamaskiner eller mister kompilasjonskoden. I et slikt tilfelle må du kompilere prosjektet på nytt. Igjen, når du gjør endringer i en fil, må du manuelt kompilere prosjektet for å imøtekomme endringene.

Alt dette bryet kan utelukkes ved å lage en enkel makefil som vist på følgende:

Makefilen inneholder to mål: den ene med forutsetninger og en kommando og den andre med bare kommandoen.

Tidligere bemerket vi at “gjøre”Bruker den første kommandoen som standardkommando for å bygge prosjektet. Derfor kan vi skrive gjøre I prosjektkatalogen for å utføre kommandoen for å opprette prosjektet. Make -kommandoen genererer målet som er Greatmake Som den kjørbare filen. Ta en titt på følgende:

Nå kan vi komfortabelt kjøre den kjørbare filen for å se utdataene fra det opprettede prosjektet.

$ ./output-fil

Anta at vi bruker “gjøre”For å utføre en annen kommando i stedet for standard en. Spesifiser målet du vil utføre med make -kommandoen.

$ Gjør mål

La oss bruke den samme makefilen og bruke Hei mål:

Legg merke til hvordan vi klarer å bli “gjøre”For å kjøre kommandoen som ingen forutsetninger er spesifisert med målet.

Hvis vi gjør noen endringer i en av filene i prosjektet, kjører "gjøre”Kommando imøtekommer endringene uten å måtte kompilere prosjektet manuelt.

Likevel, hvis du kjører "gjøre”Kommando uten nye endringer,”gjøre”Varsler deg om at den kjørbare filen er oppdatert.

Anta at du er usikker på endringene du har gjort eller hva Make -kommandoen gjør når du blir utført. Du kan gjøre et tørt løp ved å legge til -N -flagget.

Det første eksemplet i følgende illustrasjon, Make -n, viser kommandoen som blir utført med standardkommandoen. I neste tilfelle viser Make -N endringene som blir lagt til Hello -målet.

Hvis du er komfortabel med endringene, kan du utføre make -kommandoen for det gitte målet for å imøtekomme endringene som i følgende eksempel:

Hvordan bruke makefilvariablene

Så langt forsto vi hvordan “gjøre”Fungerer med en makefil. Imidlertid er vår tilnærming så langt ikke den beste for å håndtere store prosjekter, spesielt der noen verdier må endres med tiden. En bedre tilnærming innebærer å bruke variabler slik at hvis du vil endre kompilatoren for programmet, kan du redigere variabelen i stedet for å endre makefilkoden manuelt for kompilatoren manuelt.

Dessuten hjelper variabler med å oppnå en ren makefilkode som alle kan lese og forstå.

La oss ha et eksempel på å bruke variablene for å lage filer.

I makefilen definerer vi en variabel som heter filer som inneholder to verdier for filene som vi oppretter når vi bygger prosjektet:

I dette eksemplet, la oss referere til vårt tidligere eksempel på å sammenstille C -programmet. Men i dette tilfellet, la oss legge til noen få variabler som vi kan endre gjennom hele programmet.

Først spesifiserer vi banen som kompilatoren skal bruke for å finne overskriftsfilene som gjeldende katalog (.). En bedre tilnærming er å spesifisere banen som en variabel. Du kan spesifisere variabelen som skal brukes av kompilatoren ved hjelp av CFLAGS Spesielle konstanter som brukes til å kommunisere med kompilatoren.

CFLAGS = -I.

Bruke $ (CFLAGS) variabel plassholder i stedet for banen.

Likevel kan vi stille typekompilatoren til å bruke som en variabel, slik at noen som bruker en annen kompilator kan endre variabelen for å spesifisere en kompilator som skal brukes til saken.

CC = GCC

Bruke $ (CC) variabel plassholder i stedet for kompilatoren. Her er den endelige makefilen med de ekstra variablene:

Når vi kjører make -kommandoen, får vi den samme produksjonen som vi gjorde tidligere, bare at makefilkoden vår nå er renere og vi eliminerte noen oppsigelser.

Når du oppretter makefilen, kan du opprette en makro Obj For å representere forutsetningene som er nødvendige for å lage et mål. På den måten kan du raskt redigere objektfilene fra makroen uten å tukle med den andre makefilen. For eksempel kan vi ha en makro OBJ for vårt mål som vist i følgende:

Merk at vi erstatter forutsetningene med objektvariabelen.

Håndtere avhengigheter

“inkludere”Filer avhenger av“.c”Filer i prosjektet. Når du jobber med et stort prosjekt og du redigerer "inkludere” fil, "Make" vil ikke kompilere ".c”Filer. Denne feilen betyr at prosjektet ditt ikke blir kompilert ordentlig med mindre vi gjør makefilen til de eksisterende avhengighetene mellom ".c”Og“.h”Filer.

I så fall må vi bruke den spesielle konstanten Deps å lage en makro for å håndtere disse avhengighetene. Vi kan representere DEPS som regel, som vist i følgende:

Den forrige regelen oppretter først en Deps Makro hvis verdi er overskriftsfilen i prosjektfilene. Deretter instruerer det “gjøre”Det før det genererer“.o”-Filen, den må først sammenstille“.c”Fil ved hjelp av den spesifiserte kompilatoren. Deretter indikerer -C -flagget kompilatoren for å generere en objektfil mens -o $@ instruerer “gjøre”For å sette den kompilerte produksjonen til venstre for tykktarmen.

Med denne regelen håndterer vi alle avhengigheter slik at når vi endrer en fil, "gjøre”Innobler det når du kompilerer prosjektet på nytt.

Legge til andre makefiler

Når du jobber med en makefil, er det mulig å inkludere de andre makefilene. På den måten kan den nåværende makefilen lese fra de inkluderte makefilene for å støtte samlingen.

For å inkludere andre makefiler, legg til inkludere nøkkelord som instruerer “gjøre”For å pause lesingen av den nåværende makefilen og lese den andre inkluderte Makefiles.

inkluderer filnavn

Du kan også inkludere andre filtyper med inkluderer nøkkelord, forutsatt at du legger til avstanden mellom filnavnene.

Delte lange linjer i makefiler

Selv om "gjøre”Har ingen grense for hvor lenge en uttalelse kan være, lange setninger blir raskt uleselig og er dårlig formateringsstil. Gnu “gjøre”Hjørner for splitting av lange setninger ved å legge til backslash -karakteren.

Obj = mainFunc.c \
Func1.c

I dette eksemplet, "gjøre”Leser den forrige linjen som Obj = mainFunc.C Func1.c og ignorere Backslash.

I det medfølgende bildet delte vi oppskriftslinjen med en tilbakeslag.

Anta at du vil representere ett ord uten å legge til et hvitrom. Bytt ut tilbakeslaget med et dollartegn, en tilbakeslag og en ny linje.

Her er et eksempel:

Når "gjøre”Leser makefilen, den ignorerer først tilbakeslaget for en ny linje. Deretter leser det dollarskiltet som et rom som representerer en variabel med ett tegn.

Derfor behandler den til slutt dine delte linjer som ett ord uten hvitrom. Når vi bruker “gjøre”For å lese makefilen, får vi ingen feil siden“gjøre”Behandler de delte linjene i variabelen som ett ord.

Rengjøring av en katalog

Når du har satt sammen et program som bruker "gjøre”, Det kan hende du må rengjøre unødvendige filer som genereres som utdata. Selv om det er mulig å lage et rent mål, er det ikke den anbefalte tilnærmingen, som vist i følgende:

Det forrige bildet instruerer "gjøre" å slette alle tekstfilene og “.o”Utvidelsesfiler som er opprettet i den gjeldende katalogen.

For å håndtere de uventede situasjonene, er det best å skape en mer presis regel og sikre at du ikke legger den til som standard (første) regel i makefilen.

Når du utfører den rene regelen, bruk "Gjør rent”Kommando.

Konklusjon

GNU “Make” er et nyttig verktøy for å bygge og administrere små og store prosjekter. Å vite hvordan du bruker det er en ekstra fordel, da det hjelper deg å lese makefilene dine og samle prosjektene dine pent. Vi lærte hvordan vi bruker GNU “gjøre”Dybde og hvordan man jobber med en makefil, inkludert forståelsen av hvordan make leser makefilen. Forhåpentligvis har denne guiden lagt et grunnlag for å forbedre GNU -ferdighetene dine med å håndtere prosjektene dine.