metaconfig - Online in de cloud

PROGRAMMA:

NAAM

metaconfig - een configuratiescriptgenerator

KORTE INHOUD

metaconfig [-dhkmostvwGMV ] [-L dir ]

PRODUCTBESCHRIJVING

Metaconfig is een programma dat Configure-scripts genereert. Als je niet weet wat een
Configureer het script is, ga dan naar de TUTORIAL sectie van deze handleidingpagina. Als je wil
een volledige (formele) beschrijving van de wijze van gebruik metaconfig en zijn eenheden, kijk dan eens naar de
REFERENTIE sectie. Het volgende is een korte introductie en referentie voor deskundigen
gebruikers.

Metaconfig werkt vanaf set eenheden die alles definiëren waar metaconfig van weet
draagbaarheid. Elke eenheid staat op zichzelf en hoeft nergens geregistreerd te worden
anders dan door opname in de openbare U-directory of uw privé U-directory. Als
het dist-pakket (waarvan metaconfig deel uitmaakt) wordt geïnstalleerd in LIB, vervolgens het publieke U
map is LIB/dist/mcon/U. Op deze machine is de LIB-directory /usr/share/dist. Jouw
private U-map, als u die heeft, bevindt zich in de map op het hoogste niveau van uw pakket.
Voordat je kunt rennen metaconfig je moet een aantal dingen doen:

· Maak een .package-bestand in de map op het hoogste niveau van het pakket door dit uit te voeren inpakken.
Dit programma zal u vragen naar uw pakket en onthouden wat u hem vertelt, zodat u het kunt onthouden
alle dist-programma's kunnen slim zijn.

· Raadpleeg de verklarende woordenlijst (in LIB/dist/mcon) en schrijf uw shellscripts en C-programma's
in termen van de symbolen die metaconfig weet te definiëren. Je hoeft het niet te vertellen
metaconfig welke symbolen je hebt gebruikt, aangezien metaconfig dat voor je uitzoekt.

· Genereer alle .SH-scripts die nodig zijn om Makefiles of shell-scripts te schrijven die hiervan afhankelijk zijn
op waarden die zijn gedefinieerd door Configure. Er is een programma genaamd maakSH dat zal je helpen
converteer een gewoon script naar een script.SH-sjabloon; er zal nog wel wat bewerking nodig zijn
uitgevoerd op het resulterende .SH-bestand om het variabele configuratiegedeelte in het .SH-bestand te verplaatsen
bovenste deel van het script (zie inline opmerkingen gegenereerd door maakSH binnen uw .SH
bestand).

· Maak een MANIFEST.new-bestand in uw map op het hoogste niveau waarin alle bestanden worden vermeld
Jouw pakket. Dit bestand blijft privé en maakt geen deel uit van de finale
verdeling. (Voor het gemak wordt het MANIFEST-bestand gebruikt door metaconfig if
er is nog geen MANIFEST.new-bestand.) De bestandsnaam moet in elk veld het eerste veld zijn
lijn. Na wat witruimte kunt u een korte opmerking toevoegen die uw bestand beschrijft. Alleen
bronbestanden moeten daarin worden vermeld. Het speciale bestand patchniveau.h (dat is
behandeld en onderhouden door de patchingtools - zie pat(1)) moet deel uitmaken van de
MANIFEST.new-bestand, maar kan door sommige tools stilzwijgend worden genegeerd. Als vuistregel,
alleen bestanden die door RCS worden onderhouden, mogen daarin worden vermeld, de patchniveau.h bestand zijn
één belangrijke uitzondering.

· Optioneel kunt u een MANIFEST-bestand maken, wat een geëxporteerde versie zal zijn
van uw MANIFEST.new. Dat bestand moet deel uitmaken van de release, dwz in beide worden vermeld
uw MANIFEST.nieuw en MANIFEST zelf. Een van de metaconfig eenheden weten hiervan
bestand en dwingt Configure een vrijgavecontrole uit te voeren, waarbij alle bestanden worden gecontroleerd
die daar vermeld staan, maken deel uit van de distributie. De bestanden MANIFEST en MANIFEST.new moeten
onderscheidend zijn, geen verbanden.

· Kopieer alle .U-bestanden die u wilt wijzigen naar uw privé-U-map. Alle .U-bestanden
in uw privé U-directory wordt voorrang gebruikt boven die in de openbare U
map. Eén manier om de opname van een eenheid af te dwingen, is bijvoorbeeld door de End.U
bestand naar uw .U-directory en voeg de naam toe van de eenheid waarvan u een afhankelijkheid wilt maken
het einde van de ?MAKE: regel. Bepaalde eenheden kunnen ALLEEN op deze manier worden geforceerd, namelijk
die van de vorm Warn_*.U en Chk_*.U. U kunt ook bepaalde standaardinstellingen aanpassen
Configureer variabelen door Myinit.U naar de privé U-map van uw pakket te kopiëren en
het instellen van de variabelen in die eenheid.

Nu ben je klaar om te rennen metaconfig. Dat zal een creëren Configure bestand, en optioneel een
config_h.SH bestand (als uw bronnen enig gebruik maken van C-symbolen). De gegenereerde bestanden zullen
indien nodig automatisch aan uw MANIFEST.new toegevoegd. Vergeet niet uw
MANIFEST-bestand wel.

Om nieuwe eenheden aan te maken, doe je het volgende:

· Kopieer een soortgelijke eenheid naar een nieuw .U-bestand. De naam die u kiest, moet de naam zijn van a
variabele die door de eenheid wordt gegenereerd, hoewel dit alleen voor uw gemak is, en niet voor a
vereiste. Het moet 12 of minder tekens bevatten om te voorkomen dat de bestandsnaam wordt afgebroken.
Eigenlijk zou het waarschijnlijk 10 of minder moeten zijn, zodat degenen die RCS willen gebruiken dit kunnen hebben
a.U,v aan het uiteinde zonder te hakken. Metaconfig gebruikt de hoofdlettergebruik van de eerste letter to
bepaal of er daadwerkelijk een variabele door deze eenheid wordt geproduceerd, dus gebruik geen hoofdletter
eenheidsnaam als deze een shellvariabele moet produceren.

· Bewerk het nieuwe .U-bestand zodat het doet wat u wilt. De eerste ?MAKE: regel geeft de
afhankelijkheden; vóór de definitieve lijst een dubbele punt van alle variabelen die deze eenheid definieert, en
na de laatste dubbele punt alle variabelen (of andere eenheden) waarvan deze eenheid afhankelijk is.
Het is heel belangrijk dat deze lijsten accuraat zijn. Als een afhankelijkheid optioneel is en a
standaardwaarde kan worden gebruikt, moet u de afhankelijkheid vooraf laten gaan door een '+' teken. De
de overeenkomstige eenheid wordt niet geladen om het symbool te berekenen, tenzij dit echt nodig is
door een andere eenheid.

· Parametreer, voor zover mogelijk, uw eenheid op basis van de shell-variabele die is gedefinieerd
?INIT: lijnen. Hierdoor worden de variabeledefinities naar de Init.U-eenheid verplaatst, waar
ze kunnen worden overschreven door definities in Myinit.U, die is opgenomen na Init.U.

· Voeg de definitie van eventuele gewenste C-symbolen toe als ?H:-lijnen. Een regel die begint met
?H:?%<: in het .U-bestand wordt alleen toegevoegd aan het uiteindelijke config.h-bestand als
metaconfig besluit dat deze eenheid nodig is. De %< staat voor de naam van de eenheid,
wat toevallig ook de naam van het bestand is (zonder .U) als je de
conventie. Plaats altijd commentaar op elke ?H:-regel als het een van de variabelen is
Vervangingen eerder op de lijn starten een opmerking zonder deze af te maken. Elke schaal
variabele die begint met d_ kan dit doen, dus pas op. Als u de ?%<: weglaat, dan
metaconfig zal proberen het symbool te begrijpen waarvan de definitie vooraf nodig is
opname in config.h.

· Voeg woordenlijstdefinities toe als ?S: regels voor shell-variabelen en ?C: regels voor C
preprocessorvariabelen. Zie een huidige eenheid voor voorbeelden. Het is HEEL belangrijk om
begin elke invoer met een links uitgelijnde symboolnaam en eindig elke invoer met een ?C:. of
?S:. lijn. Het algoritme dat symboolinvoer van de C-preprocessor vertaalt voor de
Woordenlijst met opmerkingen voor config.h hangt hiervan af.

· Zorg ervoor dat de bestelling van al uw ? lijnen klopt. De juiste volgorde is:

?RCS: en ?X: eigenlijk alleen maar commentaar
?MAKE: metaconfig-afhankelijkheden
?Y: richtlijn voor indeling van de unit
?S: verklarende woordenlijst shell-definities
?C: verklarende woordenlijst C-definities
?H: config.h-definities
?M: confmagic.h-definities
?W: gezochte symbolen
?V: zichtbare symbolen
?F: bestanden gemaakt door dit toestel
?T: tijdelijke shell-symbolen gebruikt
?D: optionele standaardwaarde voor afhankelijkheden
?O: gebruikt om verouderde eenheden te markeren
?LINT: metalint-hints
?INIT: initialisaties van shell-symbolen

Hier is een voorbeeld om de volgorde van de regels en de verschillende toegestane formaten te tonen:

?RCS: $RCS-ID$
?RCS: Copyrightinformatie
?RCS: $RCS-logboek$
?X:
?X: Een gekunsteld voorbeeld
?X:
?MAKE:d_one twee: drie +vier Vijf
?MAKE: -kies voeg $@ % toe
?Y:STANDAARD
?S:d_one:
?S: Eerste shell-symbool, definieert voorwaardelijk EEN.
?S:.
?S:twee:
?S: Tweede shell-symbool, waarde voor TWEE.
?S:.
?KEGEL:
?C: Eerste C-symbool.
?C:.
?C:TWEE:
?C: Tweede C-symbool.
?C:.
?H:#$d_one EEN /**/
?H:#define TWEE "$twee"
?H:#$d_one ONE_TWO "$twee"
?H:.
?M:flip: HAS_FLIP
?M:#ifndef HAS_FLIP
?M:#define flip(x) flop(x)
?M:#eindif
?M:.
?W:%<:één_twee
?V:p_één p_twee:p_drie
?F:bestand ./ftest !tmp
?T:tmp var
?D:twee='undef'
?LINT: verander er drie
?INIT:twee_init='2'
: shell-code die de eenheid implementeert volgt
p_one='één'
p_two='twee'
p_drie = ""

Laat ik het nog een keer zeggen: de bovenstaande eenheidsdefinitie is a nep één om alleen de te laten zien
verschillende mogelijkheden. Zo'n eenheid zou sowieso weinig nut hebben... Nog wat meer
geavanceerde functies worden hier niet beschreven. Raadpleeg de REFERENTIE sectie voor meer
complete informatie.

· Plaats het apparaat naar wens in de publieke of private U-directory.

· Opnieuw uitvoeren metaconfig.

· Stuur uw eenheid naar [e-mail beveiligd] (Raphael Manfredi) voor opname in de mastercopy,
als u denkt dat het van algemeen belang is.

Om een ​​nieuw te lokaliseren programma toe te voegen:

· Bewerk Loc.U en voeg de naam van het programma toe aan de ?MAKE: regel (tussen de
twee dubbele punten) en naar loclist of trylist (afhankelijk van of het programma dat is
verplicht of niet).

· Voer metaconfig opnieuw uit.

· Stuur uw unit naar mij zodat deze kan worden opgenomen in het masterexemplaar, als u denkt dat het algemeen is
belang.

Opmerkingen voor het schrijven van .U-bestanden:

* Gebruik altijd "rm -f" omdat er systemen zijn waarbij rm standaard interactief is.

* Gebruik niet "set -- ..." omdat '--' niet met elke shell werkt. Gebruik "set x ...;
verschuiving".

* Gebruik "unset ENV" niet, aangezien unset niet volledig draagbaar is. Zeg in plaats daarvan "ENV=''".

* Gebruik altijd echo " " (met een spatie) vanwege Eunice-systemen.

* Alleen gebruiken proef met -r, -w, -f of -d omdat dit de enige draagbare schakelaars zijn. In
vermijd vooral "test -x".

* Gebruik alleen programma's die bij V7 zijn geleverd, zodat u weet dat iedereen ze heeft.

* Gebruik $contains als je voorwaardelijk grep wilt maken, omdat niet alle greps a retourneren
redelijke toestand. Zorg ervoor dat u de uitvoer omleidt naar /dev/null, met behulp van '>/dev/null
2>&1'.

* Gebruik "if test" in plaats van "if [...]", aangezien niet elke sh dit laatste construct kent.

* Gebruik het myread-script voor invoer, zodat ze shell-escapes en standaardwaarden kunnen uitvoeren
evaluatie. De algemene vorm is

geval "$grimble" in
'') dflt=452;;
*) dflt="$grimble";;
hexac
rp='Hoeveel grimbles heb je?'
. ./mijnlezen
grimble="$ ans"

* Gebruik het getfile-script wanneer u om een ​​bestandspadnaam vraagt ​​om optioneel te zijn
~naamuitbreiding en geestelijke gezondheidscontroles. Zie de Getfile.U-eenheid voor een volledige beschrijving.

* Zet altijd een

$startsh

bovenaan elk gegenereerd script dat wordt gelanceerd of gebruikt
Configure .

* Ga nooit uit van algemene UNIX-ismen, zoals het feit dat een objectbestand eindigt met een .o en
waarmee een bibliotheeknaam eindigt .a. Gebruik de $_o en $_a variabelen in plaats daarvan (zie
Unix.U).

* Wanneer u een compile-link-execute-test uitvoert, schrijf deze dan altijd als volgt:

$cc $ccflags $ldflags try.c -o probeer $libs

omdat sommige systemen vereisen dat koppelingsvlaggen worden opgegeven voordat ze worden gecompileerd
doel (met uitzondering van trailing linking-bibliotheken).

* Geef belangrijke berichten weer op bestandsdescriptor #4, door '>&4' te gebruiken om de uitvoer om te leiden.
Alleen die berichten verschijnen wanneer de -s schakelaar wordt gegeven Configure op de
opdrachtregel (stille modus).

* Probeer altijd op de meest specifieke manier te bepalen of een kenmerk aanwezig is; doe dat niet
zeg "if bsd" als je libc kunt grep. Er zijn veel hybride systemen beschikbaar, en
elk kenmerk moet op zichzelf staan ​​of vallen.

* Probeer altijd op de meest algemene manier vast te stellen of een kenmerk aanwezig is, zodat
andere pakketten kunnen uw apparaat gebruiken.

* Stel bij twijfel een standaard in en vraag ernaar. Neem niets aan.

* Als u denkt dat de gebruiker ongelijk heeft, houd er dan rekening mee dat hij wellicht gelijk heeft. Voor
Het kan bijvoorbeeld zijn dat hij Configure op een ander systeem uitvoert dan hij gaat gebruiken
het eindproduct op.

Metaconfig reserveert de volgende namen in uw directory, en als u een dergelijke naam gebruikt, wordt deze ook bewaard
kan in elkaar slaan of andere onvoorziene effecten hebben:

.MT/*
Configure
gezocht
Verouderd
configureer
config_h.SH
confmagic.h
U/*
MANIFEST.nieuw

Bovendien kan Configure deze namen in de map waarin het wordt uitgevoerd, vernietigen:

UU/*
config.sh
configuratie.h

OPTIES

De volgende opties worden herkend door: metaconfig:

-d Schakel de foutopsporingsmodus in. Niet echt nuttig, tenzij je aan het debuggen bent metaconfig
zelf.

-h Help-bericht afdrukken en afsluiten.

-k Bewaar een tijdelijke map, zodat u de werkbestanden kunt bekijken die worden gebruikt door
metaconfig om je te bouwen Configure script. Alleen nuttig bij het debuggen van het
units.

-m Ga uit van veel geheugen en swapruimte. Dit versnelt het opzoeken van symbolen
bronbestanden met een aanzienlijke hoeveelheid tijd, ten koste van het geheugen
consumptie...

-o Wijs verouderde symbolen toe aan nieuwe. Gebruik deze schakelaar als je er nog een hebt
verouderde symbolen in uw broncode en die u niet wilt (of kunt) verwijderen
ze voor nu. De verouderde symbolen worden overigens genegeerd, hoewel dat zo is
zal u een waarschuwing geven van metaconfig.

-s Schakel de stille modus in.

-t Traceer symbolen zodra ze worden gevonden.

-v Schakel de uitgebreide modus in.

-w Ga ervan uit dat het gewenste bestand up-to-date is. Hiermee worden de tijd en het geheugen overgeslagen
consumerende fase van het scannen van de broncode, op zoek naar bekende symbolen. Gebruik het
alleen als u weet dat uw bronbestand niet is gewijzigd ten opzichte van het
Zwembad van metaconfig gebruikte symbolen.

-G Zorg ook voor een GNU configureer-achtige voorkant naar het gegenereerde Configure
script, dat ook in de distributie moet worden opgenomen. Dit is slechts een omslag
in de Configure script natuurlijk, maar het laat mensen vertrouwd raken met de
GNU-tool om niet verloren te gaan als u met een nieuwe distributie wordt geconfronteerd.

-L dir Negeer de standaard bibliotheeklocatie. Normaal gesproken alleen nuttig voor metaconfig
beheerders om de eenheden die worden ontwikkeld lokaal te gebruiken in plaats van de
openbaar beschikbare. De dir opgegeven is degene die de eenheden bevat
U directory.

-M Laat de productie van een confmagic.h bestand om automatisch een aantal goed-
bekende symbolen naar een ander alternatief, zoals bkopie() wordt opnieuw toegewezen
transparant naar memcpy() wanneer niet beschikbaar. Deze optie is ingeschakeld
automatisch wanneer een confmagic.h bestand bestaat in de map op het hoogste niveau.
Verwijder eenvoudigweg dat bestand als u deze optie permanent wilt uitschakelen.

-V Versienummer afdrukken en afsluiten.

TUTORIAL

Dit (lange) gedeelte is een introductie tot metaconfig, waarin we alles zullen leren
basis. Als je al weet hoe je het moet gebruiken metaconfig, kunt u veilig naar de volgende gaan
pagina.

Overzicht
Meestal als u een bronpakket wilt compileren op een bepaald platform dat u heeft
om de belangrijkste Makefile te bewerken (ervan uitgaande dat die er is!), kies dan een C-compiler, zorg ervoor dat je
zorg dat u over de juiste bibliotheken beschikt en vuur vervolgens de maken commando. Als het pakket redelijk is
goed geschreven, het zal compileren (zonder dat een waarschuwing een optie is :-). Op zichzelf de laatste
zin is een echte prestatie, gezien de verscheidenheid aan UNIX-platforms die vandaag de dag beschikbaar zijn
en de diversiteit aan smaken, dat betekent dat de auteur van het pakket er diep op is ingegaan
moeite om de juiste keuzes te vinden, gegeven wat standaard uitproberen, raden en knoeien
rond met systeem omvat en typen.

Ondanks al zijn talent kan de auteur echter onmogelijk weten dat een bepaald systeem een ​​systeem heeft
kapotte systeemaanroep, of dat een systeemstructuur een anderszins standaardveld mist, of
eenvoudigweg of een bepaald include-bestand bestaat of niet. En ik houd geen rekening met het impliciete
aannames, zoals het type dat wordt geretourneerd door de malloc () functie of de aanwezigheid van de
hernoem() systeemoproep om er maar een paar te noemen. Maar die kennis is nodig om werkelijkheid te bereiken
draagbaarheid.

Laten we onszelf nu niet misbruiken. Het gebruik van die informatie vereist grotere vaardigheden, maar dat kan wel
leiden tot meer draagbare programma's, omdat deze dan op een systeemonafhankelijke manier worden geschreven
en berust alleen op het feit dat een bepaalde veronderstelling waar of onwaar is op een bepaald systeem,
elke aanname staat los van elkaar. Dat wil zeggen, we zeggen niet: we zitten op een
BSD-systeem of we gebruiken een USG-systeem. Dat is tegenwoordig toch te vaag. Nee, dat willen wij
zeg tegen de broncode: dit systeem beschikt niet over de hernoem() systeemoproep en malloc ()
geeft een terug (leegte *) waarde.

Metaconfig is een tool waarmee u precies dat kunt doen, met het extra voordeel dat dit niet het geval is
de Makefile met de hand moeten bewerken als alles goed gaat. Door rennen metaconfig, je maakt een
shellscript genoemd Configure . Er is veel aandacht besteed aan het Configure-script
internals om ervoor te zorgen dat het vanaf nu op 99% van de bestaande shells zal werken
schrijven. Configure onderzoekt het doelsysteem en stelt vragen bij twijfel
verzamel alle antwoorden in één enkel shell-bestand, dat op zijn beurt kan worden gebruikt
automatisch geconfigureerde Makefiles en C include-bestanden genereren.

Er is slechts een beperkte (maar vrij grote) set symbolen beschikbaar voor uw shellscripts
en C-programma's. Ze zijn allemaal gedocumenteerd in het bestand Woordenlijst. Het enige dat u hoeft te doen, is leren
over hen en ga ze gebruiken om portabiliteits- en configuratieproblemen aan te pakken. Dan,
door rennen metaconfig, wordt er een geschikt Configure-script gegenereerd voor uw pakket.

Het Configure-script is opgebouwd uit verschillende eenheden (meer dan 300), waarbij elke eenheid bestaat uit
verantwoordelijk voor het definiëren van een klein aantal shell- en/of C-symbolen. Eenheden worden geassembleerd
samen in de laatste fase, waarbij de afhankelijkheidsgrafiek wordt gerespecteerd (één eenheid heeft mogelijk het resultaat nodig).
van verschillende andere eenheden die vervolgens eerder in het script worden geplaatst).

Symbolen
Symbolen zijn het belangrijkste in de metaconfig wereld. Ze zijn de kleinste
herkende entiteit, meestal een woord, en kan aan het einde van de configuratie een waarde worden toegekend
executie. Bijvoorbeeld het C-preprocessorsymbool HAS_RENAME is een metaconfig symbool dat
wordt gegarandeerd gedefinieerd als, en alleen als, de hernoem() systeemoproep aanwezig is. Insgelijks,
de $ranlib shell-variabele wordt ingesteld op ':' of 'ranlib', afhankelijk van of de
bel naar de ranlib programma is nodig om een ​​bibliotheekbestand te bestellen. Hoe dit werkt is dat niet
Wat voor nu belangrijk is, is om te begrijpen dat deze symbolen een leven
(dwz een waarde) op Configure uitvoering.

Het gebruik van symbolen is relatief eenvoudig. In een C-bronbestand gebruik je eenvoudigweg het symbool
waarde, als een pre-processorrichtlijn (bijvoorbeeld een: #ifdef HAS_RENAME) of, als het symbool
waarde is een string, direct zoals je een macro in C zou gebruiken. En in een shell-bestand of a
Makefile, u kunt rechtstreeks naar een shell-symbool verwijzen.

Eigenlijk lieg ik, want dat is niet zo magisch als de vorige paragraaf
zou kunnen klinken. In een C-bestand moet u het door Configure geproduceerde configuratie.h bestand en
u moet uw shellscript of Makefile in een .SH-bestand verpakken en u mag naar de shell verwijzen
symbool alleen in het variabelevervangingsgedeelte van dat .SH-bestand. Hierover later meer.

bron Bestanden
Symbolen verschijnen mogelijk alleen in een beperkte set bronbestanden, omdat metaconfig zal alleen
scan deze bij het zoeken naar bekende symbolen en probeer erachter te komen welke eenheden het nodig heeft.
U kunt C-symbolen gebruiken in C-bronbestanden, dat wil zeggen bestanden met een .c, .h, .y or .l extensie, en
shell-symbolen worden alleen gezocht in .SH-bestanden.

Om de waarde van een symbool te krijgen, moet een C-bestand de special configuratie.h
bestand, dat is geproduceerd door Configure wanneer C-symbolen aanwezig zijn. En .SH-bestanden worden uitgevoerd
via een shell, waardoor een nieuw bestand ontstaat. In het bovenste gedeelte van het .SH-bestand staat echter de
special config.sh bestand (ook geproduceerd door running Configure ) is afkomstig en variabel
vervangingen zijn van toepassing. Eigenlijk, configuratie.h wordt geproduceerd door het uitvoeren van de metaconfig-geproduceerd
config_h.SH bestand, opnieuw met behulp van variabelevervanging. Dus daar gaan we naar kijken a
iets nader, aangezien dit de kern van het geheel is configuratie schema...

Veranderlijk Vervanging
Er is een shell-constructie genaamd hier document waardoor een commando een invoer kan ontvangen
gespecificeerd in het script zelf. Die invoer wordt door de shell geïnterpreteerd als een dubbele
tekenreeks tussen aanhalingstekens of een enkele tekenreeks tussen aanhalingstekens, afhankelijk van de vorm van het here-document
specificatie.

Om een ​​here-document te specificeren, wordt het '<<'-token gebruikt, gevolgd door een enkele identificatie. Van
Vervolgens vormen de resterende scriptregels de invoer voor het commando, tot hier
document op zichzelf op een regel wordt gevonden. Shell-vervanging (inclusief shell-variabele
vervangingen) wordt gedaan tenzij de identificatie tussen enkele aanhalingstekens staat. Bijvoorbeeld:

var='eerste'
tar='tweede'
echo "--> eerst hier document:"
kat <
var='$var'
tar='$tar'
EOM
echo "--> tweede hier document:"
kat <<'EOM'
echo $var
echo $tar
EOM
echo "--> einde."

zal produceren, wanneer het door een schaal wordt gehaald:

--> eerst hier document:
var='eerste'
tar='tweede'
--> tweede hier document:
echo $var
echo $tar
--> einde.

Van het eerste hier-document wordt de inhoud geïnterpreteerd, terwijl van het tweede document wordt uitgevoerd zoals het is.
Beide zijn nuttig in een .SH-script, zoals we binnenkort zullen zien.

gebruik .NS Scripts
Een .SH-script wordt meestal geproduceerd door het uitvoeren van de .SH-script MerknaamSH script andere een bestaand bestand,
transformeren filet een bestand.SH. Laten we een enkel voorbeeld nemen. Hier is een klein scriptje
(laten we het noemen intgrootte) waarmee één enkel bericht wordt afgedrukt, ter grootte van de int gegevenstype in C.
Helaas zit de waarde erin vastgebakken, dus:

#!/ Bin / sh
intsize='4'
echo "Op deze machine is het int-type $intsize bytes"

Laten we rennen maakSH daarop door ' te typenmaakSH intgrootte'. Wij krijgen een single intsize.SH bestand dat
het lijkt hierop:

geval $CONFIG in
'')
als test -f config.sh; dan TOP=.;
elif test -f ../config.sh; dan TOP=..;
elif test -f ../../config.sh; dan TOP=../..;
elif test -f ../../../config.sh; dan TOP=../../..;
elif test -f ../../../../config.sh; dan TOP=../../../..;
anders
echo "Kan config.sh niet vinden."; uitgang 1
fi
. $TOP/config.sh
;;
hexac
: Dit dwingt SH-bestanden om een ​​doel te maken in dezelfde map als het SH-bestand.
: Dit is zodat make depend altijd weet waar SH-derivaten te vinden zijn.
geval "$ 0" in
*/*) cd `expr X$0 : 'X\(.*\)/'` ;;
hexac
echo "Intsize extraheren (met vervangingen van variabelen)"
: In dit gedeelte van het bestand worden variabele vervangingen uitgevoerd.
: Verplaats alles waarvoor configuratie-subs nodig zijn van !NO!SUBS! sectie naar !GROK!THIS!.
: Bescherm alle dollartekens en backticks die u niet wilt laten interpreteren
: door een backslash ervoor te plaatsen. U kunt deze opmerkingen verwijderen.
$spitshell >intsize <
$startsh
!GROK!DIT!

: In de volgende dollars en backticks is de extra backslash niet nodig.
$spitshell >>intsize <<'!NO!SUBS!'
intsize='4'
echo "Op deze machine is het int-type $intsize bytes"
!GEEN!ABONNEMENTEN!
chmod 755 intsize
$eunicefix intsize

Het eerste deel van dit script (in de geval statement) probeert de config.sh
bestand, om het te kunnen sourcen. De $CONFIG variabele is standaard false, wanneer waar
config.sh is al gesourced (wat het geval zou zijn als dit bestand werd uitgevoerd vanuit
binnen Configure zelf, maar laten we de kwestie hier niet verwarren).

Wanneer de config.sh bestand bronnen zijn geweest, alle shell-symbolen gedefinieerd door Configure zijn
set. We weten dat er een tweede case-instructie is bereikt, die wordt gebruikt om de huidige map te wijzigen als er een
pad gebruikt worden om dit programma te bereiken (bijvoorbeeld als we zeiden 'sh ../scripts/intsize.SH', Wij
zou eerst rennen 'cd ../scripts' voordat u verdergaat). Als je dit niet begrijpt, doe het dan niet
zich zorgen maken.

Hier komen de interessante dingen. Dit script maakt gebruik van de $spuugschelp variabel, en dat is het niet
iets waar we al vanaf weten. Als u door het bestand Woordenlijst bladert, ziet u dat
dit is een variabele bekend bij metaconfig. Als u dit bestand onderdeel maakt van uw distributie
(door het op te nemen in het bestand MANIFEST.new, we komen daar later op terug) en voer het uit
metaconfig, dan de Configure script zal een geschikte waarde voor deze variabele bepalen
en het zal worden ingevoerd config.sh. Hetzelfde geldt voor $startsh en het mysterieuze $eunicfix at
het einde. Op een redelijk systeem is het relevante deel van config.sh zou er als volgt uitzien:

spitshell='kat'
startsh='#!/ Bin / sh'
eunicefix=':'

Ah! We komen er. Nu ziet het er bekend uit. We hebben te maken met een single hoe opdracht waarvan
invoer komt uit een met variabelen geïnterpoleerd here-document en waarnaar de uitvoer wordt doorgestuurd
intgrootte. De waarde zal die van zijn $startsh, dat wil zeggen '#!/ Bin / sh'. Prima tot nu toe.

Dan bereiken we de tweede documentuitbreiding, om de rest van het script te krijgen. Dit
tijd wordt het hier-documentsymbool omgeven door enkele aanhalingstekens, zodat de inhoud dat zal zijn
letterlijk toegevoegd aan de intgrootte bestand. Dus door te rennen 'sh intsize.SH', wij krijgen de
volgende uitvoer:

Intsize extraheren (met variabele vervangingen)

en door naar het geproduceerde intsize-bestand te kijken, zien we:

#!/ Bin / sh
intsize='4'
echo "Op deze machine is het int-type $intsize bytes"

en dat is precies wat we in het begin hadden. Tot nu toe is het een procedure zonder operatie...
Maar wat geweldig! Het gebeurt zo (puur toeval, geloof me!), dat metaconfig weet
over de $intgrootte schelp symbool. Door de initialisatie van intsize naar de variabele te verplaatsen
geïnterpoleerd gebied van het .SH-script en initialiseert het met de .SH-script Configure -berekende waarde,
en het verwijderen van de nu nutteloze opmerkingen toegevoegd door maakSH, we krijgen:

geval $CONFIG in
'')
als test -f config.sh; dan TOP=.;
elif test -f ../config.sh; dan TOP=..;
elif test -f ../../config.sh; dan TOP=../..;
elif test -f ../../../config.sh; dan TOP=../../..;
elif test -f ../../../../config.sh; dan TOP=../../../..;
anders
echo "Kan config.sh niet vinden."; uitgang 1
fi
. $TOP/config.sh
;;
hexac
geval "$ 0" in
*/*) cd `expr X$0 : 'X\(.*\)/'` ;;
hexac
echo "Intsize extraheren (met vervangingen van variabelen)"
$spitshell >intsize <
$startsh
intsize='$intsize'
!GROK!DIT!

$spitshell >>intsize <<'!NO!SUBS!'
echo "Op deze machine is het int-type $intsize bytes"
!GEEN!ABONNEMENTEN!
chmod 755 intsize
$eunicefix intsize

Als u dit script door een shell laat lopen, wordt uiteraard hetzelfde script opnieuw uitgevoerd. Maar als
wij rennen Configure op een machine waarop een int wordt opgeslagen als een hoeveelheid van 64 bits, config.sh wil
reeks intgrootte tot 8 en de intgrootte script zal de juiste waarde hebben en afdrukken:

Op deze machine is het int-type 8 bytes

welke is correct. Gefeliciteerd! We hebben zojuist een shellscript geconfigureerd!!

Het produceren configuratie.h
We kunnen nu de route bekijken configuratie.h waaruit wordt geproduceerd config_h.SH. We weten dat
lopend Configure produceert een config.sh script (hoe dit precies wordt gedaan is niet strikt
relevant hier, maar voor de nieuwsgierigen: het is een andere documentvervanging hierbinnen
Configure zelf). De config_h.SH zelf is gebouwd door metaconfig tegelijkertijd
Configure is, op voorwaarde dat u binnen uw bronnen gebruik maakt van minimaal één C-symbool.

Laten we eens een paar willekeurige bekijken config_h.SH bestand om te zien wat er werkelijk gebeurt:

geval $CONFIG in
'')
als test -f config.sh; dan TOP=.;
elif test -f ../config.sh; dan TOP=..;
elif test -f ../../config.sh; dan TOP=../..;
elif test -f ../../../config.sh; dan TOP=../../..;
elif test -f ../../../../config.sh; dan TOP=../../../..;
anders
echo "Kan config.sh niet vinden."; uitgang 1
fi
. $TOP/config.sh
;;
hexac
geval "$ 0" in
*/*) cd `expr X$0 : 'X\(.*\)/'` ;;
hexac
echo "Configur.h uitpakken (met vervangingen van variabelen)"
sed < config.h -e 's!^#undef!/define!' -e 's!^#un-def!#undef!'
/*
* Dit bestand is gemaakt door het script config_h.SH uit te voeren
* haalt zijn waarden uit config.sh, dat doorgaans wordt geproduceerd door
* Configureren uitvoeren.
*
* Voel je vrij om dit allemaal te wijzigen als dat nodig is. Houd er echter rekening mee dat
* dat het opnieuw uitvoeren van config.h.SH alle aangebrachte wijzigingen teniet zal doen.
* Voor een meer permanente verandering bewerk je config.sh en voer je config.h.SH opnieuw uit.
*/

/* Configuratietijd: $cf_time
* Geconfigureerd door: $cf_by
* Doelsysteem: $myuname
*/

#ifndef _config_h_
#define_config_h_

/* bkopie:
* Dit symbool wordt toegewezen aan memcpy als de bcopy()-routine dat niet is
* beschikbaar om tekenreeksen te kopiëren.
*/
/* HAS_BCOPY:
* Dit symbool wordt gedefinieerd als de bcopy()-routine beschikbaar is
* kopieer geheugenblokken. U mag dit symbool niet gebruiken onder
* normale omstandigheden en gebruik in plaats daarvan direct bcopy().
* wordt toegewezen aan memcpy() als bcopy niet beschikbaar is.
*/
#$d_bcopy HAS_BCOPY /**/
#ifndef HAS_BCOPY
#ifdef bkopie
#un-def bcopy
#stop als
#define bcopy(s,d,l) memcpy((d),(s),(l)) /* toegewezen aan memcpy */
#stop als

/* HAS_DUP2:
* Dit symbool geeft, indien gedefinieerd, aan dat het om de dup2-routine gaat
* beschikbaar voor het dupliceren van bestandsdescriptors.
*/
#$d_dup2 HAS_DUP2 /**/

/* IK_STRING:
* Dit symbool, indien gedefinieerd, geeft aan het C-programma aan dat dit zo zou moeten zijn
* erbij betrekken (USG-systemen) in plaats van (BSD-systemen).
*/
#$i_string I_STRING /**/

#stop als
!GROK!DIT!

Bovenaan het bestand herkennen we de standaard .SH-constructie die we al hebben
gedetailleerd bestudeerd. Vervolgens komt de extractie van het bestand zelf, via een hier-document met
variabele vervangingen. Hier gebruiken we echter geen vlakte hoe maar a dorst in plaats daarvan, sinds
we moeten onderweg nog wat verdere bewerkingen uitvoeren. We zullen later zien waarom, dus laten we het vergeten
er nu over.

We komen nu bij de belangrijkste opmerking en het bestand is getagd met de configuratietijd, de
doelsysteem, enz... (deze variabelen komen uit het sourced config.sh bestand geweest
opgezet door Configure ). Die commentaarkop wordt gevolgd door een '#ifndef'-bescherming om te bewaken
tegen meerdere opnames van dit bestand. Dan komt het hart van het bestand...

Het helpt om dat te weten $d_* en $i_* variabelen zijn ingesteld op 'bepalen'of'ondefinieerbaar' door
Configure , afhankelijk van of er een functie of een include-bestand aanwezig is op het systeem of
niet. Dat betekent de:

#$d_bcopy HAS_BCOPY /**/

lijn wordt uitgebreid naar:

#define HAS_BCOPY /**/

als de variabele $d_bcopy is ingesteld op 'define' of:

#undef HAS_BCOPY /**/

als $d_bcopy was ingesteld op 'undef', omdat de functie er niet was. Dat is echter niet het geval
wat er in de configuratie.h bestand vanwege de dorst filter dat we al hebben gezien,
die de tweede vorm zal transformeren in:

/*#define HAS_BCOPY /**/

Dat is een handig formulier om later te bewerken configuratie.h omdat je alleen de
met '/*' als u dit wilt overschrijven Configure 's keuze. Op dezelfde manier kunt u er één toevoegen
'/*' aan het begin van een '#define'-regel om de definitie van een bepaald symbool te vermijden.
Dit is de reden waarom elke symbooldefinitie wordt beschermd door een '/**/' aan het einde, om de voorloop af te sluiten
commentaar geopend door '/*' (commentaar is niet genest in C).

Nu is het leuk om '#undef' om te zetten in '/*#define', maar als we daadwerkelijk a
'#undef', we zitten vast... tenzij we het schrijven als '#un-def' en let dorst herstel dat naar '#undef'
tijdens het produceren configuratie.h, wat hier feitelijk wordt gedaan.

Dezelfde soort redenering is van toepassing op deze twee lijnen:

#$d_dup2 HAS_DUP2 /**/
#$i_string I_STRING /**/

en ervan uitgaande dat config.sh definieert:

d_dup2='definieer'
i_string='undef'

we komen in de geproduceerde configuratie.h:

#define HAS_DUP2 /**/
/*#define I_STRING /**/

Helder als stromend water? Goed!

Nu zou het duidelijk moeten zijn dat door op te nemen configuratie.h in al uw C-bronbestanden komt u bij
weet je wat Configure heeft geraden op uw systeem. Door deze symbolen te gebruiken, ben je dat in feite ook
schrijven van geconfigureerde C-code, sindsdien metaconfig zal weten dat je die symbolen en wil nodig hebt
een geschikt genereren config_h.SH bestand en alle benodigde code in Configure naar
bereken er een juiste waarde voor (door waarden toe te wijzen aan bijbehorende shell-variabelen).

Hardlopen Metaconfig
Laten we ons concentreren op de metaconfig programma een tijdje om te begrijpen hoe het zijn eenheden gebruikt en
uw broncode om alle benodigde configuratiebestanden te produceren. Als u van plan bent om nieuw te schrijven
eenheden, moet u het hele schema goed begrijpen.

Als er geen MANIFEST.new-bestand is, metaconfig zal proberen in plaats daarvan het MANIFEST-bestand te gebruiken,
voor het gemak. Overal waar we MANIFEST.new noemen, kan het worden opgevat als MANIFEST
op voorwaarde dat er geen bestand MANIFEST.new in de root van uw pakket wordt gevonden.

Ervan uitgaande dat uw MANIFEST.new-bestand correct is ingesteld en alle gewenste bronbestanden vermeldt
configureren en dat u hebt uitgevoerd pakket in uw hoofdbronmap om een
.pakket bestand, u kunt uitvoeren metaconfig en je krijgt het volgende:

$ metaconfig
Eenheden lokaliseren...
Afhankelijkheidslijsten uit 312 eenheden extraheren...
Bestandsnamen (*.[chyl] en *.SH) extraheren uit MANIFEST.new...
Een Gezocht-bestand opbouwen...
.[chyl]-bestanden scannen op symbolen...
.SH-bestanden scannen op symbolen...
Optimale afhankelijkheidsgrafiek berekenen...
Privé make-bestand maken...
Bepalen van laadbare eenheden...
Make-bestand bijwerken...
De juiste volgorde voor de eenheden bepalen...
Configuratie maken...
Gereed.

In de eerste fase wordt gezocht naar alle unit-bestanden (eindigend op .U) in de openbare map
eerst, dan in uw privéomgeving. Als u een openbaar bestand kopieert naar uw privé U-map
(dwz een map met de naam U op het hoogste niveau van uw pakket), zal deze de publieke map overschrijven
versie. Zodra het een lijst heeft met alle beschikbare eenheden, ontleedt het deze en extraheert het allemaal
de ?MAKE: regels om meer te weten te komen over de afhankelijkheden en de bekende shell-symbolen. Het ook
richt zich op de ?H:-lijnen om meer te leren over de C-symbolen en welke shell-symbolen moeten zijn
berekend om een ​​juiste waarde voor dat C-symbool te krijgen (dus we hebben een ander niveau van afhankelijkheden
hier).

Vervolgens worden de juiste bestandsnamen geëxtraheerd uit de MANIFEST.new-bestanden en a gezocht bestand is
gebouwd: dat bestand bevat alle C-symbolen en de shell-symbolen die nodig zijn voor dat pakket. Wij
scan eerst de C-type bestanden op C-symbolen en geef vervolgens de afhankelijkheden door aan hun
bijbehorende shell-symbolen (verzameld uit ?H: lijnen). Vervolgens worden .SH-bestanden gescand en uiteindelijk
alle schelpsymbolen zijn bekend.

Er wordt een tijdelijke Makefile gebouwd en metaconfig probeert dit maken alle shell-symbolen om te zien
welke commando's (vermeld op de tweede ?MAKE:-regel) worden uitgevoerd, en dus welke eenheden dat zijn
echt nodig. Optionele eenheden die anders niet nodig zijn, worden verwijderd en er komt een tweede Makefile
gegenereerd. Deze keer zijn we op de hoogte van alle eenheden en hun respectievelijke bestellingen, optioneel
eenheden zijn verwijderd en standaardwaarden zijn berekend voor hun shell-symbolen. De
Configure script kan vervolgens worden gegenereerd, samen met config_h.SH. Werden gedaan.

conventies
Om het hele proces goed te laten verlopen, moeten de juiste conventies worden gevolgd. Er is een geval
conventie voor eenheden en een naamgevingsconventie voor variabelen.

Bij alle eenheden moet de eerste letter in kleine letters staan, tenzij het speciale eenheden zijn. Door
speciaal bedoelen we dat ze niet echt nieuwe shell-variabelen definiëren die door de
gebruiker in zijn .SH-bestanden, maar eerder eenheden die scripts of shell-variabelen produceren die dat wel doen
intern gebruikt worden door de Configure script. Typische voorbeelden zijn de Init.U bestand dat is
de initialisatie van de hoofdvariabele, of Myread.U die de produceert mijnlees script bijna gebruikt
overal in Configure wanneer er een vraag aan de gebruiker wordt gesteld.

Niet-speciale eenheden worden vervolgens onderverdeeld in twee verschillende groepen: eenheden die variabelen definiëren
geassocieerd met een C-symbool en eenheden die hun eigen shell-variabelen definiëren. De eerste groep
is verder onderverdeeld in variabelen die verband houden met include-bestanden (hun naam begint met i_) en
variabelen gerelateerd aan andere definities (naam begint met d_). De tweede groep heeft
namen die voor zichzelf staan, bijvoorbeeld cc.U definieert de $ cc shell-variabele waarvan de waarde is
welke C-compiler moet worden gebruikt.

Speciale eenheden reserveren soms een vooraf gedefinieerde variabele voor zichzelf en retourneren 'resultaten'
in andere bekende variabelen. Bijvoorbeeld de mijnlees script geproduceerd door Myread.U
verwacht de prompt $ rp, het standaardantwoord in $dflt en plaatst het antwoord van de gebruiker erin $ ans.
Dit is niet gedocumenteerd op deze handleidingpagina: u moet naar het apparaat zelf gaan kijken
begrijpen welke variabelen worden gebruikt en hoe de eenheid moet worden gebruikt.

gebruik De Begrippenlijst
Het woordenlijstbestand wordt automatisch geproduceerd door de makeglans script, dat het
informatie uit ?S:, ?C: en ?MAKE: lijnen en formatteren ze opnieuw in alfabetische volgorde
gesorteerde woordenlijst. Het is belangrijk om de verklarende woordenlijst te lezen om te weten welke symbolen u bent
toegestaan ​​om te gebruiken. De verklarende woordenlijst vertelt u echter niet hoe u ze moet gebruiken. Meestal is dat zo
dat is jouw keuze.

Op een dag zul je waarschijnlijk je eigen eenheden schrijven en zul je er genoeg over weten metaconfig
om dit snel en efficiënt te doen. Vergeet echter nooit uw werk goed te documenteren
de ?S: en ?C: regels, anders kunnen andere mensen deze niet opnieuw gebruiken. Denk aan de
tijd waarin u alleen de woordenlijst en deze handleiding had om aan de slag te gaan.

Conclusie
Nu dat je het kent metaconfig basisprincipes, je zou de moeten lezen PRODUCTBESCHRIJVING sectie, dan
ga naar de REFERENTIE sectie voor meer informatie over alle bloederige details, zoals de toegestane
syntaxis voor eenheidscontroleregels (regels die beginnen met een '?') of de afzonderlijke MAKE-opdrachten
je mag gebruiken.

REFERENTIE

Deze sectie documenteert de interne werking van metaconfig, eigenlijk de syntaxis van de eenheid, de special
eenheden die u moet kennen en de hintbestanden.

Algemeen Eenheid Syntaxis
Een metaconfig-eenheid is verdeeld in twee afzonderlijke delen. Het kopgedeelte (regels beginnend
met '?') en een shell-sectie (code die moet worden opgenomen in de Configure script). Het is
Het is mogelijk om '?X:' commentaar overal binnen de eenheid toe te voegen, maar de andere '?' lijnen (ook
Dit betekent dat we onszelf en onze geliefden praktisch vergiftigen. onder controle te houden lijnen) hanteren een strikt bestelbeleid.

Als een controlelijn te lang is, is het mogelijk om gebruik te maken van een voortzetting door aan de finale te ontsnappen
new-line met een backslash en doorgaan op de volgende regel (die dan moet worden ingesprongen
door spaties of tabs).

Het volgende is een formele beschrijving van elk van de controlelijnen. Tenzij vermeld
anders is de volgorde van deze presentatie de volgorde die binnen de eenheid moet worden gebruikt.

?RCS: gratis tekst
Te gebruiken voor RCS-opmerkingen, bovenaan het toestel.

?X: elke tekst
Opmerkingen voor algemene doeleinden. Kan overal in het apparaat voorkomen, maar moet gerechtvaardigd blijven.
Voor RCS-opmerkingen kunt u het ?RCS: commentaarformulier gebruiken.

?MAKEN:symbool lijst: afhankelijkheid lijst [+optioneel]
Dit is de eerste afhankelijkheidslijn. De eerste symbool lijst moet alle symbolen vermelden
gebouwd door deze eenheid (dwz waarvan de waarde wordt berekend door het schilgedeelte van de eenheid).
Symbolen moeten door spaties worden gescheiden. Als een gedefinieerd symbool alleen voor intern gebruik is en
mag niet verschijnen in het gegenereerde bestand config.sh bestand, dan moet het worden voorafgegaan door een
'+' (niet te verwarren met optionele afhankelijkheden die hierna worden gedefinieerd). De seconde
een deel van de lijst (na de middelste ':') is de eenheidsafhankelijkheid. Het zou alles moeten vermelden
de benodigde speciale eenheden, evenals alle symbolen die door de schaal worden gebruikt
implementatie. Als een symbool wordt toegevoegd, maar de configuratiewaarde ervan niet kritisch is, wordt dit gedaan
kan worden voorafgegaan door een '+', in welk geval er sprake is van een voorwaardelijke afhankelijkheid: its
de overeenkomstige eenheid zal worden geladen als en slechts als dat symbool werkelijk bestaat
gewild; anders wordt de standaardwaarde gebruikt.

?MAKEN:tab commando
Er kunnen een of meer opdrachtregels volgen na de initiële afhankelijkheidsregels. Die
commando's worden uitgevoerd wanneer de eenheid ze wil laden Configure . Zien
de paragraaf over opdrachten maken voor meer informatie. Merk op dat de leidende tab
karakter is vereist vóór de commando.

?J:lay-out
Declareer een lay-outrichtlijn voor deze eenheid. Die richtlijn kan een van de snaren zijn
top, verzuim or bodem (hoofdlettergebruik doet er niet toe, de aanbevolen stijl is om ze uit te spellen
hoofdletter). Indien weggelaten, verzuim wordt verondersteld.

Deze richtlijn is alleen nodig als u een eenheid aan de boven- of onderkant wilt forceren
van de gegenereerde Configure script, voor zover de afhankelijkheden van de eenheden dit toelaten. Belangrijk
vragen kunnen dus in het begin geforceerd worden. Binnen dezelfde lay-outklasse, eenheden
worden alfabetisch gesorteerd met twee speciale gevallen voor d_* en i_* eenheden, geforceerd
respectievelijk bovenaan en onderaan hun klassen (maar deze zouden tot de
standaardklasse).

Je dwingt aan de top een eenheid waarvan de afhankelijkheden vereisen dat alle andere eenheden dat doen
eraan voorafgaat, bereik je niets interessants. Daarom zou die richtlijn er echt moeten zijn
worden gebruikt om de prioriteit te verhogen van sommige interactieve eenheden die niet van veel eenheden afhankelijk zijn
andere voor de gebruiker zichtbare symbolen, zoals padgerelateerde vragen.

?S:symbool_naam [(verouderd symbool lijst)]:
Introduceert een schelpsymbool. Op deze eerste regel wordt het symbool genoemd, optioneel gevolgd door a
lijst tussen haakjes en met het verouderde equivalent. Die zijn verouderd
symbolen worden opnieuw toegewezen aan de nieuwe symbool_naam indien de -o optie wordt gegeven
metaconfig.

?S:elke tekst, For Begrippenlijst
Eigenlijk een opmerking die het shell-symbool beschrijft, dat zal worden geëxtraheerd door makeglans
in het woordenlijstbestand.

?S:. Sluit het shell-symboolcommentaar.

?C:symbool_naam [~ alias] [(verouderd symbool lijst)]:
Introduceert een nieuw C-symbool. De alias naam is de naam waaronder het C-symbool zal verschijnen
gecontroleerd worden, dat wil zeggen als de alias symbool gewenst is, dan zal dat C-symbool worden geschreven
in de config_h.SH bestand. Meestal is de alias gewoon '%<' (staat voor de naam van de eenheid)
en er is ook een ?W:-lijn die een C-symbool toewijst aan de alias. Ook de relevante onderdelen
van de ?H:-regels worden expliciet beschermd door een '?%<'-voorwaarde. Zie het symbool
aliasingparagraaf voor meer details. De rest van de regel is optioneel
verouderd symbool lijst, waarin oude equivalenten voor het nieuwe worden vermeld symbool_naam.

?C:elke tekst, For Begrippenlijst en config_h.SH
Eigenlijk een opmerking die het C-symbool beschrijft, dat zal worden geëxtraheerd door makeglans
in het Woordenlijstbestand en door metaconfig in de config_h.SH bestand als het symbool is
wanted (of als de alias ervan gewenst is wanneer symboolaliasing wordt gebruikt).

?C:. Sluit de opmerking over het C-symbool.

?H:?symbool:config_h.SH spul
Dit is het algemene opnameverzoek in config_h.SH. De regel wordt alleen geschreven wanneer
de bewaking symbool is echt gewenst. Deze algemene vorm is nodig bij het C-symbool
er is gebruik gemaakt van aliasing. Anders, als u een van de andere "standaard"-formulieren gebruikt, wordt de
bewaking gebeurt automatisch door metaconfig zelf.

?H:#$d_var VAR "$var"
Definieert voorwaardelijk de VAR C-symbool in $var wanneer is ingesteld op 'bepalen'. Impliceert een
'?VAR:' bewakingstoestand, en metaconfig automatisch gekoppeld VAR naar zijn twee schillen
variabele afhankelijkheden (dwz beide $d_var en $var zal worden gemarkeerd als gezocht if VAR is
gebruikt in C-bronnen).

?H:#definieer VAR [optioneel tekst]
Definieert altijd de VAR C-symbool naar een bepaalde waarde. Impliceert een '?VAR:' bewakingstoestand.
Er wordt automatisch een shell-afhankelijkheid gemaakt van de eenheid zelf.

?H:#definieer VAR(x,y,z) $var
Definieert altijd de macro VAR de waarde zijn van de $var variabel. Het is aan de
eenheid te garanderen $var heeft een redelijke waarde. Een automatische afhankelijkheid tussen de C
macro VAR en de shell-variabele is vastgesteld, en de hele lijn wordt bewaakt door een
impliciet '?VAR:'.

?H:#$d_var VAR
Voorwaardelijk definieert VAR if $d_var ingesteld op 'bepalen'. Impliceert een '?VAR:' bewaken
voorwaarde. Er wordt een automatische shell-afhankelijkheid gegenereerd $d_war.

?H:#definieer VAR "$var"
Wijst een geconfigureerde waarde toe aan de VAR C-symbool. Impliceert een '?VAR:' voorwaarde garanderen.
Er wordt een automatische shell-afhankelijkheid gegenereerd om te koppelen VAR en $var.

?H:. Sluit de config_h.SH opnameverzoeken.

?M:C symbool: C afhankelijkheden
Introduceert magische definitie met betrekking tot het C-symbool, voor confmagic.h, en definieert de
bewakingssymbool voor de overige ?M: definities. Deze regel impliceert stilzwijgend
'?W:%<:C symbool', dwz dat de unit in Configure wordt geladen als het C-symbool verschijnt
binnen de C-bronnen, of er nu magie wordt gebruikt of niet. De C-afhankelijkheden zijn geactiveerd
wanneer magie wordt gebruikt, om hun definitie te forceren config_h.SH. Echter, als
magie is niet gebruikt, maar het C-symbool verschijnt in de bron zonder de benodigde C
afhankelijkheden, wordt u elke keer gewaarschuwd wanneer het Wanted-bestand wordt gebouwd, aangezien dit het geval kan zijn
een draagbaarheidsprobleem (en ook omdat de eenheid onvoorwaardelijk wordt geladen in
Configureer wanneer het C-symbool wordt gebruikt, ongeacht de andere ?C:-regels uit de
eenheid).

?M:cpp defs
Definieert de magische cpp-toewijzing die moet worden geïntroduceerd in confmagic.h wanneer het betreft
symbool wordt gebruikt. Er is een impliciete '?sym'bewaken waar sym is de symboolnaam
gedefinieerd door de leidende ?M:-lijn.

?M:. Sluit de confmagic.h opname verzoek.

?W:schelp symbool lijst:C symbool lijst
Verbindt het lot van de schelpsymbolen met dat van de C-symbolen: als een van de C
vermelde symbolen gewenst zijn, dan worden alle shell-symbolen gemarkeerd als gewenst. Handig om
forceer opname van een eenheid (shell-symbolenlijst ingesteld op '%<') wanneer de aanwezigheid van een of andere C
symbool wordt gedetecteerd. De lijst met schelpsymbolen kan leeg worden gelaten om van de zijkant te profiteren
effect van de locatie van het C-symbool binnen de ingebouwde pre-processor (symbool is gedefinieerd
voor die pre-processor als deze zich in de bron bevindt). Zoeken naar patronen met een spatie
daarin moet je de C-symbolen tussen eenvoudige aanhalingstekens citeren, zoals in 'struct
tijdzone'.

?V:alleen-lezen symbolen:lezen schrijven symbolen
Dit is een metaalint hint en mag alleen worden gebruikt in speciale eenheden die een granaat exporteren
variabelen. De variabelen vóór de middelste ':' worden alleen-lezen geëxporteerd (waarbij ze worden gewijzigd
zal een waarschuwing geven), terwijl andere symbolen vrijelijk kunnen worden gelezen en gewijzigd.

?F:bestanden aangemaakt
Deze regel heeft twee doelen: het is een metaalint hint, en ook een tijdelijke aanduiding voor
toekomst jmaken gebruik. Het moet drie soorten bestanden vermelden: de tijdelijke die zijn
gemaakt voor een toets, de privé UU-exemplaren gemaakt in de UU-directory voor later
inzage, en de openbare links in de hoofdmap van het pakket. Tijdelijk
bestanden moeten worden vermeld met een voorafgaande '!' karakter (betekent "nee! ze worden niet hergebruikt
later!"), moeten privé UU-bestanden worden voorafgegaan door een './' (wat betekent: om ze te gebruiken
./bestand, Niet alleen filet), en openbare namen moeten worden genoemd zoals ze zijn.

?T:schelp tijdelijke medewerkers
Nog een metaalint hint. Op deze regel worden alle shell-variabelen vermeld die als tijdelijke bestanden worden gebruikt
binnen het schaalgedeelte van deze eenheid.

?D:symbool='waarde'
Initialisatiewaarde voor symbolen die worden gebruikt als voorwaardelijke afhankelijkheden. Indien geen ?D: lijn is
gevonden, dan wordt in plaats daarvan een nulwaarde gebruikt. De metaalint programma zal u waarschuwen als een
symbool wordt minstens één keer gebruikt als een voorwaardelijke afhankelijkheid en heeft geen echte
?D: initialisatie. Het is een goede gewoonte om deze regels zelfs voor een nul toe te voegen
initialisatie omdat het de nadruk legt op het mogelijk optionele karakter van een symbool.

?O:elke Bericht u willen
Deze richtlijn geeft aan dat dit toestel als geheel verouderd is. Wanneer er gebruik van wordt gemaakt
van de symbolen wordt gemaakt (of indirect gebruik via afhankelijkheden), wordt het bericht uitgevoerd
het scherm (op stderr). U kunt één of meer regels plaatsen, in welk geval elke regel dat zal doen
op volgorde worden afgedrukt.

?LINT:metaalint hints
Zie de metaalint handleidingpagina voor een uitleg van de verschillende hints die kunnen zijn
gebruikt.

?IN HET:initialisatie code
De initialisatiecode die door deze regel wordt gespecificeerd, wordt bovenaan het bestand geladen
Configure script op voorwaarde dat de eenheid nodig is.

C Symbool aliasing
Soms is het niet mogelijk om erop te vertrouwen metaconfig's eigen standaardselectie voor config_h.SH
opmerkingen en C-symbooldefinitie. Dat is waar aliasing een rol speelt. Omdat het eerder is
lastig uit te leggen, we zullen een voorbeeld bestuderen om het onderliggende mechanisme te begrijpen.

De d_const.U-eenheid probeert te bepalen of uw C-compiler al dan niet op de hoogte is van de const
trefwoord. Als dit niet het geval is, willen we dat trefwoord opnieuw toewijzen aan een nulreeks, zodat de
programma compileren. Bovendien willen we de test automatisch activeren wanneer de const woord
is gebruikt.

Hier zijn de relevante delen van de d_const.U-eenheid:

?MAKE:d_const: cat cc ccflags Setvar
?MAKE: -kies voeg $@ % toe
?S:d_const:
?S: Deze variabele definieert voorwaardelijk het HASCONST-symbool, dat
?S: geeft aan het C-programma aan dat deze C-compiler op de hoogte is van de
?S: const-type.
?S:.
?C:HASCONST ~ %<:
?C: Dit symbool, indien gedefinieerd, geeft aan dat deze C-compiler hiervan op de hoogte is
?C: het const-type. Het is niet nodig om daadwerkelijk op dat symbool te testen
?C: binnen uw programma's. Alleen al het gebruik van het trefwoord "const" zal dat doen
?C: activeer de noodzakelijke tests.
?C:.
?H:?%<:#$d_const HASCONST /**/
?H:?%<:#ifndef HASCONST
?H:?%<:#define const
?H:?%<:#endif
?H:.
?W:%<:const
?LINT: stel d_const in
?LINT: bekende const
: controleer op const trefwoord
echo " "
echo 'Controleren of uw C-compiler op de hoogte is van "const"...' >&4
/bin/kat >const.c <<'EOCP'
hoofd()
{
const char *foo;
}
EOCP
if $cc -c $ccflags const.c >/dev/null 2>&1 ; Dan
val="$define"
echo "Ja, dat klopt."
anders
val="$undef"
echo "Nee, dat is niet zo."
fi
stel d_const in
eval $setvar

Als eerste zien we het gebruik van een ?W:-regel, die feitelijk zegt: "This unit is wanted when the
const trefwoord wordt gebruikt in een C-bestand.". Om voorwaardelijk opnieuw toe te wijzen const tot een nul
insnoeren configuratie.h, Ik heb ervoor gekozen om voorwaardelijk te definiëren HASCONST via $d_const.

Dit levert echter een probleem op, omdat de HASCONST symbool zal niet worden gebruikt in de
bronnen, alleen de const teken is. En de ?H: lijnbepalend HASCONST is impliciet
bewaakt door '?HASCONST'. Daarom moeten we de expliciete beperking '?%<' toevoegen om dit te kunnen vertellen
metaconfig waarin deze lijnen moeten worden opgenomen config_h.SH wanneer het symbool '%<' verschijnt
wordt gezocht (%< verwijst hier naar de naam van de eenheid d_const).

Dat is bijna perfect, want de ?W:-lijn zal willen d_const telkens als const wordt gebruikt, dan
de ?H:-lijnen worden opgenomen in de config_h.SH bestand. De leidende opmerking (?C:
lijnen) eraan vastgemaakt HASCONST wordt zelf ook bewaakt via HASCONST, dwz het heeft een impliciet
'?HASCONST'-beperking. Vandaar de behoefte aan aliasing de HASCONST symbool naar '%<'.

Het resterende deel van de eenheid (het schaalgedeelte) is heel eenvoudig. Het is eenvoudig
probeert een voorbeeld C-programma te compileren met behulp van de const trefwoord. Als het kan, dan zal het ook gebeuren
bepalen $d_const via de $setvar functie (gedefinieerd door de Setvar.U eenheid). Zie de paragraaf
over speciale eenheden voor meer details.

Merk commando's
Op de ?MAKE: commandoregel kunt u een shell-commando schrijven dat uitgevoerd moet worden zoals het is of a
special -kies commando dat gevangen zit metaconfig en ontleed om te zien wat zou moeten zijn
klaar. De leidende '-' is er alleen om te voorkomen maken mislukt wanneer de opdracht terugkeert
een status die niet nul is - het is niet echt nodig omdat we ' gebruikenmaken -n' om het op te lossen
afhankelijkheden, maar ik raad u aan om het te behouden voor het geval het in toekomstige versies verplicht wordt.
De syntaxis van de kiezen commando is:

-kies cmd $@ Doelbestand

WAAR $@ is de standaardmacro binnen Makefiles die staat voor het huidige doel (de naam
van de eenheid die wordt gebouwd, waarbij de laatste .U-extensie is verwijderd). De cmd onderdeel is de
daadwerkelijk metaconfig opdracht die moet worden uitgevoerd, en de Doelbestand is nog een andere parameter, waarvan
interpretatie hangt af van de cmd zelf. De laatste .U-extensie is ook gestript en
verwijst normaal gesproken naar een eenheidsbestand, tenzij het begint met './', in welk geval het naar één bestand verwijst
van de metaconfig controlebestanden in de '.MT directory.

De beschikbare commando's zijn:

toevoegen Voegt de Doelbestand naar Configure .

toevoegen.Config_sh
Vult dat deel van in Configure het produceren van de config.sh bestand. Alleen gebruikt
variabelen worden toegevoegd, voorwaardelijke variabelen (van voorwaardelijke afhankelijkheden) zijn dat wel
overgeslagen.

add.Null Voegt de sectie toe die alle gebruikte shell-variabelen initialiseert aan een lege tekenreeks.

c_h_weed Produceert de config_h.SH bestand. Alleen de noodzakelijke regels worden afgedrukt.

cm_h_weed Produceert de confmagic.h bestand. Alleen de noodzakelijke regels worden afgedrukt. Dit
commando is alleen ingeschakeld als de -M schakelaar wordt gegeven, of wanneer a confmagic.h filet
bestaat al.

close.Config_sh
Voegt het laatste 'EOT'-symbool toe aan een regel om het here-document te beëindigen
constructie produceren van de config.sh bestand.

prepend Plaatst de inhoud van het doel vóór de Doelbestand als dat bestand niet leeg is.

wiet Voegt de eenheid toe aan Configure zoals het toevoegen commando, maar voer enkele aanvullende tests uit
om de '?symbool' En '%symbool' regels uit de Doelbestand als het symbool
niet gewenst of voorwaardelijk gewenst is. De '%'-vorm wordt alleen intern gebruikt door
metaconfig terwijl hij zijn eigen .U-bestanden produceert in de '.MT' map.

veeg Hetzelfde als toevoegen echt, maar voert een extra macrovervanging uit. De
beschikbare macro's worden beschreven in de Hardwired Macro's paragraaf.

Als een kanttekening, metaconfig genereert een -cond opdracht intern om te gaan met voorwaardelijke
afhankelijkheden. U mag het niet zelf gebruiken, maar u zult het wel zien als u het scant
gegenereerde Makefile in de .MT directory.

Hardwired Macro's
De volgende macro's worden herkend door de vegen commando en vervangen vóór opname in
Configure :

Het basisrevisienummer van het pakket, afgeleid van .pakket.

De huidige datum.


Het e-mailadres van de beheerder van dit pakket, afgeleid van uw
.pakket.


De naam van het pakket, zoals afgeleid van uw .pakket bestand.


Het patchniveau van de metaconfig programma (verouderd ten gunste van ).


Het SVN-revisieniveau van het metaconfig programma.

Het versienummer van de metaconfig programma.

Deze macro's worden voornamelijk gebruikt om de metaconfig versie die een
bijzonder Configure script en voor welk pakket het is gedaan. Het e-mailadres van de
onderhouder is vastgelegd in de leidende instructies die Configure afdrukken bij het starten.

Recent metaconfig versies begrijpen een veel algemenere syntaxis van het formulier:

<$variabele>

die wordt vervangen tijdens het genereren van Configure door de waarde van variabele overgenomen van jouw
.pakket bestand. Uiteindelijk zal het oude vaste macroformaat verdwijnen, en <$baserev>
zal vervangen in alle geleverde eenheden.

special Eenheden
De volgende speciale eenheden worden gebruikt om code te ontbinden in factoren en een hoger niveau te bieden
functionaliteiten. Ze produceren ofwel een shellscript dat kan worden gesourced, ofwel een shell
variabele dat kan zijn eval'ed. Het doorgeven van parameters gebeurt ook via bekende variabelen
genoemd of anoniem zoals $1, $2, enz... (wat eenvoudig kan worden ingesteld via de shell reeks
exploitant). Wanneer Configure wordt uitgevoerd, het creëert en gaat in een UU directory, dus elke
geproduceerde script ligt daarin en interfereert niet met de bestanden uit uw pakket.

Hier volgen de speciale eenheden die u moet kennen, en de manier waarop u ze kunt gebruiken.

Cppsym.U
Deze eenheid produceert een shellscript genaamd Cppsym, die kan worden gebruikt om te bepalen
of een symbool in een lijst wordt gedefinieerd door de C-preprocessor of de C-compiler die u heeft
gespecificeerd. Het kan de status van elk symbool bepalen, hoewel de symbolen in
(attributenlijst) zijn gemakkelijker te bepalen.

Csym.U
Hiermee wordt de shell-variabele $csym ingesteld, die intern wordt gebruikt door Configure om te controleren of een
gegeven C-symbool is gedefinieerd of niet. Een typisch gebruik is:

symboolresultaat instellen [-fva] [vorige]
evalueer $csym

Dat zal de resultaat variabele naar 'true' als de functie [-f], variabele [-v] of
array [-a] is gedefinieerd, anders 'false'. Als er een eerdere waarde is opgegeven en de -r
schakelaar werd geleverd Configure (Zie de Configure Opties paragraaf), en dan dat
waarde wordt hergebruikt zonder vragen te stellen.

De manier waarop deze berekening wordt uitgevoerd, hangt af van het antwoord dat de gebruiker op de vraag geeft
Configure zal vragen of het een nm extractie of niet. Als de
extractie is uitgevoerd, bladert het apparaat eenvoudigweg door de symbolenlijst
het voert een compile-link-test uit, tenzij -r werd gegeven om de eerder berekende te hergebruiken
waarde natuurlijk...

Einde.U
Door dit apparaat naar uw privé te kopiëren U directory en het toevoegen van afhankelijkheden aan de
?MAKE: regel, kun je forceren dat een bepaalde eenheid erin wordt geladen Configure ook als dat niet zo is
anders gewenst. Sommige eenheden kunnen alleen worden gedwongen Configure op die manier.

Filex.U
Deze eenheid produceert een shellscript filex waarmee de bestandsnamen worden uitgevouwen, beginnend met
tildes. Een typisch gebruik is:

exp_name=`./filexp $naam`

om de uitgebreide bestandsnaam toe te wijzen exp_naam.

Vindhdr.U
Dit apparaat produceert een vindhdr script dat wordt gebruikt om de headerbestanden te lokaliseren
$usrinc of andere vreemdere plaatsen die cpp-mogelijkheden gebruiken. Het script krijgt een
neem de bestandsbasisnaam op, zoals 'stdio.h' of 'sys/file.h' en retourneert het volledige pad van
het inlcude-bestand en een nulstatus indien gevonden, of een lege string en een niet-nulstatus
als het bestand niet kon worden gevonden.

Getfile.U
Deze eenheid produceert een stukje shell-code die moet worden opgehaald om een ​​bestand te verkrijgen
naam en voer een aantal gezondheidschecks uit. Optioneel wordt een ~name-uitbreiding uitgevoerd.

Om dit apparaat te gebruiken, $ rp en $dflt moet de vraag en het standaardantwoord bevatten, welke
wordt in de huidige vorm doorgegeven aan de mijnlees script (zie binnenkort Myread.U). De $fn
variabele bestuurt de bewerking en het resultaat wordt teruggestuurd naar $ ans.

Om een ​​bestand of map te vinden, typt u 'f' of 'd' f~/. Als er een '~' verschijnt, dan ~naam
vervanging is toegestaan. Als er een '/' verschijnt, worden alleen absolute padnamen geaccepteerd en
~naamvervangingen worden altijd uitgebreid voordat ze terugkeren. Als '+' is opgegeven,
bestaanscontroles worden overgeslagen. Als 'n' binnenin verschijnt $fn, dan mag de gebruiker dat doen
antwoord 'geen'.

Tenzij u om portabiliteit hebt gevraagd, vindt vervanging van de ~naam doorgaans plaats wanneer daarom wordt gevraagd.
Er zijn echter momenten waarop u de draagbaarheid wilt omzeilen en de
vervanging. U kunt hiervoor de letter 'e' (uitvouwen) gebruiken.

Als het speciale 'l' (locate) type wordt gebruikt, dan wordt de $fn variabele moet eindigen met een ':',
gevolgd door een bestandsbasisnaam. Als het antwoord een map is, zal de bestandsbasisnaam dat zijn
toegevoegd vóór het testen op het bestaan ​​van bestanden. Dit is handig bij vragen in locatiestijl
soortgelijk:

dflt='~nieuws/lib'
: het is niet nodig om 'd' of 'f' op te geven als 'l' wordt gebruikt
fn='l~:actief'
rp='Waar is het actieve bestand?'
. ./getbestand
actief="$ans"

Bovendien kan de letter 'p' (pad) worden gebruikt in combinatie met 'l' om te vertellen
krijgbestand dat een antwoord zonder '/' erin geaccepteerd moet worden, ervan uitgaande dat dit wel het geval is
zich in ieders PATH bevinden op het moment dat deze waarde nodig is.

Ook handig is de mogelijkheid om een ​​lijst met antwoorden op te geven die geaccepteerd moeten worden
woordelijk, waarbij alle controles worden omzeild. Deze lijst moet tussen haakjes en items staan
moet door komma's gescheiden zijn, zonder tussenliggende spaties. Vergeet niet de
resulterende tekenreeks sinds haakjes zijn betekenisvol voor de shell. Bijvoorbeeld:

dflt='/bin/install'
fn='/fe~(installeren,./installeren)'
rp='Welk installatieprogramma gebruiken?'
. ./getbestand
install="$ans"

zou de gebruiker alleen volledig gekwalificeerde paden laten specificeren die verwijzen naar bestaande bestanden,
maar laat nog steeds de speciale "install" en "./install" antwoorden toe zoals ze zijn (ervan uitgaande dat
Natuurlijk zal er iets met hen gebeuren, vooral later in de keten, aangezien zij dat wel doen
niet in overeenstemming met het algemeen verwachte kader).

Als het antwoord op de vraag 'geen' is, worden de bestaanscontroles overgeslagen en
de lege string wordt geretourneerd. Merk op dat sindsdien krijgbestand gesprekken mijnlees intern, allemaal
de functies die beschikbaar zijn bij mijnlees hier solliciteren.

Als een volledig uitgebreide waarde nodig is (bijvoorbeeld in een Makefile), kunt u gebruik maken van
de $ ansexp variabele die altijd goed is ingesteld door krijgbestand als de uitgebreide
versie $ ans. Natuurlijk wordt ~name niet uitgebreid als je dat niet hebt toegestaan ​​in het
eerste plaats in de $fn variabel.

Inhdr.U
Deze eenheid produceert de $inhdr shell-variabele, intern gebruikt door Configure om te controleren
of er een set headers bestaat of niet. Een typisch gebruik is:

set koptekst i_kop [ koptekst2 i_kop2 ... ]
eval $inhdr

Er wordt dan een bericht afgedrukt waarin staat of de header is gevonden of niet, en de
ik_kop dienovereenkomstig variabel. Als er meer dan één header is opgegeven en de eerste
header niet wordt gevonden, proberen we de volgende, totdat de lijst leeg is of er een wordt gevonden.

Inlibc.U
Deze eenheid produceert de $inlibc shell-variabele, intern gebruikt door Configure om te controleren
of een bepaalde C-functie is gedefinieerd of niet. Een typisch gebruik is:

stel functie d_func in
eval $inlibc

Er wordt dan een bericht afgedrukt waarin staat of de functie is gevonden of niet en is ingesteld
$d_functie overeenkomstig. Intern werd gebruik gemaakt van de $csym routine.

Loc.U
Deze belangrijke eenheid produceert een shellscript loc waarmee je kunt achterhalen waar
in een lijst met mappen ligt een bepaald bestand. Het eerste argument specificeert het bestand waarnaar moet worden verwezen
worden gelokaliseerd, is het tweede argument wat er zal worden geretourneerd als de zoekopdracht mislukt, en de
overige argumenten zijn een lijst met mappen waarin het bestand moet worden doorzocht. Voor
voorbeeld:

dflt=`./loc sendmail.cf X / Usr / lib /var/lib/sendmail / lib`

zou zetten $dflt naar X als Nee sendmail.cf bestand gevonden onder de vermelde mappen,
of zoiets /usr/lib/sendmail.cf op sommige systemen. Zie ook Getfile.U.

MailAuteur.U
Dit apparaat moet worden opgenomen in de ?MAKE:-lijn van uw eigen particuliere End.U om te maken
het erin Configure . Het biedt de gebruiker de mogelijkheid om zich optioneel bij de auteur te registreren
een melding krijgen wanneer er nieuwe patches arriveren of deze automatisch ontvangen wanneer ze worden uitgegeven.
Je moet installeren postbezorger om dit te doen (tenminste versie 3.0).

MailList.U
Dit apparaat moet worden opgenomen in de ?MAKE:-lijn van uw eigen particuliere End.U om te maken
het erin Configure . Het biedt de gebruiker de mogelijkheid om zich aan of af te melden voor een mailinglijst
waar discussies over het pakket plaatsvinden. Je moet rennen inpakken
en beantwoord de mailinglijstgerelateerde vragen om de juiste variabelen in uw
.pakket voordat deze eenheid operationeel kan worden.

Mijninit.U
Kopieer dit apparaat naar uw privé U directory om uw eigen standaardwaarden aan sommige toe te voegen
interne variabelen. Deze eenheid wordt in geladen Configure immers de standaard
initialisaties zijn uitgevoerd.

Myread.U
Deze eenheid produceert de mijnlees shell-script dat moet worden opgehaald om een
lezen. Het maakt shell-escapes, standaardtoewijzing en parameterevaluatie mogelijk, zoals
gedocumenteerd in de Instruct.U-eenheid. Het maakt ook een dynamische instelling van de -d keuze,
die zal worden gebruikt voor de rest van de scriptuitvoering.

Om dit apparaat te gebruiken, $ rp moet de vraag vasthouden en $dflt moet de standaard bevatten
antwoord. De vraag wordt door het script zelf afgedrukt en het resultaat wordt geretourneerd
in de $ ans variabel.

Hier is een typisch gebruik:

dflt='j'
rp='Vraag?'
. ./mijnlezen
waarde="$ans"

Zie het apparaat zelf voor meer informatie.

Oudeconfig.U
Deze eenheid moet deel uitmaken van uw afhankelijkheidsregel ?MAKE: wanneer sommige van uw eenheden het proberen
om een ​​oude symboolwaarde opnieuw te gebruiken. Deze eenheid is verantwoordelijk voor het verkrijgen van de oude antwoorden
oppompen van config.sh of het geven van nuttige tips bij het draaien op een bepaald platform voor de
eerste keer. Zie de Configure Hints paragraaf voor meer informatie over hints.

Voorvoegsel.U
Het doel van dit apparaat is om veranderingen in de installatievoorvoegselmap te detecteren
automatisch geschikte standaardwaarden opnieuw berekenen op basis van eerdere antwoorden. Het berust op de
waarde van de $oudvoorvoegsel variabele die de vorige prefixmap bevat wanneer deze wordt gebruikt
gewijzigd en is verder leeg. Als het voorvoegsel bijvoorbeeld is gewijzigd van / opt naar
/ Usr / local, dan wordt de vorige binaire installatiemap gewijzigd van
/opt/bin naar / Usr / local / bin, of zal onveranderd blijven als het bijvoorbeeld / bin.

Je moet bellen reeks alvorens een eval on $voorvoegselZoals:

set dflt var [dir]
eval $voorvoegsel

die zou instellen $dflt naar $var or $voorvoegsel/dir afhankelijk van of het voorvoegsel bleef bestaan
hetzelfde of niet. Als dir is de string geen, een enkele spatiewaarde in $dflt wordt bewaard als-
is, zelfs als het voorvoegsel verandert. Als dir wordt dan weggelaten $dflt is ingesteld op leeg
string als het voorvoegsel is gewijzigd, naar $var anders.

Voorvoegselup.U
De bedoeling van dit apparaat is vergelijkbaar met die van Prefixit.U, dwz het helpt bij het oplossen van het probleem
standaardtekenreeks om wijzigingen in het voorvoegsel mogelijk te maken. Echter, de shell-variabele $voorvoegselup,
wanneer geëvalueerd, zal het alleen ~name-uitbreidingen herstellen, moet een voorvoegsel een dergelijke escape gebruiken
mechanisme. Gebruik het als:

stel dflt in
eval $prefixup

voordat u via vraagt krijgbestand bijvoorbeeld. Als het voorvoegsel geen gebruik maakt van ~name
uitbreiding, dan is het bovenstaande een no-op voor de y variabel, natuurlijk.

Typedef.U
Deze eenheid produceert de $typedef shell-variabele, intern gebruikt door Configure om te controleren
of er een typedef bestaat of niet. Een typisch gebruik is:

set typedef val_t standaard [inclusief]
eval $typedef

Hiermee wordt de variabele ingesteld val_t de waarde van verzuim als de typedef niet is gevonden
onder de genoemde bestanden zijn onder meer bestanden, of naar typedef indien gevonden. Als er geen include-bestanden zijn
opgegeven, kijkt het apparaat naar binnen alleen. Als u enkele inclusief opgeeft, alleen
daar wordt naar gekeken.

Unix.U
Het doel van dit onderdeel is het definiëren van enkele van de meest voorkomende UNIX-ismen via variabelen
die kan worden gewijzigd vanaf de opdrachtregel of via de juiste hintbestanden. In het bijzonder,
$_exe, $_o en $_a spelen zich af. Alle eenheden moeten verwijzen naar $_o en niet om .o direct.
De '.' maakt deel uit van deze variabelen.

Setvar.U
Deze eenheid produceert de variabele, die intern wordt gebruikt door Configure om een
bepalen/undef-waarde aan een bepaald symbool toewijzen, waarbij een waarschuwing wordt gegeven wanneer dit plotseling verandert
van een eerdere waarde. Bijvoorbeeld:

val="$define"
stel d_variabele in
eval $setvar

Als de vorige $d_variabele waarde was niet nul en $val is anders, een "whoa"
waarschuwing wordt afgegeven.

Whoa.U
Deze eenheid produceert de ho script, dat een waarschuwing geeft wanneer de waarde in variabele
wiens naam is $var is niet hetzelfde als de oude, vorige waarde die erin werd vastgehouden $ was. Bij
terug te keren, $td en $tu de juiste waarde behouden bepalen or ondefinieerbaar de variabele. Zien
voorbeelden in Inlibc.U.

ingebouwde Pre-processor
Elke eenheid moet worden opgenomen Configure wordt uitgevoerd via een ingebouwde pre-processor. Pre-
processorinstructies worden geïntroduceerd door het teken '@' ('#' is het shell-commentaar
karakter). Het functioneert slechts zoals de C-pre-processor, maar maakt shell en perl mogelijk
ontsnapt. Dit zijn de beschikbare functies:

@indien uitdrukking
If uitdrukking waar is, ga door met het laden van code tot @end, @elsif of @else.

@elsif uitdrukking
Alternatieve keuze. Als uitdrukking is waar, ga door met het laden van code tot @end,
nog een @elsif of @else.

@else Standaardcode die moet worden geladen als de @if uitdrukking was vals en geen van de
optioneel @elsif komt overeen. Laden tot @end.

@end Sluit de voorwaardelijke laadinstructie geopend door @if.

@definiëren symbool
Vertelt de pre-processor dat symbool wordt vanaf nu bepaald.

de voorwaardelijke uitdrukking kan symboolnamen bevatten (waarde is waar als symbool gewenst is of
gedefinieerd via @definiëren of shell/perl-ontsnappingen. Die atomen kunnen worden gecombineerd met behulp van de
traditionele Booleaanse operatoren '!' voor ontkenning, '&&' voor logische en, en '||' voor logisch
of.

Tekst tussen enkele haakjes is een shell-test, terwijl tekst tussen dubbele haakjes dat wel is
een perl-test. Namelijk de uitdrukkingen:

{ schelp tekst }
{{ perl tekst }}

worden vertaald in:

if schelp tekst >/dev/null 2>&1; dan uitgang 0; anders uitgang 1; fi
if (perl tekst) {afrit 0;} anders {afrit 1;}

en de afsluitstatus wordt op de standaardmanier gebruikt om een ​​Booleaanse waarde te krijgen, dwz 0 is waar en
al het andere is vals. Merk op dat alleen eenvoudige voorwaarden kunnen worden uitgedrukt in perl, until
er kan een aantal complexe code in worden geladen metaconfig en geëxecuteerd.

De ingebouwde pre-processor kan worden gebruikt om sommige units fijn af te stemmen (zie d_gethnaam.U voor een
complex voorbeeld), afhankelijk van de symbolen die daadwerkelijk door het programma of de bestanden worden gebruikt
aanwezig in de distributie. Bijvoorbeeld de Oudeconfig.U gebruikt een test als:

@if {test -d ../hints}

en Configure zal alleen hint-afhankelijke code bevatten als er een is hints map in de
de map op het hoogste niveau van het pakket. Houd er rekening mee dat tests worden uitgevoerd vanuit de '.MT' map,
vandaar de benodigde '../' in de test.

De pre-processor kan ook worden gebruikt om te voorkomen dat nutteloze code wordt geplaatst terwijl een symbool dat niet is
bepaald. Eenheden die meer dan één symbool definiëren, kunnen op die manier worden beschermd (aangezien de eenheid
als geheel geladen) door symboolafhankelijke code te verzamelen binnen een @if/@end-paar. Voor
voorbeeld:

@if I_TIME || I_SYS_TIME || I_SYS_TIME_KERNEL
need_time_h='waar'
@anders
need_time_h='false'
@einde

zal testen of de broncode enig gebruik maakt van een van de drie symbolen die bepalend zijn
de tijd.h or sys/tijd.u opname en definieer het shell-symbool dienovereenkomstig. Dat geeft
Configure een feedback over wat de bronnen nodig hebben en vermijd het nadeel van het repareren
bevroren eenheden.

Via de '?W:' lijnen kun je interessante combinaties krijgen. Bijvoorbeeld de i_time.U eenheid
moet weten of de C-bronnen enig gebruik maken van de struct tijdzone type. Daarom,
de lijn:

?W::tijdzone

wordt gebruikt vanwege het neveneffect van het definiëren van het symbool tijdzone voor de preprocessor. De
eenheidscode kan dan zeggen:

@if tijdzone
voor s_timezone in '-DS_TIMEZONE' ''; Doen
@anders
s_timezone=''
@einde

... code met s_timezone ...

@if tijdzone
gedaan
@einde

en zorg voor een extra lus die twee opeenvolgende waarden probeert voor de s_tijdzone variabel, maar alleen
indien nodig.

Verouderd Symbolen
Verouderde symbolen worden bewaard om de overgang naar oudere symbolen te vergemakkelijken metaconfig eenheden. Tenzij
de -o schakelaar wordt doorgegeven metaconfig ze zullen worden genegeerd. Echter, een Verouderd bestand zal
worden gegenereerd, waarbij u wordt verteld welke bestanden gebruik maken van deze verouderde symbolen en welke
zijn de nieuwe symbolen die moeten worden gebruikt.

De levensduur voor verouderde symbolen is één volledige revisie, dat wil zeggen dat ze worden verwijderd wanneer de
volgende basisrevisie wordt uitgegeven (patchupgrades tellen uiteraard niet mee). Daarom is het
het is verstandig om uw bronnen te vertalen en de nieuwe symbolen zo snel mogelijk te gaan gebruiken.

Configure Hints
Het kan gebeuren dat de interne configuratielogica de verkeerde keuzes maakt. Voor
Op een bepaald platform kan bijvoorbeeld de vvork() systeemoproep is aanwezig maar kapot, en dat zou ook moeten gebeuren
niet worden gebruikt. Het is niet mogelijk om die kennis in de eenheden zelf op te nemen, omdat
dat kan een tijdelijk probleem zijn dat de leverancier uiteindelijk zal oplossen, of iets dergelijks
werd geïntroduceerd door een nieuwe OS-upgrade.

Hoe dan ook, voor al die kleine problemen die te systeemspecifiek zijn, metaconfig
biedt ondersteuning voor hintbestanden. Om het te gebruiken, moet u een hints map in de
de map op het hoogste niveau van het pakket, zodat u deze bij de hand hebt wanneer u het uitvoert metaconfig. Dat laadt de
hint-gerelateerd deel uit Oudeconfig.U.

Vanaf dat moment kunt u enkele shell-variabelen vooraf instellen Configure gebruikt in een besturingssysteemspecifiek
.sh-bestand. Er zit code in Oudeconfig.U dat probeert te raden welke hintbestanden nodig zijn
het berekenen van een standaardnaam op basis van de naam van het systeembesturingssysteem, de kernelnaam en de release
nummer, etc... Omdat deze informatie waarschijnlijk snel zal veranderen, documenteer ik dit niet
hier. Je moet de code reverse-engineeren Oudeconfig.U.

Wanneer u uw pakket voor het eerst vrijgeeft, moet de map met hintsbestanden leeg zijn. Als de
gebruikers van uw pakket klagen dat ze er problemen mee hebben Configure standaard op a
bepaald systeem, moet je kijken of dit een platformspecifiek probleem is of een
algemene één. In het eerste geval is het tijd om een ​​nieuw hintbestand te introduceren, terwijl in het
laatstgenoemde moet de overeenkomstige eenheid worden herzien.

Het is bijvoorbeeld bekend dat SGI-systemen een defect hebben vvork() systeemoproep, vanaf nu
schrijven. En de bijbehorende hintbestandsnaam is sgi.sh. U hoeft dus alleen maar te creëren
a hints/sgi.sh bestand waarin u schrijft:

d_vfork="$define"

die altijd opnieuw zal worden toegewezen vvork on vork (Zie d_vfork.U). Bij gebruik op SGI-systemen voor de
eerste keer, Configure zal detecteren dat er een hints/sgi.sh bestand, en daar zijn we mee bezig
een IRIX-machine (de kernelnaam is vaak /irix), daarom zal deze voorstellen sgi een
mogelijke aanwijzing. Als de gebruiker het accepteert, en aangezien de $d_vvork waarde wordt gewijzigd via de
$setvar bel, een ho! wordt uitgezonden om te waarschuwen dat we op het punt staan ​​de waarde te overschrijven
berekend door Configure .

Let op: u hoeft niets op te geven allen de bekende hints Oudeconfig.U. Als er een hintbestand is
ontbreekt, zal het niet als mogelijke keuze worden voorgesteld. De heuristische tests zijn uitgevoerd om te berekenen
de mogelijke hintkandidaten zijn schilferig. Als u nieuwe waarden of andere tests heeft, alstublieft
Verzend ze naar mij...

Dwingend Keuzes
Als u een configuratie.over bestand in de map op het hoogste niveau, Configure zal je vragen of je
wilt laden om de standaardwaarden te overschrijven. Dit gebeurt voorafgaand aan het maken van de
config.sh bestand, dus het geeft je de kans om de waarden die daarin zijn opgeslagen te patchen.

Dit verschilt van de hintsbenadering doordat het een lokaal bestand is dat de gebruiker is
vrij om te creëren voor eigen gebruik. U dient zo’n bestand niet zelf aan te leveren, maar laat de
gebruiker op de hoogte zijn van deze mogelijkheid.

Configure Opties
De Configure script kan worden aangeroepen met enkele opties die op de opdrachtregel zijn opgegeven, to
zijn gedrag enigszins aanpassen. Dit zijn de toegestane opties:

-d Gebruik standaardwaarden voor alle antwoorden.

-e Ga verder zonder vragen te stellen voorbij de productie van config.sh.

-f filet Gebruik het opgegeven bestand als standaardconfiguratie. Als deze schakelaar niet wordt gebruikt,
waaruit de configuratie is overgenomen config.sh, indien aanwezig.

-h Help-bericht afdrukken en afsluiten.

-r Hergebruik indien mogelijk de waarde van C-symbolen. Dit zal de kostbare kosten overslaan nm symbool
extractie. Bij eerste gebruik (zonder eerder configuratiebestand),
Configure zal proberen een klein programma te compileren en te koppelen om meer te weten te komen
de aanwezigheid van een symbool, of de afwezigheid daarvan.

-s Stille modus. Alleen tekenreeksen die zijn afgedrukt op bestandsdescriptor #4 zijn zichtbaar in het
scherm (dat zijn de belangrijke berichten). Volledig uitschakelen is niet mogelijk
elke uitvoer, maar u kunt 'Configure -ders > / dev / null 2> & 1'vol hebben
batchrun zonder uitvoer en zonder gebruikersinteractie.

-D symbool=waarde
Vooraf gedefinieerd symbool het gespecificeerde te dragen waarde. Het is ook mogelijk om '-D
symbool', waarbij de standaardwaarde 'define' wordt gebruikt.

-E Stop aan het einde van de configuratievragen, nadat u een
config.sh. Dit zal geen enkele 'maken afhangen' of .SH-bestanden uitpakken.

-K Deskundige gebruiker. Wanneer u deze optie gebruikt, weet u wat u doet en
Daarom, de config.sh Het dossier wordt altijd behandeld zoals het bedoeld is
hergebruikt, ook al is het mogelijk gegenereerd op een buitenaards systeem. Het ook
voorkomt afbreken wanneer Configure detecteert een onbruikbare C-compiler of een verkeerde set
van C-vlaggen. Andere snelkoppelingen kunnen ook door deze optie worden ingeschakeld in het
toekomst. Deze optie is gedocumenteerd in de Configure gebruiksbericht, om ons eraan te herinneren
over het bestaan ​​ervan, maar de gegeven beschrijving is hopelijk cryptisch genoeg.
:-)

-O Waarden toegestaan ​​die zijn opgegeven via a -D or -U om instellingen van alle geladen instellingen te overschrijven
configuratiebestand. Dit is niet het standaardgedrag, aangezien de overheersende wil
niet worden doorgegeven aan variabelen die zijn afgeleid van de variabelen die u momenteel wijzigt.
Uiteraard zonder -O, wordt de instelling alleen gedaan als er geen configuratiebestand is
geladen, wat veilig is omdat afgeleide variabelen nog niet zijn berekend...

-S Voer variabelevervanging uit op alle .SH-bestanden. Je kunt het combineren met de
-f schakel over om elke gewenste configuratie door te geven.

-U symbool=
Voorinstellingen symbool een lege waarde dragen. Het is ook mogelijk om '-U symbool'
die zal instellen symbool naar 'ondef'.

-V Druk het versienummer van het metaconfig die dit heeft gegenereerd Configure script
en verlaat.

Hardlopen Milieu
Bij het starten, Configure creëert een lokaal UU map en wordt van daaruit uitgevoerd. De map
wordt verwijderd wanneer Configure eindigt, maar dit betekent dat u het script moet uitvoeren vanaf een plaats waar
u kunt schrijven, dwz niet vanuit een alleen-lezen bestandssysteem.

Je kan lopen Configure op afstand, zoals in:

../pakket/Configureren

om bronnen te configureren die niet lokaal aanwezig zijn. Alle gegenereerde bestanden worden erin geplaatst
de map van waaruit u het script uitvoert. Deze magie wordt bereikt dankzij de src.U
eenheid, die de instelling regelt $src en $rsrc variabelen om naar de pakketbronnen te verwijzen. Dat
pad is vol of relatief, afhankelijk van of Configure werd aangeroepen via een volledige of
relatief pad.

Van binnen de UU submap die u kunt gebruiken $rsrc om toegang te krijgen tot de bronbestanden (units
verwijzend naar bronbestanden linkhints zullen altijd dit mechanisme gebruiken en niet uitgaan van de
bestand aanwezig is in de bovenliggende map). Alle Makefiles moeten de variabele $src gebruiken
als verwijzing naar de bronnen bovenaan de build-directory (waar Configure wordt uitgevoerd),
rechtstreeks of via een VPATH-instelling.

Tijdens het hardlopen Configure op afstand worden de .SH-bestanden uitgepakt in de build-directory, niet
in de bronboom. Het vereist echter een soort van maken ondersteuning om te kunnen compileren
dingen in een build-directory terwijl de bronnen elders liggen.

gebruik Magic herdefinities
Door gebruik te maken van de -M overschakelen, kunnen sommige magische hertoewijzingen plaatsvinden binnen een confmagic.h
bestand. Dat bestand moet daarna worden toegevoegd configuratie.h, natuurlijk, maar ook tenslotte
andere nodig zijn onder meer bestanden. Namelijk:

#include "config.h"
...
... anders insluitsels ...
...
#include "confmagic.h"

Typisch, confmagic.h zal proberen opnieuw in kaart te brengen bkopie() on memcpy() als Nee bkopie() is
lokaal beschikbaar, of transformeren vvork in vork wanneer dat nodig is, waardoor het nutteloos wordt
zorgen maken over de HAS_VFORK symbool.

Deze configuratiemagie wordt gedocumenteerd in het bestand Woordenlijst.

Eenheid Sjablonen
Er is een set eenheidsjablonen in de metaconfig bronmap, die bedoeld zijn om
worden gebruikt door een (nog niet geschreven) programma om snel nieuwe eenheden voor verschillende soorten te produceren
situaties. Geen documentatie voor dit onvoltooide project, maar ik dacht dat ik het toch zou vermelden
op de handleidingpagina voor het geval u het zelf wilt doen en het vervolgens wilt bijdragen...

AUTEURS

Larry Muur[e-mail beveiligd]> voor versie 2.0.
Harlan Stenn[e-mail beveiligd]> voor belangrijke unituitbreidingen.
Rafaël Manfredi[e-mail beveiligd]>.
Vele andere bijdragers voor de metaconfig eenheden. Zie het kredietbestand voor een lijst.

Gebruik metaconfig online met behulp van onworks.net-services