Wildcards en Foreach in Makefile

Wildcards En Foreach In Makefile



Een bestand bestaat altijd uit een ander type inhoud: of het nu een eenvoudig tekstbestand, een programmacodebestand of een make-bestand is. Het inhoudstype van elk bestand maakt het uniek en onderscheidt het van andere bestandsformaten. Zo bestaat makefile uit regels die verschillende elementen gebruiken om zijn werk goed uit te voeren. Van die elementen zijn er de wildcard en foreach die nodig zijn om iets unieks en extra's uit te voeren. In deze handleiding bespreken we de kracht van jokertekens en foreach terwijl ze in een makefile worden gebruikt.

Jokertekens in Makefile

Over het algemeen is bekend dat de wildcard een factor is die niet kan worden voorspeld en die de situatie op alle mogelijke manieren kan veranderen. De jokertekens in het makefile worden gebruikt om als bonus alle mogelijke patronen uit een huidige werkmap te detecteren, of het nu een bestand of een willekeurige map is. Deze bronbestanden kunnen van elk type zijn.







Om een ​​jokerteken in een makefile te gebruiken, moet u het trefwoord “wildcard” gebruiken dat volgt op het sterretje “*” of “?” teken en de bestandsextensie die via een punt met elkaar verbonden is. U kunt ook de “?” teken om naar één teken te zoeken en “*” om met een willekeurig aantal tekens overeen te komen. Deze hele structuur moet tussen de haakjes en een “$”-teken worden gebruikt. We declareren bijvoorbeeld de variabele “SRCS” die zijn waardebestand via het jokerteken krijgt. Dit jokerteken zoekt naar alle bestanden met het “cpp”-patroon aan het einde.





Foreach in Makefile

De foreach-functie van makefile werkt precies zoals een foreach-lus in programmeertalen: herhaal de items in een lijst. De foreach-functie in makefile voert een specifieke actie uit op elk item van een lijst. Dit element kan een variabele of een ander bronbestand zijn. We werken bijvoorbeeld de syntaxis van de foreach-functie in makefile uit via de variabele SOURCES die een lijst van drie bronbestanden bevat. De foreach-functie gebruikt deze SOURCES-variabele om dezelfde naam te creëren voor drie objectbestanden door de lijst met bronbestanden te herhalen en deze op te slaan in een andere “OBJECTS”-variabele. De laatste twee regels laten zien hoe een makefile-regel kan worden gebruikt om na iteratie een objectbestand voor elk C-bestand te maken.





BRONNEN:= bestand1.c bestand2.c bestand3.c
OBJECTEN := $ ( foreach src,$ ( BRONNEN ) ,$ ( src:.c=.o ) )
$OBJECTEN : % .O: % .C
$ ( CC ) $ ( CFLAGS ) -C $ < -O $ @

Voorbeeld 1: Jokertekens gebruiken

Om de illustratie en werking van jokertekens en foreach-functies weer te geven, introduceren we een C++-bestand. Dit “salary.cpp”-bestand wordt gestart met het gebruik van de “iostream”-header om een ​​soepel gebruik van invoer- en uitvoerstromen mogelijk te maken. De hoofdmethode declareert een variabele “s” van het integer-type en de “cout”-instructie vraagt ​​om een ​​invoerwaarde tijdens runtime. De standaard invoerstroom “cin” krijgt de waarde van een gebruiker tijdens runtime en slaat deze op in de variabele “s”. De “cout” geeft de door een gebruiker ingevoerde waarde weer op het consolescherm.

#include
namespace std; gebruiken;
int. hoofd ( ) {
int s;
uit << 'Voer salaris in: ' ;
aan het eten >> S;
uit << ' \N Salaris: ' << S << eind;
opbrengst 0 ;
}



We starten het makefile met de “CXX” variabele die de compiler voor C++ definieert, en de CXXFLAGS variabele bevat de vlaggen voor de C++ compiler. De EXECUTABLE-variabele bevat de naam van een uitvoerbaar “hallo”-bestand dat wordt gegenereerd na de uitvoering van een makefile. De SRCS-variabele haalt alle C++-bestanden uit een huidige map op met behulp van het jokerteken “*” om elk patroon te doorzoeken dat eindigt op “.cpp”. De OBJS-variabele bevat de namen van objectbestanden die moeten worden gemaakt met behulp van de SRCS-variabele, waarbij de extensie “cpp” wordt vervangen door “o”. Het standaarddoel “all” bouwt het makefile en dit is afhankelijk van de EXECUTABLE-variabele.

De eerste regel creëert het doelbestand “hallo” dat afhankelijk is van het objectbestand van de OBJS-variabele (namen van objectbestanden) met behulp van de bestandsnamen die worden gegenereerd via de “OBJS”-variabele. De tweede makefile-regel genereert het objectbestand met de extensie “.o” die afhankelijk is van het C++-bestand na het compileren van het C++-codebestand. Hier is “%” een jokerteken om te zoeken naar de bestandsnamen van elk patroon dat eindigt op “cpp”. Uiteindelijk gebruikt het schone doel zijn opdracht “rm” om de nieuw gegenereerde uitvoerbare bestanden en objectbestanden met geweld uit een map op te schonen met behulp van de vlag “-f”.

CXX = g++
CXXFLAGS = -Muur -soa =c++ elf
UITVOERBAAR = hallo
SRCS = $ ( wildcard * .cpp )
OBJS = $ ( SRCS:.cpp=.o )
alles: $ ( UITVOERBAAR )
$ ( UITVOERBAAR ) : $ ( OBJS )
$ ( CXX ) $ ( CXXVLAGS ) -O $ @ $ ( OBJS )
% .O: % .cpp
$ ( CXX ) $ ( CXXVLAGS ) -C $ < -O $ @
schoon:
rm -F $ ( UITVOERBAAR ) $ ( OBJS )

Bij het uitvoeren van de “make” -instructie werden zowel de doel- als de objectbestanden gemaakt. Na het uitvoeren van het uitvoerbare “hallo”-bestand wordt de gebruiker gevraagd een salaris in te voeren en voegen we “67000” toe. Aan het einde wordt het salaris weergegeven.

maken

Voorbeeld 2: Foreach gebruiken

Nadat u jokertekens hebt gebruikt, is het tijd om gebruik te maken van de foreach-functie in makefile. De rest van de makefile-code is hetzelfde. Op regel 6 initialiseren we een andere variabele, namelijk 'NAMES', met een lijst met drie waarden: Kate, Kim, Tim. Het standaarddoel “all” is afhankelijk van de EXECUTABLE-variabele (doelbestandsnaam “hello”) en foreach-instructie. De functie “addprefix” herhaalt de variabele “NAMES” om dynamisch de doelnamen te genereren door “run_” voor te zetten aan het begin van elke naam in de lijst “NAMES”.

De regel op de achtste regel geeft aan dat een uitvoerbaar doelbestand, d.w.z. hallo, afhankelijk is van de “OBJS”. De vlag “-o” genereert het doeluitvoerbestand met behulp van de OBJS. De regel op de tiende regel genereert het doelobjectbestand met behulp van de bronbestanden met de extensie “cpp”. Om dit te doen, wordt de vlag “-c” gebruikt om een ​​bronbestand te compileren en het gerelateerde objectbestand te genereren dat nodig is voor de doelgeneratie. Op de dertiende regel gebruiken we de EXECUTABLE-variabele om de uitvoer te genereren met verschillende namen, beginnend met “run_” als voorvoegsel. Uiteindelijk zullen de Clean Target- en Fake-doelen het object en de doelbestanden verwijderen en opschonen.

CXX = g++
CXXFLAGS = -Muur -soa =c++ elf
# uitvoerbaar doelbestand
UITVOERBAAR = hallo
SRCS = $ ( wildcard * .cpp )
OBJS = $ ( SRCS:.cpp=.o )
# Lijst met namen
NAMEN = Kate Kim Tim
# Doelstellingen
alles: $ ( UITVOERBAAR ) $ ( addprefix run_, $ ( NAMEN ) )
$ ( UITVOERBAAR ) : $ ( OBJS )
$ ( CXX ) $ ( CXXVLAGS ) -O $ @ $ ( OBJS )
% .O: % .cpp
$ ( CXX ) $ ( CXXVLAGS ) -C $ < -O $ @
# Maak doelen voor elke naam
loop_ % : $ ( UITVOERBAAR )
. / $ ( UITVOERBAAR ) $*
schoon:
rm -F $ ( UITVOERBAAR ) $ ( OBJS )
# Valse doelwitten
.PHONY: allemaal schoon

Het gebruik van de “make”-instructie genereert het uitvoerbare “hello”-doel en voert het programma uit voor elke naam die is opgegeven in de “NAMES”-variabele.

maken

U kunt uw uitvoer ook wijzigen met behulp van de naam uit een lijst met het voorvoegsel “run_”.

Maak run_Kim

Conclusie

In deze handleiding wordt het gebruik van jokertekens en foreach-concepten in het makefile besproken, terwijl hun syntaxis afzonderlijk wordt besproken. Daarna bespraken we de codevoorbeelden om dieper in te gaan op elk van hun werken met uitvoer bij het verkrijgen van de bestanden met dezelfde extensies en het herhalen van de waarden in een variabelenlijst.