Namn

make – underhåller, uppdaterar och återskapar grupper av program (UTVECKLING)

Prolog

Denna manualsida är en del av POSIX Programmer's Manual. Linux-implementationen av detta gränssnitt kan skilja sig från POSIX-beskrivningen. Se motsvarande Linux-manualsida för detaljer om Linux-beteende. Gränssnittet kan också saknas helt på vissa Linux-system.

Synopsis

make [-einpqrst] [-f makefile]... [-k|-S] [macro=value...]
     [target_name...]

Beskrivning

Verktyget make uppdaterar filer som härleds från andra filer. Ett typiskt fall är när objektfiler byggs från motsvarande källkodsfiler. make undersöker tidsstämplar och uppdaterar de härledda filer, kallade mål, vars ändringstid är äldre än ändringstiden för de filer de beror på, kallade förutsättningar eller beroenden.

En beskrivningsfil, normalt kallad en makefil, beskriver relationerna mellan filer samt de kommandon som måste köras för att uppdatera mål när deras beroenden har ändrats. Varje specifikation, eller regel, består av ett mål, valfria beroenden och valfria kommandon som ska köras när ett beroende är nyare än målet.

Det finns två typer av regler:

Härledningsregler – regler med ett enda målnamn som innehåller minst en punkt (`.`) och inget snedstreck (`/`).
Målregler – regler som kan ha mer än ett målnamn.

Utöver regler i makefilen ska make ha en uppsättning inbyggda makron och härledningsregler som kan dra slutsatser om beroenden för att förenkla underhåll av program.

För att få exakt det beteende som POSIX beskriver ska en portabel makefil:

innehålla det särskilda målet .POSIX
inte använda särskilda mål som är reserverade för implementationer, det vill säga mål som börjar med punkt följt av versaler, om de inte uttryckligen anges i POSIX-avsnittet

Om något av dessa villkor inte uppfylls är beteendet ospecificerat.

Flaggor

Verktyget make ska följa POSIX.1-2017, Base Definitions, avsnitt 12.2, Utility Syntax Guidelines, med undantag för riktlinje 9.

Följande flaggor stöds:

-e

Gör att miljövariabler, även sådana med tomma värden, åsidosätter makrotilldelningar i makefiler.

-f makefile

Anger en annan makefil. Argumentet makefile är sökvägen till en beskrivningsfil. Sökvägen `-` betyder standard in. Flaggan kan förekomma flera gånger och behandlas då i den ordning den anges. Effekten av att ange samma argument flera gånger är ospecificerad.

-i

Ignorera felkoder från körda kommandon. Detta motsvarar att det särskilda målet .IGNORE anges utan beroenden.

-k

Fortsätt uppdatera andra mål som inte beror på det mål där ett fel inträffade. Detta gäller när ett icke ignorerat fel uppstår under körning av kommandon.

-n

Skriv ut de kommandon som skulle ha körts, men kör dem inte. Kommandorader med prefixet `+` ska dock köras. I detta läge skrivs även rader med `@`-prefix ut.

-p

Skriv ut den fullständiga uppsättningen makrodefinitioner och målbeskrivningar till standard ut. Utdataformatet är ospecificerat.

-q

Returnera noll om målet är uppdaterat, annars 1. Inga mål ska uppdateras. Kommandorader med `+`-prefix ska dock köras.

-r

Töm suffixlistan och använd inte de inbyggda reglerna.

-S

Avsluta make om ett fel inträffar när kommandon körs för att uppdatera ett mål. Detta är standardbeteendet och motsatsen till -k.

-s

Skriv inte ut makefilens kommandorader eller meddelanden från -t innan de körs. Detta motsvarar att det särskilda målet .SILENT anges utan beroenden.

-t

Uppdatera ändringstiden för varje mål som om kommandot `touch mål` hade körts. Mål som har beroenden men inga kommandon, eller som redan är uppdaterade, ska inte ändras på detta sätt. Ett meddelande ska skrivas för varje fil som rörs. Normalt körs inte kommandoraderna för målet, men kommandorader med `+`-prefix ska köras.

Flaggor i miljövariabeln MAKEFLAGS ska behandlas före flaggor på kommandoraden. Om både -k och -S anges, antingen via kommandoraden eller MAKEFLAGS, gäller den senast angivna flaggan. Om -f eller -p förekommer i MAKEFLAGS är resultatet odefinierat.

Operander

target_name

Namn på mål enligt den utökade beskrivningen. Om inget mål anges används det första mål som make hittar under läsningen av makefilerna och som inte är ett särskilt mål eller en härledningsregel.

macro=value

Makrodefinition enligt avsnittet om makron.

Om mål och makrodefinitioner blandas på kommandoraden är resultatet ospecificerat.

Standard in

Standard in används endast om argumentet till -f är `-`. Se avsnittet om indatafiler.

Indatafiler

Indatafilen, även kallad makefilen, är en textfil som innehåller regler, makrodefinitioner, inkluderingsrader och kommentarer. Formatet beskrivs i den utökade beskrivningen.

Miljövariabler

Följande miljövariabler påverkar körningen av make:

LANG

Anger standardvärde för internationaliseringsvariabler som saknas eller är tomma.

LC_ALL

Om denna är satt till ett icke-tomt värde åsidosätter den alla andra internationaliseringsvariabler.

LC_CTYPE

Bestämmer hur byte-sekvenser i argument och indata tolkas som tecken.

LC_MESSAGES

Bestämmer språk och format för diagnostiska meddelanden till standard fel.

MAKEFLAGS

Innehåller standardflaggor för make. Implementationer ska acceptera både format med enbart flaggbokstäver utan bindestreck och ett kommandoradsliknande format med bindestreck och blanksteg. Makrodefinitioner av formen `macro=value` kan också ingå. Innehållet i variabeln genomgår inte samma ordexpansion som kommandoraden.

NLSPATH

Bestämmer var meddelandekataloger för LC_MESSAGES ska sökas.

PROJECTDIR

Anger katalog som används vid sökning efter SCCS-filer som inte finns i aktuell katalog. Sökningen sker i en katalog med namnet SCCS under den angivna katalogen.

Om PROJECTDIR börjar med `/` behandlas den som en absolut sökväg. Annars behandlas värdet som ett användarnamn vars hemkatalog undersöks efter underkatalogerna src eller source. Om dessa inte hittas används värdet som en relativ sökväg. Om PROJECTDIR saknas eller är tom sker sökning i SCCS under aktuell katalog.

Variabeln SHELL i miljön ska inte användas som makro och ska inte ändras genom att definiera makrot SHELL i en makefil eller på kommandoraden. Alla andra miljövariabler, även tomma, ska användas som makron.

Asynkrona händelser

Om signalerna inte redan ignoreras ska make fånga SIGHUP, SIGTERM, SIGINT och SIGQUIT och ta bort det aktuella målet, om inte målet är en katalog, är ett beroende till det särskilda målet .PRECIOUS, eller om någon av flaggorna -n, -p eller -q angavs.

Mål som tas bort på detta sätt ska rapporteras i diagnostiska meddelanden till standard fel. Efter denna städning ska make utföra standardåtgärden för övriga signaler.

Standard ut

make ska skriva de kommandon som ska köras till standard ut, utom när:

flaggan -s har angetts
kommandot har prefixet `@`
det särskilda målet .SILENT gäller för målet eller gäller globalt

Om make körs utan att något behöver göras ska ett meddelande skrivas till standard ut om att ingen åtgärd vidtogs. Om -t används och en fil rörs ska ett meddelande med filnamnet skrivas.

Standard fel

Standard fel används endast för diagnostiska meddelanden.

Utdatafiler

Filer kan skapas när flaggan -t används. Ytterligare filer kan också skapas av verktyg som körs från make.

Utökad beskrivning

make försöker utföra de åtgärder som krävs för att de angivna målen ska vara uppdaterade. Ett mål anses uppdaterat om det finns och är nyare än alla sina beroenden, eller om det redan har gjorts uppdaterat av den aktuella körningen av make. Ett mål kan också anses uppdaterat om det finns, har samma tidsstämpel som ett eller flera beroenden och är nyare än övriga beroenden.

Alla beroenden behandlas som mål i sig och uppdateras rekursivt i den ordning de förekommer i regeln. Filernas ändringstider används för att avgöra om ett mål är föråldrat.

För att uppdatera ett mål säkerställer make först att alla beroenden är uppdaterade. Därefter kontrolleras målet. Om målet inte är uppdaterat körs regelns kommandon. Om målet fortfarande inte finns efter en lyckad uppdatering ska det ändå behandlas som nyare än mål som beror på det.

Om ett mål finns men saknar både målregel och härledningsregel ska det betraktas som uppdaterat. Det är ett fel om make försöker uppdatera ett mål som inte finns och det saknas både målregel och härledningsregel.

Makefilens syntax

En makefil kan innehålla regler, makrodefinitioner, inkluderingsrader och kommentarer. Regler finns i två former: härledningsregler och målregler. make har en uppsättning inbyggda härledningsregler, men dessa används inte om flaggan -r anges.

Regler och makron kan definieras flera gånger. För en regel gäller den senast angivna definitionen. För makron gäller de regler som beskrivs i avsnittet om makron.

Kommentarer är tomma rader, blanka rader och rader där `#` inleder kommentaren. En kommentar fortsätter till nästa icke-escapade radslut.

Som standard ska följande filer prövas i ordning:

./makefile
./Makefile

Om ingen hittas får implementationen pröva andra filer. På XSI-system ska även följande prövas:

./s.makefile
SCCS/s.makefile
./s.Makefile
SCCS/s.Makefile

Flaggan -f gör att dessa standardfiler ignoreras och den angivna filen används i stället. Om argumentet är `-` används standard in.

Termen makefil avser alla regler som användaren tillhandahåller, oavsett om de kommer från standardnamnen eller från -f.

En omvänt snedstreck-escapad radbrytning utanför kommandorader och inkluderingsrader ersätts, tillsammans med inledande blanktecken på följande rad, med ett enda blanksteg. I kommandorader bevaras det omvända snedstrecket och radbrytningen, men ett inledande tab-tecken på nästa rad tas bort.

Inkluderingsrader

Om ordet include står i början av en rad och följs av ett eller flera blanktecken ska resten av raden tolkas som ett filnamn som ska inkluderas.

Behandlingen sker i huvudsak så här:

Avslutande radbrytning, blanktecken före en kommentar samt själva kommentaren tas bort.
Strängen expanderas med makron.
Blanktecken efter det första icke-blanka tecknet används för att dela upp strängen i fält.
Om resultatet inte blir exakt ett icke-tomt fält är beteendet ospecificerat.

Om sökvägen inte börjar med `/` behandlas den relativt processens aktuella katalog, inte relativt katalogen där makefilen finns. Filens innehåll läses och behandlas som om det stod i makefilen i stället för inkluderingsraden. Inkluderade filer kan själva innehålla inkluderingsrader. Implementationer ska stödja minst 16 nivåers nästling.

Körning av makefilen

Kommandorader i makefilen behandlas en i taget. En kommandorad kan ha följande prefix:

-

Fel från kommandot ignoreras. Detta gäller också om -i används eller om .IGNORE gäller.

@

Kommandot skrivs inte ut innan körning, om inte -n används. Detta gäller också om -s används eller om .SILENT gäller.

+

Kommandot körs även om -n, -q eller -t används.

En körningsrad skapas genom att prefixtecknen tas bort. Om raden inte tystas skrivs den till standard ut. Därefter körs den av ett skal som om den skickades till systemgränssnittet `system()`. Om fel inte ignoreras ska skalets `-e`-läge vara aktivt. Miljön för kommandot ska innehålla alla variabler i make-processens miljö.

Som standard avslutas make med felmeddelande om ett kommando returnerar en status skild från noll.

Målregler

Målregler har formatet:

target [target...]: [prerequisite...][;command]
<TAB>command
<TAB>command
...

En målrad består av en eller flera mål, följt av kolon, följt av noll eller flera beroenden. Text efter semikolon och efterföljande rader som börjar med tab är kommandorader.

Applikationer bör välja målnamn som endast består av punkt, understreck, siffror och bokstäver ur den portabla teckenuppsättningen. Implementationer kan tillåta fler tecken. Tolkningen av mål med `%` eller `"` är implementationsberoende.

Ett mål med beroenden men utan kommandon kan användas för att lägga till beroenden för målet. Endast en målregel för ett visst mål får innehålla kommandon.

Följande särskilda mål styr make:

.DEFAULT

Om detta mål används ska det ha kommandon men inga beroenden. Kommandona används när inga andra regler finns för att bygga ett mål.

.IGNORE

Beroenden till detta mål får sina kommandofel ignorerade. Om inga beroenden anges ignoreras fel för alla mål.

.POSIX

Ska anges utan beroenden och kommandon. Om det förekommer som första icke-kommenterade rad ska makefilen behandlas enligt POSIX. Annars är beteendet ospecificerat.

.PRECIOUS

Beroenden till detta mål ska inte tas bort vid de asynkrona händelser som beskrivs ovan. Om inga beroenden anges behandlas alla mål som värdefulla.

.SCCS_GET

Ska anges utan beroenden. Om det förekommer ersätter dess kommandon standardkommandona för hämtning av SCCS-filer.

.SILENT

Beroenden till detta mål får sina kommandon tystade. Om inga beroenden anges skrivs inga kommandon eller touch-meddelanden för några mål.

.SUFFIXES

Beroenden till detta mål läggs till suffixlistan och används tillsammans med härledningsregler. Om inga beroenden anges töms suffixlistan.

Målen .IGNORE, .POSIX, .PRECIOUS, .SILENT och .SUFFIXES ska anges utan kommandon.

Mål som börjar med punkt följt av `POSIX` och andra tecken är reserverade för framtida standardisering. Mål som börjar med punkt följt av en eller flera versaler är reserverade för implementationstillägg.

Makron

Makrodefinitioner har formen:

string1 = [string2]

Makrot med namnet string1 får värdet string2. Värdet består av tecknen efter likhetstecknet fram till kommentar eller oescapad radbrytning. Blanktecken omedelbart före och efter likhetstecknet ignoreras.

Makron expanderas med formerna:

$(namn)
${namn}

Parenteser eller klamrar är valfria om namnet är ett enda tecken. `$$` ersätts av ett enda `$`.

Makroexpansion sker enligt följande:

Makron i målrader expanderas när raden läses.
Makron i kommandorader expanderas när kommandot körs.
Makron före likhetstecknet i en makrodefinition expanderas när tilldelningen görs.
Makron efter likhetstecknet i en makrodefinition expanderas först när makrot används.

Ersättningsformen:

$(namn:från=till)
${namn:från=till}

kan användas för att ersätta förekomster av ett suffix i varje ord i makrovärdet.

Makrodefinitioner hämtas i denna logiska ordning innan makefilerna läses:

Makron från kommandoraden.
Makron från MAKEFLAGS.
Miljövariabler, utom MAKEFLAGS och SHELL.
Inbyggda makron från härledningsregler.

Makron från en högre prioriterad källa åsidosätter inte lägre numrerade källor enligt POSIX-reglerna. Makron i makefilen åsidosätter tidigare definitioner i makefilen och inbyggda makron. Om -e inte anges åsidosätter makefilens makron också miljön. Makron i makefilen åsidosätter inte makron från kommandoraden eller MAKEFLAGS.

Makrot SHELL behandlas särskilt. Det tillhandahålls av make och ska ange sökvägen till skalets kommandotolk. Miljövariabeln SHELL påverkar inte makrot. Om SHELL definieras i makefilen eller på kommandoraden ersätter det makrot, men påverkar inte miljövariabeln SHELL.

Härledningsregler

Härledningsregler har formatet:

target:
<TAB>command
<TAB>command
...

Måldelen ska ha formen `.s2` eller `.s1.s2`, där suffixen finns i .SUFFIXES och inte innehåller snedstreck eller punkt. En regel med ett suffix är en enkel suffixregel. En regel med två suffix är en dubbel suffixregel.

Härledningsregler får inte ha beroenden. De kan omdefinieras. En tom regel kan skapas med enbart semikolon:

regel: ;

make använder suffixen för mål och beroenden för att avgöra hur ett mål kan göras uppdaterat. Om ingen målregel finns undersöks härledningsreglerna. Suffixet för målet jämförs med suffixlistan i .SUFFIXES. Den första regel som matchar och där motsvarande beroendefil finns används.

Om ett mål saknar suffix och ingen målregel finns prövas enkla suffixregler. Regeln `.s2` beskriver hur mål kan byggas från `mål.s2`.

Tilde (`~`) i dessa regler avser en SCCS-fil i aktuell katalog. Exempelvis betyder `.c~.o` att ett SCCS-lagrat C-källfilsmål kan transformeras till en objektfil.

Bibliotek

Om ett mål eller beroende innehåller parenteser behandlas det som en medlem i ett arkivbibliotek. Formen:

lib(member.o)

betyder att lib är arkivbiblioteket och member.o är medlemmen. Medlemmen ska vara en objektfil med suffixet `.o`. Ändringstiden för uttrycket är ändringstiden för medlemmen i arkivet. Suffixet `.a` avser arkivbibliotek. Regeln `.s2.a` används för att uppdatera en medlem i biblioteket från en fil med suffixet `.s2`.

Interna makron

make tillhandahåller fem interna makron som kan användas i mål- och härledningsregler:

$@

Det fullständiga namnet på aktuellt mål, eller arkivfilens namn när målet är en biblioteksmedlem.

$%

Utvärderas endast när aktuellt mål är en biblioteksmedlem av formen `libname(member.o)`. Då är `$@` biblioteket och `$%` medlemmen.

$?

Listan över beroenden som är nyare än det aktuella målet.

$<

I en härledningsregel: filnamnet vars existens gjorde att regeln valdes. I `.DEFAULT`: aktuellt målnamn. I andra sammanhang är betydelsen ospecificerad.

$*

Aktuellt målnamn med suffixet borttaget. Ska åtminstone utvärderas för härledningsregler.

Varje internt makro har också former med D och F tillagda, till exempel `$(<D)` och `$(<F)`. D ger katalogdelen och F ger filnamnsdelen. För aktuell katalog är katalogdelen `.`.

För ett mål av formen `lib(member.o)` och regeln `.s2.a` gäller:

$<    member.s2
$*    member
$@    lib
$?    member.s2
$%    member.o

Standardregler

Standardreglerna för make ska ge samma resultat som följande principer. Implementationer som saknar vissa utvecklingsverktyg kan utelämna motsvarande makron och regler.

Särskilda mål:

.SCCS_GET: sccs $(SCCSFLAGS) get $(SCCSGETFLAGS) $@
.SUFFIXES: .o .c .y .l .a .sh .f .c~ .y~ .l~ .sh~ .f~

Standardmakron:

MAKE=make
AR=ar
ARFLAGS=-rv
YACC=yacc
YFLAGS=
LEX=lex
LFLAGS=
LDFLAGS=
CC=c99
CFLAGS=-O 1
FC=fort77
FFLAGS=-O 1
GET=get
GFLAGS=
SCCSFLAGS=
SCCSGETFLAGS=-s

Exempel på enkla suffixregler:

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

.f:
        $(FC) $(FFLAGS) $(LDFLAGS) -o $@ $<

.sh:
        cp $< $@
        chmod a+x $@

Exempel på dubbla suffixregler:

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

.f.o:
        $(FC) $(FFLAGS) -c $<

.y.o:
        $(YACC) $(YFLAGS) $<
        $(CC) $(CFLAGS) -c y.tab.c
        rm -f y.tab.c
        mv y.tab.o $@

.l.o:
        $(LEX) $(LFLAGS) $<
        $(CC) $(CFLAGS) -c lex.yy.c
        rm -f lex.yy.c
        mv lex.yy.o $@

.y.c:
        $(YACC) $(YFLAGS) $<
        mv y.tab.c $@

.l.c:
        $(LEX) $(LFLAGS) $<
        mv lex.yy.c $@

Standardregler för SCCS-varianter använder get för att hämta källfilen innan kompilering.

Slutstatus

När flaggan -q används ska make avsluta med:

0

Lyckad körning. Målet är uppdaterat.

1

Målet var inte uppdaterat.

>1

Ett fel inträffade.

När -q inte används ska make avsluta med:

0

Lyckad körning.

>0

Ett fel inträffade.

Följder av fel

Standardbeteende enligt POSIX. Följande avsnitt är informativa.

Användning i program

Om det finns en källfil, till exempel `./source.c`, och två SCCS-filer som motsvarar den, exempelvis `./s.source.c` och `./SCCS/s.source.c`, använder make på XSI-system SCCS-filen i aktuell katalog. Användare rekommenderas ändå att använda de underliggande SCCS-verktygen eller kommandot sccs konsekvent för alla källfiler i en katalog.

Portabla makefiler bör alltid ange det särskilda målet .POSIX för att undvika påverkan från lokala tillägg.

Flaggorna -k och -S finns båda för att relationen mellan kommandoraden, MAKEFLAGS och makefilen ska kunna styras exakt.

När -n används läggs den alltid till i MAKEFLAGS. Detta gör att rekursiv körning med `make -n mål` visar hela den åtgärdssekvens som skulle köras.

Historisk praxis gör att `#` inuti en variabel tolkas som början på en kommentar. Detta gör det svårt att lägga ett `#`-tecken i en variabel, exempelvis:

CFLAGS = "-D COMMENT_CHAR='#'"

Många historiska implementationer slutar kedja härledningsregler när ett mellanliggande mål saknas. Exempelvis kan `.y.c` och `.c.o` teoretiskt bygga `.o` från `.y`, men make kan i stället kräva en direkt `.y.o`-regel.

Det bästa sättet att skriva portabla makefiler är att själv ange alla regler som behövs i makefilen.

Makron inuti andra makron expanderas när det nya makrot används, inte när det definieras. Exempel:

MACRO = value1
NEW   = $(MACRO)
MACRO = value2

target:
        echo $(NEW)

Detta skriver `value2`, inte `value1`.

Vissa historiska program har blandat mål och makrodefinitioner på kommandoraden och förväntat sig att alla makron behandlas före mål. Portabla program ska inte göra så.

Följande tecken i filnamn kan orsaka problem:

= : ` ' @

I inkluderingsfilnamn bör även mönstertecken och citattecken undvikas.

För härledningsregler kan `$<` och `$?` verka lika, men de skiljer sig. Om en makefil innehåller:

foo.o: foo.h

och `foo.h` är nyare än `foo.o`, men `foo.c` är äldre än `foo.o`, används den inbyggda regeln från `foo.c`, med `$<` lika med `foo.c` och `$?` lika med `foo.h`. Om även `foo.c` är nyare än `foo.o`, blir `$?` lika med `foo.h foo.c`.

Ett mål utan beroenden och utan kommandon, där målfilen inte finns, behandlas som uppdaterat när regeln körs. Detta innebär att alla mål som beror på detta mål alltid får sina kommandon körda.

På filsystem med låg tidsupplösning kan sekvenser som:

make; cp original copy; make

ge problem, beroende på om implementationen betraktar identiska tidsstämplar som uppdaterade eller föråldrade.

Standarden anger inte prioritet mellan makrodefinitioner och inkluderingsdirektiv. Därför är beteendet för:

include =foo.mk

ospecificerat. Om syftet är att definiera en variabel med namnet `include` bör blanktecknet före likhetstecknet tas bort eller ett annat makro användas.

Exempel

Följande kommando bygger standardmålet i aktuell katalog:

make

Följande kommando använder en särskild makefil:

make -f projekt.mk

Följande kommando visar vad som skulle köras utan att köra kommandona:

make -n

Följande kommando bygger ett specifikt mål:

make install

Följande är ett enkelt exempel på en makefil:

.POSIX:

prog: main.o util.o
        c99 -o prog main.o util.o

main.o: main.c util.h
        c99 -c main.c

util.o: util.c util.h
        c99 -c util.c

Om `main.c` eller `util.h` är nyare än `main.o` byggs `main.o` om. Om `main.o` eller `util.o` är nyare än `prog` länkas programmet om.

Bakgrund och motivering

POSIX-beskrivningen av make är avsedd att ange ett portabelt kärnbeteende, trots att historiska implementationer av make har haft många lokala tillägg. Kravet på målet .POSIX gör det möjligt för en makefil att uttryckligen begära POSIX-beteende.

Flaggorna -k och -S finns för att både fortsätt-efter-fel och stoppa-vid-fel ska kunna styras tydligt, även vid rekursiva körningar.

Reglerna kring MAKEFLAGS gör att rekursiva make-körningar kan ärva relevanta flaggor från föräldraprocessen.

POSIX specificerar inte alla historiska specialfall. Därför bör portabla makefiler undvika implementationsegna mål, ovanliga tecken i filnamn och antaganden om hur långt kedjade härledningsregler följs.

Framtida riktning

Inga framtida ändringar anges.

Se även

ar(1p), c99(1p), get(1p), sh(1p), touch(1p)

POSIX.1-2017, Base Definitions, avsnitt 12.2, Utility Syntax Guidelines.

Upphovsrätt

Delar av denna text återges och reproduceras elektroniskt från IEEE Std 1003.1-2017, Standard for Information Technology -- Portable Operating System Interface (POSIX), The Open Group Base Specifications Issue 7, 2018 Edition, Copyright © 2018 Institute of Electrical and Electronics Engineers, Inc. och The Open Group.

Vid skillnader mellan denna version och den ursprungliga IEEE/The Open Group-standarden är originalstandarden den avgörande referensen. Originalstandarden finns tillgänglig online från The Open Group.

Eventuella typografiska fel eller formateringsfel i denna manualsida har sannolikt uppstått vid konverteringen till manualsidesformat.

Sidslut

Orginalhemsidan på Engelska https://man7.org/linux/man-pages/man1/make.1p.html Det här är en maskinöversättning av Linux man sidor till svenska. Om du hittar fel är vi tacksamma om du rapporterar dem via formuläret som finns på https://www.linux.se/kontaka-linux-se/

Tack till Datorhjälp hemma som har sponsrat Linux.se med webbhotell.

make(1p)

Innehåll