metaconfig - Online sa Cloud

PROGRAMA:

NAME

metaconfig - isang generator ng I-configure ang script

SINOPSIS

metaconfig [ -dhkmostvwGMV ] [ -L dir ]

DESCRIPTION

Metaconfig ay isang program na bumubuo ng mga script ng I-configure. Kung hindi mo alam kung ano ang a
I-configure ang script ay, mangyaring lumaktaw sa PAGTUTURO seksyon ng manwal na pahinang ito. Kung gusto mo
isang buong (pormal) na paglalarawan ng paraan ng paggamit metaconfig at ang mga unit nito, pakitingnan ang
Sanggunian seksyon. Ang sumusunod ay isang mabilis na pagpapakilala at sanggunian para sa mga may kaalaman
gumagamit.

Metaconfig gumagana mula sa set ng yunit na tumutukoy sa lahat ng nalalaman ng metaconfig
maaaring dalhin. Ang bawat unit ay self-contained, at hindi kailangang irehistro kahit saan
maliban sa pagsasama sa alinman sa pampublikong direktoryo ng U o sa iyong pribadong direktoryo ng U. Kung
ang dist package (kung saan ang metaconfig ay isang bahagi) ay naka-install sa LIB, pagkatapos ay ang pampublikong U
ang direktoryo ay LIB/dist/mcon/U. Sa makinang ito, ang direktoryo ng LIB ay /usr/share/dist. Iyong
Ang pribadong direktoryo ng U, kung mayroon ka, ay nasa pinakamataas na antas ng direktoryo ng iyong package.
Bago ka makatakbo metaconfig kailangan mong gawin ang ilang bagay:

· Gumawa ng .package file sa nangungunang antas ng direktoryo ng package sa pamamagitan ng pagpapatakbo packinit.
Tatanungin ka ng program na ito tungkol sa iyong package at tandaan kung ano ang sasabihin mo dito
lahat ng dist program ay maaaring maging matalino.

· Kumonsulta sa Glossary (sa LIB/dist/mcon) at isulat ang iyong mga shell script at C program
sa mga tuntunin ng mga simbolo na alam ng metaconfig kung paano tukuyin. Hindi mo kailangang sabihin
metaconfig kung aling mga simbolo ang ginamit mo, dahil malalaman iyon ng metaconfig para sa iyo.

· Bumuo ng anumang .SH script na kailangan para magsulat ng Makefiles o shell script na depende
sa mga halaga na tinukoy ng Configure. May programang tinatawag makeSH na makakatulong sa iyo
i-convert ang isang plain script sa isang script.SH template; kailangan pa rin ang ilang pag-edit
isinagawa sa nagresultang .SH file upang ilipat ang bahagi ng variable na configuration sa
tuktok na bahagi ng script (tingnan ang mga inline na komento na nabuo ni makeSH sa loob ng iyong .SH
file)

· Gumawa ng MANIFEST.new na file sa iyong nangungunang antas na direktoryo na naglilista ng lahat ng mga file sa
iyong pakete. Mananatiling pribado ang file na ito at hindi magiging bahagi ng final
pamamahagi. (Bilang kaginhawahan, ang MANIFEST file ay gagamitin ng metaconfig if
wala pang MANIFEST.bagong file.) Ang filename dapat ang unang field sa bawat isa
linya. Pagkatapos ng ilang whitespace maaari kang magdagdag ng maikling komento na naglalarawan sa iyong file. Tanging
ang mga source file ay dapat na nakalista doon. Ang espesyal na file patchlevel.h (na
pinangangasiwaan at pinananatili ng mga tool sa pag-aayos -- tingnan tapik(1)) ay dapat na bahagi ng
MANIFEST.new file, ngunit maaaring tahimik na hindi pinansin ng ilang tool. Bilang tuntunin ng hinlalaki,
ang mga file lamang na pinananatili ng RCS ang dapat na nakalista doon, ang patchlevel.h file being
isang mahalagang eksepsiyon.

· Opsyonal, maaaring naisin mong lumikha ng MANIFEST file, na magiging isang na-export na bersyon
ng iyong MANIFEST.bago. Ang file na iyon ay dapat gawing bahagi ng paglabas, ibig sabihin, nakalista sa pareho
iyong MANIFEST.bago at MANIFEST mismo. Isa sa mga metaconfig alam ng mga unit ang tungkol dito
file at pipilitin ang Configure na magsagawa ng release check, na tinitiyak ang lahat ng mga file
nakalista doon ay bahagi ng pamamahagi. Ang MANIFEST at MANIFEST.new na mga file ay dapat
maging naiiba, hindi mga link.

· Kopyahin ang anumang .U file na gusto mong baguhin sa iyong pribadong direktoryo ng U. Anumang .U file
sa iyong pribadong direktoryo ng U ay gagamitin bilang kagustuhan sa isa sa pampublikong U
direktoryo. Halimbawa, ang isang paraan upang pilitin ang pagsasama ng anumang yunit ay ang kopyahin ang End.U
file sa iyong .U na direktoryo at idagdag ang pangalan ng unit na gusto mo bilang dependency
ang dulo ng linyang ?MAKE:. Ang ilang partikular na unit ay maaari LAMANG mapipilitan sa ganitong paraan, ibig sabihin
ang mga nasa anyong Warn_*.U at Chk_*.U. Maaari mo ring i-customize ang ilang default
I-configure ang mga variable sa pamamagitan ng pagkopya ng Myinit.U sa pribadong direktoryo ng U ng iyong package at
pagtatakda ng mga variable sa yunit na iyon.

Ngayon ay handa ka nang tumakbo metaconfig. Iyon ay lilikha ng isang I-configure ang file, at opsyonal na a
config_h.SH file (kung ang iyong mga mapagkukunan ay gumagamit ng anumang mga simbolo ng C). Ang nabuong mga file ay
awtomatikong maidaragdag sa iyong MANIFEST.new kung kinakailangan. Huwag kalimutang i-update ang iyong
MANIFEST file bagaman.

Upang lumikha ng mga bagong unit, gawin ang sumusunod:

· Kopyahin ang isang katulad na unit sa isang bagong .U file. Ang pangalang pipiliin mo ay dapat na pangalan ng a
variable na nabuo ng unit, bagama't ito ay kaginhawaan lamang para sa iyo, hindi a
pangangailangan. Ito ay dapat na 12 o mas kaunting mga character upang maiwasan ang pagpuputol ng filename.
Actually, dapat siguro 10 or less para magkaroon ang mga gustong gumamit ng RCS
a .U,v sa dulo nang hindi tinadtad. Ginagamit ng Metaconfig ang kaso ng unang titik sa
tukuyin kung anumang variable ang aktwal na ginawa ng unit na ito, kaya huwag I-capitalize ang iyong
pangalan ng unit kung ito ay dapat na gumawa ng isang shell variable.

· I-edit ang bagong .U file para gawin ang gusto mo. Ang unang ?MAKE: linya ay nagpapahiwatig ng
dependencies; bago ang huling listahan ng colon lahat ng mga variable na tinukoy ng yunit na ito, at
pagkatapos ng huling colon ang lahat ng mga variable (o iba pang mga yunit) kung saan nakasalalay ang yunit na ito.
Napakahalaga na tumpak ang mga listahang ito. Kung ang isang dependency ay opsyonal at a
Maaaring gamitin ang default na halaga, dapat mong i-prefix ang dependency na may sign na '+'. Ang
Ang kaukulang yunit ay hindi ilo-load upang makalkula ang simbolo, maliban kung talagang kinakailangan
ng ibang unit.

· Hangga't maaari, i-parameter ang iyong unit batay sa variable ng shell na tinukoy sa
?INIT: lines. Ililipat nito ang mga variable na kahulugan hanggang sa unit ng Init.U, kung saan
maaari silang ma-override ng mga kahulugan sa Myinit.U, na kasama pagkatapos ng Init.U.

· Idagdag ang kahulugan ng anumang C na mga simbolo na nais bilang ?H: na mga linya. Isang linya na nagsisimula sa
?H:?%<: sa .U file ay idadagdag sa panghuling config.h file kung at kung lamang
nagpasya ang metaconfig na kailangan ang unit na ito. Ang %< ay kumakatawan sa pangalan ng unit,
na mangyayari rin ang pangalan ng file (walang .U) kung sinunod mo ang
kumbensiyon. Palaging maglagay ng komento sa bawat ?H: linya kung sakaling isa sa variable
ang mga pagpapalit na mas maaga sa linya ay nagsisimula ng komento nang hindi ito tinatapos. Kahit anong shell
variable na nagsisimula sa d_ ay maaaring gawin ito, kaya mag-ingat. Kung tinanggal mo ang ?%<:, kung gayon
metaconfig ay susubukan na intuit ang simbolo na ang kahulugan ay kailangan bago ang anumang
pagsasama sa config.h.

· Magdagdag ng mga kahulugan ng glossary bilang ?S: na mga linya para sa mga variable ng shell at ?C: na mga linya para sa C
mga variable ng preprocessor. Tingnan ang kasalukuyang unit para sa mga halimbawa. Ito ay napakahalaga sa
simulan ang bawat entry na may kaliwang makatwirang pangalan ng simbolo, at tapusin ang bawat entry na may ?C:. o
?S:. linya. Ang algorithm na nagsasalin ng mga entry ng simbolo ng C preprocessor para sa
Nakadepende dito ang Glossary sa mga komento para sa config.h.

· Siguraduhin ang pagkakasunod-sunod ng lahat ng iyong ? tama ang mga linya. Ang tamang pagkakasunod-sunod ay:

?RCS: at ?X: karaniwang mga komento lang
?MAKE: metaconfig dependencies
?Y: direktiba sa layout ng unit
?S: mga kahulugan ng glossary shell
?C: mga kahulugan ng glossary C
?H: mga kahulugan ng config.h
?M: mga kahulugan ng confmagic.h
?W: gusto ng mga simbolo
?V: nakikitang mga simbolo
?F: mga file na ginawa ng unit na ito
?T: ginamit na pansamantalang mga simbolo ng shell
?D: opsyonal na dependencies default na halaga
?O: ginagamit upang markahan ang mga hindi na ginagamit na yunit
?LINT: mga pahiwatig ng metalint
?INIT: mga inisyal na simbolo ng shell

Narito ang isang halimbawa upang ipakita ang pagkakasunud-sunod ng mga linya at ang iba't ibang mga format na pinapayagan:

?RCS: $RCS-Id$
?RCS: Impormasyon sa copyright
?RCS: $RCS-Log$
?X:
?X: Isang ginawang halimbawa
?X:
?GUMAWA:d_isa dalawa: tatlo +apat Lima
?MAKE: -piliin magdagdag ng $@ %
?Y:DEFAULT
?S:d_one:
?S: Unang simbolo ng shell, may kondisyong tumutukoy sa ISA.
?S:.
?S:dalawa:
?S: Pangalawang simbolo ng shell, halaga para sa DALAWA.
?S:.
?C:ONE:
?C: Unang simbolo ng C.
?C:.
?C:TWO:
?C: Pangalawang C simbolo.
?C:.
?H:#$d_one ISA /**/
?H:#define TWO "$two"
?H:#$d_one ONE_TWO "$two"
?H:.
?M:flip: HAS_FLIP
?M:#ifndef MAY_FLIP
?M:#define flip(x) flop(x)
?M:#endif
?M:.
?W:%<:isa_dalawa
?V:p_isa p_dalawa:p_tatlo
?F:file ./ftest !tmp
?T:tmp var
?D:two='undef'
?LINT:magpalit ng tatlo
?INIT:two_init='2'
: shell code na nagpapatupad ng yunit ay sumusunod
p_one='one'
p_two='two'
p_three=""

Hayaan akong sabihin ito ng isa pang beses: ang kahulugan ng yunit sa itaas ay a pekeng isa upang ipakita lamang ang
iba't ibang posibilidad. Ang ganoong unit ay magsisilbi pa ring maliit na layunin... Iba pa
hindi inilalarawan dito ang mga advanced na feature. Mangyaring sumangguni sa Sanggunian seksyon para sa higit pa
kumpletong impormasyon.

· Ilagay ang unit sa pampubliko o pribadong direktoryo ng U kung naaangkop.

· Muling tumakbo metaconfig.

· Ipadala ang iyong unit sa [protektado ng email] (Raphael Manfredi) para isama sa master copy,
kung sa tingin mo ito ay pangkalahatang interes.

Upang magdagdag ng bagong program na makikita:

· I-edit ang Loc.U, at idagdag ang pangalan ng programa pareho sa linyang ?MAKE: (sa pagitan ng
dalawang colon) at sa alinman sa loclist o trylist (depende sa kung ang programa ay
sapilitan o hindi).

· Patakbuhin muli ang metaconfig.

· Ipadala sa akin ang iyong unit para isama sa master copy, kung sa tingin mo ito ay pangkalahatan
interes.

Mga tala para sa pagsulat ng mga .U na file:

* Palaging gamitin ang "rm -f" dahil may mga system kung saan ang rm ay interactive bilang default.

* Huwag gumamit ng "set -- ..." dahil hindi gumagana ang '--' sa bawat shell. Gamitin ang "set x ...;
shift".

* Huwag gumamit ng "unset ENV" dahil hindi ganap na portable ang unset. Sabihin ang "ENV=''" sa halip.

* Palaging gumamit ng echo " " (na may espasyo) dahil sa mga sistema ng Eunice.

* Gamitin lamang pagsusulit may -r, -w, -f o -d dahil iyon lang ang mga portable switch. Sa
partikular, iwasan ang "test -x".

* Gumamit lamang ng mga program na kasama ng V7, para malaman mong lahat ay mayroon nito.

* Gamitin ang $contains kapag gusto mong mag-grep nang may kondisyon, dahil hindi lahat ng greps ay nagbabalik ng a
makatwirang katayuan. Tiyaking i-redirect ang output sa /dev/null, sa pamamagitan ng paggamit ng '>/dev/null
2>&1'.

* Gamitin ang "if test" sa halip na "if [...]" dahil hindi alam ng bawat sh ang huling construct.

* Gamitin ang myread script para sa mga input para magawa nila ang mga shell escape at default
pagsusuri. Ang pangkalahatang anyo ay

kaso "$grimble" sa
'') dflt=452;;
*) dflt="$grimble";;
na C
rp='Ilan ang grimbles mo?'
. ./myread
grimble="$ans"

* Gamitin ang getfile script kapag humihingi ng pathname ng file upang magkaroon ng opsyonal
~pagpapalawak ng pangalan at mga pagsusuri sa katinuan. Tingnan ang Getfile.U unit para sa buong paglalarawan.

* Laging maglagay ng a

$startsh

sa itaas ng bawat nabuong script na ilulunsad o kukunin ni
I-configure ang.

* Huwag kailanman ipagpalagay ang mga karaniwang UNIX-ism tulad ng katotohanan na ang isang object file ay nagtatapos sa a .o at
na nagtatapos sa isang pangalan ng library .a. Gamitin ang $_o at $_a mga variable sa halip (tingnan
Unix.U).

* Kapag gumagawa ng compile-link-execute na pagsubok, palaging isulat ito nang ganito:

$cc $ccflags $ldflags try.c -o subukan ang $libs

dahil ang ilang mga sistema ay nangangailangan na ang pag-link ng mga flag ay tinukoy bago ang pinagsama-sama
target (maliban sa trailing linking library).

* Mag-isyu ng mahahalagang mensahe sa file descriptor #4, sa pamamagitan ng paggamit ng '>&4' upang i-redirect ang output.
Ang mga mensaheng iyon lang ang lalabas kapag ang -s switch ay ibinigay sa I-configure ang sa
command line (silent mode).

* Palaging subukang tukuyin kung ang isang tampok ay naroroon sa pinakaespesipikong paraan--huwag
sabihin "kung bsd" kapag maaari mong grep libc. Mayroong maraming mga hybrid system out doon, at
ang bawat tampok ay dapat tumayo o mahulog nang mag-isa.

* Palaging subukan upang matukoy kung ang isang tampok ay naroroon sa pinaka-pangkalahatang paraan, nang sa gayon
maaaring gamitin ng ibang mga pakete ang iyong unit.

* Kapag may pagdududa, magtakda ng default at magtanong. Huwag mag-assume ng kahit ano.

* Kung sa tingin mo ay mali ang gumagamit, payagan ang katotohanan na maaaring siya ay tama. Para sa
halimbawa, maaari siyang nagpapatakbo ng Configure sa ibang sistema kaysa sa kanyang gagamitin
ang huling produkto sa.

Inilalaan ng Metaconfig ang mga sumusunod na pangalan sa iyong direktoryo, at kung gagamit ka ng ganoong pangalan ito
maaaring ma-clobbered o magkaroon ng iba pang hindi inaasahang epekto:

.MT/*
I-configure ang
Karaniwan
Hindi na ginagamit
i-configure ang
config_h.SH
confmagic.h
U/*
MANIFEST.bago

Bukod pa rito, maaaring sirain ng Configure ang mga pangalang ito sa direktoryo kung saan ito pinapatakbo:

UU/*
config.sh
config.h

Opsyon

Ang mga sumusunod na opsyon ay kinikilala ng metaconfig:

-d I-on ang debug mode. Hindi talaga kapaki-pakinabang maliban kung nagde-debug ka metaconfig
mismo.

-h Mag-print ng mensahe ng tulong at lumabas.

-k Panatilihin ang pansamantalang direktoryo, upang masuri mo ang gumaganang mga file na ginagamit ng
metaconfig upang maitayo ang iyong I-configure ang iskrip. Kapaki-pakinabang lamang kapag nag-debug ng
mga yunit.

-m Ipagpalagay na maraming memorya at magpalit ng espasyo. Mapapabilis nito ang paghahanap ng simbolo
source file sa pamamagitan ng isang makabuluhang tagal ng oras, sa gastos ng memorya
pagkonsumo...

-o I-map ang mga hindi na ginagamit na simbolo sa mga bago. Gamitin ang switch na ito kung mayroon ka pa
mga lipas na simbolo sa iyong source code at ayaw (o hindi) alisin
sila sa ngayon. Ang mga hindi na ginagamit na mga simbolo ay kung hindi man ay binabalewala, bagaman iyon
ay magbibigay sa iyo ng babala mula sa metaconfig.

-s I-on ang silent mode.

-t Bakas ang mga simbolo habang matatagpuan ang mga ito.

-v I-on ang verbose mode.

-w Ipagpalagay na ang Wanted file ay napapanahon. Ito ay laktawan ang oras at memorya
ubos na yugto ng pag-scan ng source code, naghahanap ng mga kilalang simbolo. Gamitin ito
kapag alam mo na ang iyong source file ay hindi nagbago patungkol sa
pool ng metaconfig ginamit na mga simbolo.

-G Magbigay din ng GNU i-configure ang-tulad ng front end sa nabuo I-configure ang
script, na isasama rin sa pamamahagi. Ito ay isang pambalot lamang
sa paligid ng I-configure ang natural na script, ngunit hinahayaan nito ang mga taong pamilyar sa
GNU tool upang hindi mawala kapag nahaharap sa isang bagong pamamahagi.

-L dir I-override ang default na lokasyon ng library. Karaniwang kapaki-pakinabang lamang para sa metaconfig
mga maintainer na lokal na gamitin ang mga unit na binuo sa halip na ang
mga magagamit sa publiko. Ang dir ang tinukoy ay ang naglalaman ng mga yunit
U direktoryo.

-M Payagan ang paggawa ng a confmagic.h file upang awtomatikong i-remap ang ilang maayos-
kilalang mga simbolo sa ilang iba pang alternatibo, tulad ng bcopy() ina-remap
malinaw sa memcpy() kapag hindi available. Naka-on ang opsyong ito
awtomatikong kapag a confmagic.h umiiral ang file sa nangungunang antas na direktoryo.
Tanggalin lang ang file na iyon kung gusto mong i-disable nang permanente ang opsyong ito.

-V I-print ang numero ng bersyon at lumabas.

PAGTUTURO

Ang (mahabang) seksyong ito ay isang panimula sa metaconfig, kung saan matututunan natin ang lahat ng
mga pangunahing kaalaman. Kung alam mo na kung paano gamitin metaconfig, maaari kang ligtas na lumaktaw sa susunod
seksyon.

Pangkalahatang-ideya
Kadalasan kapag gusto mong makakuha ng ilang source package para i-compile sa isang partikular na platform na mayroon ka
upang i-edit ang pangunahing Makefile (ipagpalagay na mayroong isa!), pumili ng isang C compiler, siguraduhing ikaw
magkaroon ng tamang mga aklatan, at pagkatapos ay sunugin ang gumawa utos. Kung ang pakete ay makatwiran
mahusay na nakasulat, ito ay mag-compile (nang walang babala na isang pagpipilian :-). Sa sarili nito, ang huli
Ang pangungusap ay isang tunay na pagganap, dahil ibinigay ang iba't ibang mga platform ng UNIX na magagamit ngayon
at ang pagkakaiba-iba ng mga lasa, na nangangahulugan na ang may-akda ng pakete ay naging malalim
nahihirapang malaman ang mga tamang pagpipilian na binigyan ng ilang karaniwang pagsubok, paghula at panggugulo
sa paligid kasama ang system at mga uri.

Gayunpaman, sa kabila ng lahat ng kanyang talento, hindi maaaring malaman ng may-akda na ang ilang sistema ay may a
sirang system call, o na ang ilang istraktura ng system ay kulang ng isa kung hindi man ay karaniwang field, o
kung mayroon man o wala ang isang naibigay na file. At hindi ko isinasaalang-alang ang implicit
mga pagpapalagay, tulad ng uri na ibinalik ng malloc () function o ang pagkakaroon ng
palitan ang pangalan() system call upang pangalanan ang ilan. Ngunit ang kaalamang iyon ay kinakailangan upang makamit ang tunay
kakayanan.

Ngayon, huwag nating abusuhin ang ating sarili. Ang paggamit ng impormasyong iyon ay nangangailangan ng higit na mga kasanayan, ngunit magagawa nito
humahantong sa higit pang mga portable na programa dahil ito ay isinusulat sa paraang independyente sa system
at umaasa lamang sa katotohanan na ang ilang palagay ay totoo o mali sa isang partikular na sistema,
ang bawat palagay ay walang kaugnayan sa isa't isa. Ibig sabihin, hindi namin sinasabi: We're on a
BSD system o tayo ay nasa isang USG system. Masyadong malabo iyan sa panahon ngayon. Hindi, gusto namin
sabihin sa source code: ang sistemang ito ay walang palitan ang pangalan() system call at malloc ()
nagbabalik a (walang bisa *) halaga.

Ang Metaconfig ay isang tool na hahayaan kang gawin iyon, na may karagdagang benepisyo ng hindi
kinakailangang i-edit ng kamay ang Makefile kung maayos ang lahat. Sa pamamagitan ng pagtakbo metaconfig, lumikha ka ng
pinangalanang shell script I-configure ang. Maraming pagsisikap ang inilaan sa script ng I-configure
internals upang matiyak na ito ay tatakbo sa 99% ng mga umiiral na shell na magagamit simula nito
pagsusulat. Sisiyasatin ng Configure ang target na system, na nagtatanong kapag may pagdududa at
tipunin ang lahat ng mga sagot sa isang solong shell file, na magagamit naman
awtomatikong bumubuo ng mga naka-configure na Makefiles at C kasama ang mga file.

Mayroon lamang isang limitadong (ngunit medyo malaki) na hanay ng mga simbolo na magagamit para sa iyong mga script ng shell
at mga programang C. Lahat sila ay dokumentado sa Glossary file. Ang kailangan mo lang gawin ay matuto
tungkol sa mga ito at simulang gamitin ang mga ito upang matugunan ang mga problema sa portability at configuration. pagkatapos,
sa pagtakbo metaconfig, bubuo ng angkop na script ng Configure para sa iyong package.

Ang script ng I-configure ay binuo ng ilang mga yunit (higit sa 300), ang bawat yunit ay
responsable para sa pagtukoy ng isang maliit na bilang ng mga simbolo ng shell at/o C. Ang mga yunit ay binuo
magkasama sa huling yugto, pinarangalan ang dependency graph (maaaring kailanganin ng isang unit ang resulta
ng ilang iba pang mga yunit na pagkatapos ay inilagay bago sa script).

Mga Simbolo
Ang mga simbolo ang pinakamahalagang bagay sa metaconfig mundo. Sila ang pinakamaliit
kinikilalang entity, karaniwang isang salita, at maaaring bigyan ng halaga sa dulo ng Configure
pagbitay. Halimbawa, ang simbolo ng C pre-processor HAS_RENAME ay isang metaconfig simbolo na
ay garantisadong tukuyin kung, at kung, ang palitan ang pangalan() naroroon ang system call. Gayundin,
ang $ranlib Ang variable ng shell ay itatakda sa alinman sa ':' o 'ranlib' depende sa kung ang
tawag sa ranlib programa ay kinakailangan upang mag-order ng isang file ng aklatan. Paano ito gumagana ay hindi
mahalaga sa ngayon, ang mahalaga ay maunawaan na ang mga simbolong iyon ay ibinibigay a buhay
(ibig sabihin, isang halaga) sa I-configure ang pagpapatupad

Ang paggamit ng mga simbolo ay medyo diretso. Sa isang C source file, gagamitin mo lang ang simbolo
halaga, bilang isang pre-processor na direktiba (halimbawa isang: #ifdef HAS_RENAME) o, kung ang simbolo
ang value ay isang string, nang direkta gaya ng paggamit mo ng macro sa C. At sa isang shell file o a
Makefile, maaari kang direktang sumangguni sa isang simbolo ng shell.

Sa totoo lang, nagsisinungaling ako, dahil hindi iyon ganap na magic tulad ng nakaraang talata
maaaring tumunog. Sa isang C file, kailangan mong isama ang Configure-produced config.h file, at
dapat mong balutin ang iyong shell script o Makefile sa isang .SH file at maaari mong i-reference ang shell
simbolo lamang sa variable substitution na bahagi ng .SH file na iyon. Higit pa tungkol dito mamaya.

pinagmulan File
Ang mga simbolo ay maaari lamang lumitaw sa isang limitadong hanay ng mga source file, dahil metaconfig ay lamang
i-scan ang mga iyon kapag naghahanap ng mga kilalang simbolo, sinusubukang malaman kung aling mga yunit ang kakailanganin nito.
Maaari kang gumamit ng mga simbolo ng C sa C source file, ibig sabihin, ang mga file na may a .c, .h, .y or .l extension, at
Ang mga simbolo ng shell ay hinahanap lamang sa mga .SH na file.

Upang makuha ang halaga ng isang simbolo, ang isang C file ay kailangang isama ang espesyal config.h
file, na ginawa ng I-configure ang kapag naroroon ang mga simbolo ng C. At ang mga .SH file ay pinapatakbo
sa pamamagitan ng isang shell, na gumagawa ng isang bagong file. Gayunpaman, sa tuktok na seksyon ng .SH file, ang
espesyal config.sh file (ginawa rin sa pamamagitan ng pagpapatakbo I-configure ang) ay pinagmulan, at variable
nalalapat ang mga pagpapalit. sa totoo lang, config.h ay ginawa sa pamamagitan ng pagpapatakbo ng metaconfig-produced
config_h.SH file, muli gamit ang variable substitution. Kaya titingnan natin iyon a
mas malapit dahil ito ang puso ng kabuuan configuration scheme...

Paiba-iba Paghalili
May tinatawag na shell construct dito dokumento na nagbibigay-daan sa isang command na kumuha ng input
tinukoy sa loob mismo ng script. Ang input na iyon ay binibigyang-kahulugan ng shell bilang isang double-
naka-quote na string o isang solong naka-quote na string depende sa anyo ng dito na dokumento
pagtutukoy.

Upang tukuyin ang isang dito na dokumento, ang token na '<<' ay ginagamit, na sinusundan ng isang identifier. Mula sa
pagkatapos, ang natitirang mga linya ng script ay bumubuo ng input para sa command, hanggang dito
Ang dokumento ay matatagpuan sa isang linya nang mag-isa. Pagpapalit ng shell (kabilang ang variable ng shell
mga pagpapalit) ay ginagawa maliban kung ang identifier ay napapalibutan ng mga solong panipi. Halimbawa:

var='first'
tar = 'pangalawa'
echo "--> una dito dokumento:"
pusa <
var='$var'
tar='$tar'
EOM
echo "--> pangalawa dito dokumento:"
pusa <<'EOM'
echo $var
echo $tar
EOM
echo "--> wakas."

ay magbubunga, kapag tumakbo sa isang shell:

--> una dito ang dokumento:
var='first'
tar = 'pangalawa'
--> pangalawa dito ang dokumento:
echo $var
echo $tar
--> wakas.

Ang una dito na dokumento ay may kahulugang nilalaman habang ang pangalawa ay output bilang-ay.
Parehong kapaki-pakinabang sa isang .SH script, gaya ng makikita natin.

paggamit .SH Script
Karaniwang ginagawa ang isang .SH script sa pamamagitan ng pagpapatakbo ng MakeSH script ng isa pang umiiral na file,
transforming file sa isang file.SH. Kumuha tayo ng isang halimbawa. Narito ang isang maliit na script
(tawagan natin insize) na nagpi-print ng isang mensahe, ang laki ng int datatype sa C.
Sa kasamaang palad, mayroon itong halaga na naka-hardwired dito, kaya:

#!/ Bin / SH
insize='4'
echo "Sa makinang ito, ang uri ng int ay $intsize bytes"

Tumakbo tayo makeSH dito sa pamamagitan ng pag-type 'makeSH insize'. Kumuha kami ng single insize.SH file kana
ganito ang hitsura nito:

kaso $CONFIG in
")
kung pagsubok -f config.sh; tapos TOP=.;
elif test -f ../config.sh; tapos TOP=..;
elif test -f ../../config.sh; tapos TOP=../..;
pagsubok ng elif -f ../../../config.sh; tapos TOP=../../..;
elif test -f ../../../../config.sh; tapos TOP=../../../..;
iba
echo "Hindi mahanap ang config.sh."; labasan 1
fi
. $TOP/config.sh
;;
na C
: Pinipilit nito ang mga SH file na lumikha ng target sa parehong direktoryo bilang SH file.
: Ito ay para laging alam ng make depend kung saan makakahanap ng SH derivatives.
kaso "$ 0" sa
*/*) cd `expr X$0 : 'X\(.*\)/'` ;;
na C
echo "Pag-extract ng insize (na may mga variable na pagpapalit)"
: Ang seksyong ito ng file ay magkakaroon ng mga variable na pagpapalit na gagawin dito.
: Ilipat ang anumang nangangailangan ng config subs mula sa !NO!SUBS! section to !GROK!THIS!.
: Protektahan ang anumang mga dollar sign at backtick na hindi mo gustong bigyang-kahulugan
: sa pamamagitan ng paglalagay ng backslash sa harap. Maaari mong tanggalin ang mga komentong ito.
$spitshell >intsize <
$startsh
!GROK!ITO!

: Sa mga sumusunod na dolyar at backtick ay hindi kailangan ng dagdag na backslash.
$spitshell >>intsize <<'!HINDI!SUBS!'
insize='4'
echo "Sa makinang ito, ang uri ng int ay $intsize bytes"
!HINDI!SUBS!
chmod 755 intsize
$eunicefix intsize

Ang unang bahagi ng script na ito (sa kaso pahayag) ay sinusubukang hanapin ang config.sh
file, upang mapagkunan ito. Ang $CONFIG variable ay false bilang default, sa pamamagitan ng true kapag
config.sh ay nakuha na (na magiging kaso kung ang file na ito ay naisakatuparan mula sa
sa loob ng I-configure ang mismo, ngunit huwag nating malito ang isyu dito).

Kapag ang config.sh Ang file ay mga mapagkukunan, ang lahat ng mga simbolo ng shell ay tinukoy ng I-configure ang ay
itakda. Alam naming maabot ang pangalawang case statement, na ginagamit upang baguhin ang kasalukuyang direktoryo ay dapat a
path na gagamitin upang maabot ang program na ito (halimbawa kung sinabi namin 'sh ../scripts/intsize.SH', kami
tatakbo munacd ../scripts' bago magpatuloy). Kung hindi mo maintindihan ito, huwag
Alalahanin ito.

Narito ang mga kawili-wiling bagay. Ginagamit ng script na ito ang $spitshell variable, at hindi
isang bagay na alam natin tungkol sa...pa. Kung titingnan mo ang Glossary file, makikita mo iyon
ito ay isang variable na kilala ng metaconfig. Kung gagawin mong bahagi ng iyong pamamahagi ang file na ito
(sa pamamagitan ng pagsasama nito sa MANIFEST.new na file, babalikan namin iyon mamaya) at tatakbo
metaconfig, pagkatapos ay ang I-configure ang Ang script ay tutukoy ng isang angkop na halaga para sa variable na ito
at ito ay ilalagay config.sh. Parehong napupunta para sa $startsh at ang mahiwaga $eunicefix at
wakas. Sa isang makatwirang sistema, ang nauugnay na bahagi ng config.sh magiging ganito:

spitshell='pusa'
startsh='#!/ Bin / SH'
eunicefix=':'

Ah! Papalapit na kami. Ngayon parang pamilyar. Kaharap namin ang isang single pusa utos kanino
input ay mula sa isang variable-interpolated dito dokumento at kung saan ang output ay na-redirect sa
insize. Ang halaga ay magiging ng $startsh, ibig sabihin, '#!/ Bin / SH'. Ayos sa ngayon.

Pagkatapos ay naabot namin ang pangalawang pagpapalawak ng dokumento dito, upang makuha ang natitirang script. Ito
oras, ang simbolo ng dokumento dito ay napapalibutan ng mga solong quote kaya ang mga nilalaman ay magiging
idinagdag ang verbatim sa insize file. Kaya, sa pamamagitan ng pagtakbo'sh insize.SH', nakukuha namin ang
sumusunod na output:

Extracting insize (na may variable substitutions)

at sa pamamagitan ng pagtingin sa ginawang insize na file, makikita natin:

#!/ Bin / SH
insize='4'
echo "Sa makinang ito, ang uri ng int ay $intsize bytes"

na kung ano mismo ang mayroon kami sa simula. Sa ngayon, ito ay isang no-operation procedure...
Ngunit, napakaganda! It so happens (pure coincidence, trust me!), ganun metaconfig alam mo
tungkol sa $intsize simbolo ng shell. Sa pamamagitan ng paglipat ng initialization ng insize sa variable-
interpolated area ng .SH script at sinisimulan ito gamit ang I-configure ang-kinakalkula ang halaga,
at pag-alis ng mga walang kwentang komentong idinagdag ni makeSH, nakukuha natin:

kaso $CONFIG in
")
kung pagsubok -f config.sh; tapos TOP=.;
elif test -f ../config.sh; tapos TOP=..;
elif test -f ../../config.sh; tapos TOP=../..;
pagsubok ng elif -f ../../../config.sh; tapos TOP=../../..;
elif test -f ../../../../config.sh; tapos TOP=../../../..;
iba
echo "Hindi mahanap ang config.sh."; labasan 1
fi
. $TOP/config.sh
;;
na C
kaso "$ 0" sa
*/*) cd `expr X$0 : 'X\(.*\)/'` ;;
na C
echo "Pag-extract ng insize (na may mga variable na pagpapalit)"
$spitshell >intsize <
$startsh
intsize='$intsize'
!GROK!ITO!

$spitshell >>intsize <<'!HINDI!SUBS!'
echo "Sa makinang ito, ang uri ng int ay $intsize bytes"
!HINDI!SUBS!
chmod 755 intsize
$eunicefix intsize

Siyempre, ang pagpapatakbo ng script na ito sa pamamagitan ng isang shell ay muling maglalabas ng parehong script. Ngunit kung
tumakbo kami I-configure ang sa isang makina kung saan ang isang int ay naka-imbak bilang isang 64 bits na dami, config.sh habilin
itakda insize hanggang 8 at ang insize ang script ay magkakaroon ng tamang halaga at i-print:

Sa makinang ito, ang uri ng int ay 8 bytes

ano ang tama. Binabati kita! Kaka-configure lang namin ng shell script!!

Paggawa config.h
Maaari na nating tingnan ang daan config.h ay ginawa mula sa config_h.SH. Alam namin yun
tumatakbo I-configure ang Gumagawa ng isang config.sh script (kung paano ito ginagawa ay hindi mahigpit
may kaugnayan dito, ngunit para sa mga mausisa, ito ay isa pang pagpapalit ng dokumento dito sa loob
I-configure ang mismo). Ang config_h.SH mismo ay binuo ni metaconfig sa parehong oras
I-configure ang ay, sa kondisyon na gumamit ka ng hindi bababa sa isang simbolo ng C sa loob ng iyong mga mapagkukunan.

Tingnan natin ang ilang random config_h.SH file para makita kung ano talaga ang nangyayari:

kaso $CONFIG in
")
kung pagsubok -f config.sh; tapos TOP=.;
elif test -f ../config.sh; tapos TOP=..;
elif test -f ../../config.sh; tapos TOP=../..;
pagsubok ng elif -f ../../../config.sh; tapos TOP=../../..;
elif test -f ../../../../config.sh; tapos TOP=../../../..;
iba
echo "Hindi mahanap ang config.sh."; labasan 1
fi
. $TOP/config.sh
;;
na C
kaso "$ 0" sa
*/*) cd `expr X$0 : 'X\(.*\)/'` ;;
na C
echo "Pag-extract ng config.h (na may mga variable na pagpapalit)"
sed < config.h -e 's!^#undef!/define!' -e 's!^#un-def!#undef!'
/*
* Ang file na ito ay ginawa sa pamamagitan ng pagpapatakbo ng config_h.SH script, na
* nakakakuha ng mga halaga nito mula sa config.sh, na karaniwang ginagawa ng
* tumatakbo ang I-configure.
*
* Huwag mag-atubiling baguhin ang alinman sa mga ito kapag kinakailangan. Tandaan, gayunpaman,
* ang pagpapatakbong muli ng config.h.SH ay magbubura sa anumang mga pagbabagong iyong ginawa.
* Para sa mas permanenteng pagbabago, i-edit ang config.sh at muling patakbuhin ang config.h.SH.
*/

/* Oras ng pagsasaayos: $cf_time
* Na-configure ni: $cf_by
* Target na sistema: $myuname
*/

#ifndef _config_h_
#define _config_h_

/* bcopy:
* Ang simbolo na ito ay naka-mapa sa memcpy kung ang bcopy() routine ay hindi
* magagamit upang kopyahin ang mga string.
*/
/* MAY_BCOPY:
* Ang simbolo na ito ay tinukoy kung ang bcopy() routine ay magagamit sa
* kopya ng mga bloke ng memorya. Hindi mo dapat gamitin ang simbolong ito sa ilalim
* normal na mga pangyayari at gumamit ng bcopy() nang direkta sa halip, na
* ay mapapa-mapa sa memcpy() kung hindi available ang bcopy.
*/
#$d_bcopy HAS_BCOPY /**/
#ifndef MAY_BCOPY
#ifdef bcopy
#un-def bcopy
#endif
#define bcopy(s,d,l) memcpy((d),(s),(l)) /* nakamapang sa memcpy */
#endif

/* MAY_DUP2:
* Ang simbolo na ito, kung tinukoy, ay nagpapahiwatig na ang dup2 routine ay
* magagamit sa mga duplicate na descriptor ng file.
*/
#$d_dup2 MAY_DUP2 /**/

/* I_STRING:
* Ang simbolo na ito, kung tinukoy, ay nagpapahiwatig sa C program na ito ay dapat
* isama (USG system) sa halip na (BSD system).
*/
#$i_string I_STRING /**/

#endif
!GROK!ITO!

Sa itaas ng file, kinikilala namin ang karaniwang .SH construct na mayroon na kami
pinag-aralan nang detalyado. Susunod ay ang pagkuha ng file mismo, sa pamamagitan ng isang dito na dokumento na may
variable na pagpapalit. Gayunpaman, dito hindi kami gumagamit ng plain pusa ngunit isang uhaw sa halip, dahil
kailangan nating gumawa ng ilang karagdagang pag-edit on-the-fly. Makikita natin kung bakit mamaya, kaya kalimutan na natin
tungkol dito ngayon.

Naabot na namin ngayon ang nangungunang komento, at ang file ay na-tag ng oras ng pagsasaayos, ang
target system, atbp... (yung mga variable na nagmumula sa sourced config.sh file ay naging
itinakda ni I-configure ang). Ang header ng komentong iyon ay sinusundan ng proteksyong '#ifndef' na babantayan
laban sa maraming pagsasama ng file na ito. Pagkatapos ay ang puso ng file...

Nakakatulong na malaman iyon $d_* at $i_* ang mga variable ay nakatakda sa alinman sa 'magtakda'o'undef' ni
I-configure ang, depende sa kung ang isang function o isang include file ay naroroon sa system o
hindi. Ibig sabihin ay ang:

#$d_bcopy HAS_BCOPY /**/

lalawak ang linya sa alinman sa:

#define HAS_BCOPY /**/

kung ang $d_bcopy variable ay nakatakda sa 'define' o:

#undef HAS_BCOPY /**/

kung ang $d_bcopy ay itinakda sa 'undef', dahil wala doon ang feature. Gayunpaman, hindi iyon
kung ano ang nakasulat sa config.h file dahil sa uhaw filter na nakita na natin,
na magpapabago sa pangalawang anyo sa:

/*#define HAS_BCOPY /**/

Iyan ay isang madaling gamiting form para sa pag-edit sa ibang pagkakataon ng config.h dahil kailangan mo lang tanggalin ang
nangunguna sa '/*' kung gusto mong i-override I-configure angpagpipilian ni. Gayundin, maaari kang magdagdag ng isang solong
'/*' sa simula ng isang '#define' na linya upang maiwasan ang kahulugan ng isang partikular na simbolo.
Ito ang dahilan kung bakit ang bawat kahulugan ng simbolo ay protektado ng isang sumusunod na '/**/', upang isara ang nangunguna
komentong binuksan ng '/*' (ang mga komento ay hindi naka-nest sa C).

Ngayon ang pagbabago ng '#undef' sa '/*#define' ay maganda, ngunit kung gusto nating magsulat ng a
'#undef', kami ay natigil... maliban kung isulat namin ito bilang '#un-def' at hayaan uhaw ayusin mo yan sa '#undef'
habang gumagawa config.h, na kung ano talaga ang ginagawa dito.

Ang parehong uri ng pangangatwiran ay nalalapat sa dalawang linyang iyon:

#$d_dup2 MAY_DUP2 /**/
#$i_string I_STRING /**/

at pagpapalagay config.sh tumutukoy sa:

d_dup2='define'
i_string='undef'

papasok tayo sa ginawa config.h:

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

Maaliwalas na parang umaagos na tubig? Magaling!

Ngayon ay dapat na malinaw na sa pamamagitan ng pagsasama config.h sa lahat ng iyong C source file, makukuha mo
alam mo ano I-configure ang ay nahulaan sa iyong system. Sa katunayan, sa pamamagitan ng paggamit ng mga simbolo na iyon, ikaw ay
pagsulat ng naka-configure na C code, dahil metaconfig malalaman na kailangan mo ang mga simbolo at kalooban na iyon
makabuo ng angkop config_h.SH file pati na rin ang lahat ng kinakailangang code sa I-configure ang sa
kalkulahin ang isang wastong halaga para sa kanila (sa pamamagitan ng pagtatalaga ng mga halaga sa nauugnay na mga variable ng shell).

Tumatakbo Metaconfig
Tumutok tayo sa metaconfig programa nang ilang sandali upang maunawaan kung paano nito ginagamit ang mga yunit nito at
ang iyong source code upang makagawa ng lahat ng kinakailangang configuration file. Kung balak mong magsulat ng bago
unit, dapat ay mayroon kang isang mahusay na pag-unawa sa buong scheme.

Kung walang MANIFEST.new file, metaconfig susubukan na gamitin ang MANIFEST file sa halip,
para sa kaginhawahan. Saanman namin binanggit ang MANIFEST.bago, maaari itong maunawaan bilang MANIFEST
sa kondisyon na walang MANIFEST.new file na matatagpuan sa ugat ng iyong package.

Ipagpalagay na ang iyong MANIFEST.new file ay maayos na nakatakda at naglilista ng lahat ng mga source file na nais mong gawin
i-configure, at na tumakbo ka na packint sa iyong root source na direktoryo upang lumikha ng isang
.balot file, maaari kang tumakbo metaconfig at makukuha mo ang sumusunod:

$ metaconfig
Hinahanap ang mga unit...
Kinukuha ang mga listahan ng dependency mula sa 312 unit...
Kinukuha ang mga filename (*.[chyl] at *.SH) mula sa MANIFEST.new...
Bumuo ng Wanted file...
Ini-scan ang mga .[chyl] file para sa mga simbolo...
Ini-scan ang mga .SH file para sa mga simbolo...
Kino-compute ang pinakamainam na graph ng dependency...
Pagbuo ng pribadong make file...
Pagtukoy ng mga mai-load na unit...
Ina-update ang make file...
Pagtukoy sa tamang pagkakasunud-sunod para sa mga yunit...
Gumagawa ng Configure...
Mag-donate.

Hinahanap ng unang yugto ang lahat ng file ng unit (nagtatapos sa .U) sa pampublikong direktoryo
una, pagkatapos ay sa iyong pribadong isa. Kung kumopya ka ng pampublikong file sa iyong pribadong direktoryo ng U
(ibig sabihin, isang direktoryo na pinangalanang U sa pinakamataas na antas ng iyong package), ito ay magpapawalang-bisa sa publiko
bersyon. Kapag mayroon na itong listahan ng lahat ng available na unit, i-parse nito ang mga ito at i-extract ang lahat
ang ?MAKE: mga linya upang malaman ang tungkol sa mga dependency at ang mga kilalang simbolo ng shell. Ito rin
nakatutok sa mga linyang ?H: upang malaman ang tungkol sa mga simbolo ng C at kung aling mga simbolo ng shell ang kailangan
computed upang makakuha ng isang wastong halaga para sa C na simbolo (kaya mayroon kaming isa pang antas ng dependencies
dito).

Susunod, ang mga wastong filename ay kinukuha mula sa MANIFEST.new file at a Karaniwan ang file ay
binuo: ang file na iyon ay naglilista ng lahat ng mga simbolo ng C at ang mga simbolo ng shell na kailangan para sa paketeng iyon. Kami
i-scan muna ang mga C-type na file para sa mga simbolo ng C, pagkatapos ay ipalaganap ang mga dependencies sa kanilang
nauugnay na mga simbolo ng shell (nakuha mula sa ?H: lines). Susunod na .SH file ay ini-scan at sa wakas
lahat ng mga simbolo ng shell ay kilala.

Isang pansamantalang Makefile ang binuo at sinusubukan ng metaconfig gumawa lahat ng mga simbolo ng shell upang makita
anong mga utos (nakalista sa pangalawang ?MAKE: mga linya) ang isinasagawa, at sa gayon ay aling mga yunit ang
kailangan talaga. Ang mga opsyonal na unit na hindi kinakailangan ay aalisin at ang pangalawang Makefile ay
nabuo. Sa pagkakataong ito, alam namin ang tungkol sa lahat ng unit at kani-kanilang mga order, opsyonal
naalis ang mga unit at nakalkula ang mga default na halaga para sa kanilang mga simbolo ng shell. Ang
I-configure ang maaaring mabuo ang script, kasama ng config_h.SH. Tapos na.

Kumbensyon
Ang mga wastong kombensiyon ay kailangang sundin upang maging maayos ang buong proseso. May kaso
convention para sa mga unit at isang variable na convention sa pagbibigay ng pangalan.

Ang lahat ng unit ay dapat magkaroon ng kanilang unang titik na lower-cased, maliban kung sila ay mga espesyal na unit. Sa pamamagitan ng
espesyal, ang ibig naming sabihin ay hindi talaga nila tinukoy ang mga bagong variable ng shell na maaaring gamitin ng
user sa kanyang mga .SH na file, ngunit sa halip ay mga yunit na gumagawa ng mga script o mga variable ng shell na para sa
gamitin sa loob ng I-configure ang iskrip. Ang mga karaniwang halimbawa ay ang Init.U file which is
ang pangunahing variable initialization, o Myread.U na gumagawa ng myread ginamit halos script
kahit saan sa I-configure ang kapag may itatanong sa user.

Ang mga di-espesyal na unit pagkatapos ay mag-subdivise sa dalawang magkakaibang grupo: mga yunit na tumutukoy sa mga variable
nauugnay sa isang simbolo ng C at mga yunit na tumutukoy sa sarili nilang mga variable ng shell. Ang unang pangkat
ay higit pang nahahati sa mga variable na nauugnay sa pagsasama ng mga file (nagsisimula ang kanilang pangalan sa i_) At
mga variable na nauugnay sa iba pang mga kahulugan (pangalan na nagsisimula sa d_). Ang pangalawang pangkat ay mayroon
mga pangalan na nakatayo para sa sarili nito, halimbawa cc.U tumutukoy sa $cc shell variable na ang halaga ay
ang C compiler na gagamitin.

Minsan inilalaan ng mga espesyal na unit ang kanilang sarili ng ilang paunang natukoy na variable at nagbabalik ng "mga resulta"
sa iba pang mga kilalang variable. Halimbawa, ang myread script na ginawa ng Myread.U
inaasahan ang prompt sa $rp, ang default na sagot sa $dflt at inilalagay ang sagot ng gumagamit $ans.
Hindi ito nakadokumento sa manwal na pahinang ito: kailangan mong pumunta at tingnan ang mismong unit
maunawaan kung aling mga variable ang ginagamit at kung paano gagamitin ang yunit.

paggamit Ang Talasalitaan
Ang Glossary file ay awtomatikong ginawa ng makegloss script, na kumukuha ng
impormasyon mula sa ?S:, ?C: at ?MAKE: mga linya at nire-reformat ang mga ito sa alpabeto
pinagsunod-sunod na glossary. Mahalagang basahin ang Glossary upang malaman ang tungkol sa mga simbolo na ikaw ay
pinapayagang gamitin. Gayunpaman, hindi sasabihin sa iyo ng Glossary kung paano gamitin ang mga ito. Kadalasan, ganoon
nasa iyo na

Isang araw, malamang na susulat ka ng sarili mong mga unit at sapat na ang iyong nalalaman metaconfig
upang gawin ito nang mabilis at mahusay. Gayunpaman, huwag kalimutang idokumento nang maayos ang iyong trabaho
ang ?S: at ?C: na mga linya, o ibang tao ay hindi na ito magagamit muli. Tandaan ang tungkol sa
oras kung saan mayroon ka lamang Glossary at ang manwal na pahinang ito upang makapagsimula.

Konklusyon
Ngayon alam mo na ang metaconfig basics, dapat mong basahin ang DESCRIPTION seksyon, pagkatapos
lumaktaw sa Sanggunian seksyon upang malaman ang tungkol sa lahat ng madugong detalye gaya ng pinapayagan
syntax para sa mga linya ng kontrol ng unit (mga linya na nagsisimula sa isang '?') o ang mga natatanging utos na GUMAWA
pinapayagan kang gumamit.

Sanggunian

Ang seksyong ito ay nagdodokumento ng mga panloob ng metaconfig, karaniwang ang unit syntax, ang espesyal
mga unit na dapat mong malaman at ang mga file ng pahiwatig.

Pangkalahatan Yunit palaugnayan
Ang isang metaconfig unit ay nahahati sa dalawang magkakaibang bahagi. Ang seksyon ng header (nagsisimula ang mga linya
na may '?') at isang seksyon ng shell (code na isasama sa I-configure ang script). Ito ay
posibleng magdagdag ng mga komentong '?X:' kahit saan sa loob ng unit, ngunit ang iba pang '?' mga linya (din
tinatawag kontrol linya) ay may mahigpit na patakaran sa pag-order.

Kung masyadong mahaba ang isang control line, posibleng gumamit ng continuation sa pamamagitan ng pagtakas sa final
bagong-linya na may backslash at nagpapatuloy sa susunod na linya (na dapat pagkatapos ay naka-indent
sa pamamagitan ng mga puwang o tab).

Ang sumusunod ay isang pormal na paglalarawan ng bawat isa sa mga linya ng kontrol. Maliban kung nakasaad
kung hindi, ang pagkakasunud-sunod ng pagtatanghal na ito ay ang pagkakasunud-sunod na gagamitin sa loob ng yunit.

?RCS: libre teksto
Para magamit para sa mga komento ng RCS, sa itaas ng unit.

?X: anumang teksto
Pangkalahatang layunin ng mga komento. Maaaring lumitaw saanman sa unit ngunit dapat iwanang makatwiran.
Para sa mga komento ng RCS, mangyaring gamitin ang ?RCS: form ng komento.

?GUMAWA:simbolo listahan: pagpapasustento listahan [+opsyonal]
Ito ang unang linya ng dependency. Ang una simbolo listahan dapat ilista ang lahat ng mga simbolo
binuo ng yunit na ito (ibig sabihin, ang halaga ay kinukuwenta ng seksyon ng shell ng yunit).
Ang mga simbolo ay dapat na pinaghiwalay ng espasyo. Kung ang isang tinukoy na simbolo ay para sa panloob na paggamit lamang at
hindi dapat lumitaw sa nabuo config.sh file, pagkatapos ay dapat itong unahan ng a
'+' (hindi malito sa mga opsyonal na dependency na tinukoy pagkatapos nito). Ang ikalawa
bahagi ng listahan (pagkatapos ng gitnang ':') ay ang dependency ng unit. Dapat nitong ilista ang lahat
ang mga kinakailangang espesyal na yunit, pati na rin ang lahat ng mga simbolo na ginagamit ng shell
pagpapatupad. Kung ang isang simbolo ay nedded ngunit ang configuration value nito ay hindi kritikal, ito
maaaring unahan ng '+', kung saan ito ay tinatawag na conditional dependency: its
ang kaukulang yunit ay mailo-load kung, at kung, ang simbolo na iyon ay talagang iba
nais; kung hindi, ang default na halaga ang gagamitin.

?GUMAWA:tab utos
Maaaring mayroong isa o higit pang mga command line na sumusunod sa mga paunang linya ng dependency. Yung
Ang mga utos ay isasagawa kapag ang yunit ay nais na i-load ang mga ito sa I-configure ang. Tingnan
ang talata tungkol sa gumawa ng mga utos para sa karagdagang impormasyon. Tandaan na ang nangungunang tab
kailangan ang karakter bago ang utos.

?Y:kaayusan
Magpahayag ng isang direktiba ng layout para sa unit na ito. Ang direktiba na iyon ay maaaring isa sa mga string
tuktok, default or ilalim (ang kaso ay hindi mahalaga, ang inirerekomendang istilo ay baybayin ang mga ito
uppercase). Kung aalisin, default ay ipinapalagay.

Ang direktiba na ito ay kinakailangan lamang kung nais mong pilitin ang isang yunit sa itaas o ibaba
ng nabuo I-configure ang script, dahil pinahihintulutan ito ng mga dependencies ng unit. Mahalaga
ang mga tanong ay maaaring pilitin sa simula. Sa loob ng parehong klase ng layout, mga unit
ay pinagsunod-sunod ayon sa alpabeto na may dalawang espesyal na kaso para sa d_* at i_* unit, sapilitang
ayon sa pagkakabanggit sa itaas at ibaba ng kanilang mga klase (ngunit ang mga ito ay dapat na kabilang sa
default na klase).

Pinipilit mo sa itaas ang isang unit na ang mga dependencies ay nangangailangan ng lahat ng iba pang unit
unahan ito, wala kang makakamit na interesante. Samakatuwid, ang direktiba na iyon ay dapat talaga
gamitin para pataasin ang priyoridad ng ilang interactive na unit na hindi nakadepende sa marami
iba pang mga simbolo na nakikita ng user, tulad ng mga tanong na nauugnay sa landas.

?S:simbolo_pangalan [(lipas na simbolo listahan)]:
Ipinapakilala ang isang simbolo ng shell. Pinangalanan ng unang linyang ito ang simbolo, opsyonal na sinusundan ng a
listahan na nakapaloob sa pagitan ng panaklong at pagbibigay ng hindi na ginagamit na katumbas. Mga laos na
ang mga simbolo ay muling imapa sa bago simbolo_pangalan kung ang -o ang pagpipilian ay ibinibigay sa
metaconfig.

?S:anumang teksto, para Talasalitaan
Karaniwang isang komento na naglalarawan sa simbolo ng shell, na kukunin ng makegloss
sa Glossary file.

?S:. Isinasara ang komento ng simbolo ng shell.

?C:simbolo_pangalan [~ bansag] [(lipas na simbolo listahan)]:
Ipinapakilala ang isang bagong simbolo ng C. Ang bansag pangalan ay ang pangalan sa ilalim kung saan ang C simbolo ay
makokontrol, ibig sabihin, kung ang bansag gusto ang simbolo, pagkatapos ay isusulat ang simbolong C na iyon
nasa config_h.SH file. Kadalasan, ang alyas ay '%<' lamang (na nangangahulugang pangalan ng unit)
at mayroon ding ?W: line mapping a C symbol to the bansag. Gayundin ang mga kaugnay na bahagi
ng mga ?H: na linya ay tahasang pinoprotektahan ng isang '?%<' na kundisyon. Tingnan ang simbolo
aliasing paragraph para sa higit pang mga detalye. Ang natitirang linya ay ang opsyonal
lipas na simbolo listahan, na naglilista ng mga lumang katumbas para sa bago simbolo_pangalan.

?C:anumang teksto, para Talasalitaan at config_h.SH
Karaniwang isang komento na naglalarawan sa simbolo ng C, na kukunin ng makegloss
sa Glossary file at ni metaconfig sa config_h.SH file kung ang simbolo ay
wanted (o kung gusto ang alias nito kapag ginamit ang simbolong aliasing).

?C:. Isinasara ang komento ng simbolo ng C.

?H:?simbolo:config_h.SH mga bagay
Ito ang pangkalahatang kahilingan sa pagsasama sa config_h.SH. Ang linya ay nakasulat lamang kapag
ang nagbabantay simbolo ay talagang gusto. Ang pangkalahatang anyo na ito ay kailangan kapag C simbolo
ginamit ang aliasing. Kung hindi, kung gagamit ka ng isa sa iba pang "standard" na mga form, ang
ang pagbabantay ay awtomatikong ginagawa ng metaconfig mismo.

?H:#$d_var Var "$var"
May kondisyong tumutukoy sa Var C simbolo sa $var kailan nakatakda sa 'magtakda'. Nagpapahiwatig ng a
'?Var:' kalagayang nagbabantay, at metaconfig awtomatikong nagli-link Var sa dalawang shell nito
variable dependencies (ibig sabihin pareho $d_var at $var ay i-flag bilang karaniwan if Var is
ginamit sa mga mapagkukunan ng C).

?H:#define Var [opsyonal teksto]
Laging tinutukoy ang Var C simbolo sa ilang halaga. Nagpapahiwatig ng '?Var:' kondisyong nagbabantay.
Ang isang awtomatikong shell dependency ay ginawa sa unit mismo.

?H:#define VAR(x,y,z) $var
Palaging tinutukoy ang macro Var upang maging halaga ng $var variable. Ito ay hanggang sa
yunit upang matiyak $var nagtataglay ng isang makabuluhang halaga. Isang awtomatikong dependency sa pagitan ng C
macro Var at ang shell variable ay itinatag, at ang buong linya ay binabantayan ng isang
implicit '?Var:'.

?H:#$d_var Var
May kondisyong tumutukoy Var if $d_var ay nakatakda sa 'magtakda'. Nagpapahiwatig ng '?Var:' nagbabantay
kundisyon. Ang isang awtomatikong shell dependency ay nabuo patungo $d_war.

?H:#define Var "$var"
Nagtatalaga ng naka-configure na halaga sa Var C simbolo. Nagpapahiwatig ng '?Var:' gurading kondisyon.
Ang isang awtomatikong shell dependency ay nabuo upang i-link Var at $var.

?H:. Isinasara ang config_h.SH mga kahilingan sa pagsasama.

?M:C simbolo: C dependencies
Ipinapakilala ang magic na kahulugan tungkol sa simbolo ng C, para sa confmagic.h, at tinutukoy ang
simbolo ng pagbabantay para sa natitirang ?M: mga kahulugan. Tahimik na ipinahihiwatig ng linyang ito
'?W:%<:C simbolo', ibig sabihin, mai-load ang unit sa Configure kung lilitaw ang simbolo ng C
sa loob ng C sources, magic man ang ginagamit o hindi. Ang mga dependency ng C ay isinaaktibo
kapag ginamit ang salamangka, upang mapilitan ang kanilang kahulugan config_h.SH. Gayunpaman, kung
ang magic ay hindi ginamit ngunit lumilitaw ang simbolo ng C sa pinagmulan nang walang kinakailangang C
dependencies, ikaw ay babalaan sa bawat oras na ang Wanted file ay binuo, dahil ito ay maaaring
isang isyu sa portability (at dahil din ang unit ay na-load nang walang kondisyon sa
I-configure tuwing ginagamit ang simbolo ng C, anuman ang iba pang mga linyang ?C: mula sa
yunit).

?M:cpp defs
Tinutukoy ang magic cpp mapping na ipapakilala sa confmagic.h sa tuwing may kinalaman
simbolo ang ginagamit. May implicit na '?sym' nagbabantay kung saan sym ay ang pangalan ng simbolo
tinukoy ng nangungunang ?M: linya.

?M:. Isinasara ang confmagic.h kahilingan sa pagsasama.

?W:talukap ng alimango simbolo listahan:C simbolo listahan
Itinatali ang kapalaran ng mga simbolo ng shell sa mga simbolo ng C: kung alinman sa C
ang mga nakalistang simbolo ay gusto, pagkatapos ang lahat ng mga simbolo ng shell ay minarkahan bilang gusto. Kapaki-pakinabang sa
puwersahin ang pagsasama ng isang unit (nakatakda ang listahan ng simbolo ng shell sa '%<') kapag ang presensya ng ilang C
natukoy ang simbolo. Ang listahan ng simbolo ng shell ay maaaring iwanang walang laman, upang makinabang mula sa gilid
epekto ng lokasyon ng simbolo ng C sa loob ng builtin na pre-processor (symbol being tinukoy
para sa pre-processor na iyon kung matatagpuan sa pinagmulan). Upang maghanap ng mga pattern na may espasyo
sa kanila, kailangan mong sipiin ang mga simbolo ng C sa loob ng mga simpleng panipi, tulad ng sa 'struct
timezone'.

?V:Basahin lamang simbolo:basa sulat simbolo
Ito ay isang metalint pahiwatig at dapat gamitin lamang sa mga espesyal na yunit na nag-e-export ng ilang shell
mga variable. Ang mga variable bago ang gitnang ':' ay na-export na read-only (binabago ang mga ito
ay magbibigay ng babala), habang ang ibang mga simbolo ay maaaring malayang basahin at baguhin.

?F:file nilikha
Ang linyang ito ay may dalawang layunin: ito ay a metalint pahiwatig, at isa ring placeholder para sa
hinaharap jmake gamitin. Dapat itong maglista ng tatlong uri ng mga file: ang pansamantalang isa na
nilikha para sa isang pagsubok, ang mga pribadong UU na ginawa sa direktoryo ng UU para sa ibang pagkakataon
perusal, at ang mga pampublikong naiwan sa root directory ng package. Pansamantala
dapat na nakalista ang mga file na may naunang '!' character (ibig sabihin "hindi! hindi na sila muling ginagamit
mamaya!"), ang mga pribadong UU file ay dapat unahan ng './' (ibig sabihin: gamitin ang mga ito, sabihin
./file, Hindi lamang file), at ang mga pampubliko ay dapat na pinangalanang as-is.

?T:talukap ng alimango mga pansamantalang panahon
Isa pa metalint pahiwatig. Inililista ng linyang ito ang lahat ng mga variable ng shell na ginamit bilang mga pansamantalang panahon
sa loob ng seksyon ng shell ng yunit na ito.

?D:simbolo='halaga'
Value ng initialization para sa mga simbolo na ginagamit bilang conditional dependencies. Kung wala ?D: line is
natagpuan, pagkatapos ay isang null na halaga ang ginagamit sa halip. Ang metalint babalaan ka ng programa kung a
ang simbolo ay ginagamit kahit isang beses lang bilang conditional dependency at walang proper
?D: initialization. Isang magandang kasanayan na idagdag ang mga linyang iyon kahit na para sa isang null
pagsisimula dahil binibigyang-diin nito ang posibleng opsyonal na katangian ng isang simbolo.

?O:anumang mensahe ikaw gusto
Ang direktiba na ito ay nagpapahiwatig na ang yunit na ito ay hindi na ginagamit sa kabuuan. Sa tuwing gumagamit ng anuman
ng mga simbolo nito ay ginawa (o hindi direktang paggamit sa pamamagitan ng mga dependency), ang mensahe ay naka-output
ang screen (sa stderr). Maaari kang maglagay ng isang ore pang mga linya, kung saan ang bawat linya ay gagawin
i-print, sa pagkakasunud-sunod.

?LINT:metalint pahiwatig
Tingnan ang metalint manu-manong pahina para sa pagpapaliwanag ng mga natatanging pahiwatig na maaaring
ginagamit.

?SA LOOB:Pinasimulan code
Ang inisyal na code na tinukoy ng linyang ito ay ilo-load sa tuktok ng
I-configure ang script kung kailangan ang unit.

C Icon Pagbabawas
Minsan hindi pwedeng umasa metaconfigsariling default na seleksyon para sa config_h.SH
mga komento at kahulugan ng simbolo ng C. Doon pumapasok ang aliasing. Dahil ito ay sa halip
mahirap ipaliwanag, pag-aaralan natin ang isang halimbawa para maunawaan ang pinagbabatayan na mekanismo.

Ang d_const.U unit ay sumusubok na matukoy kung ang iyong C compiler ay kilala o hindi tungkol sa const
keyword. Kung hindi, gusto naming i-remap ang keyword na iyon sa isang null string, upang hayaan ang
pagsasama-sama ng programa. Bukod dito, gusto naming awtomatikong i-trigger ang pagsubok kapag ang const salita
Ginagamit.

Narito ang mga nauugnay na bahagi ng d_const.U unit:

?MAKE:d_const: cat cc ccflags Setvar
?MAKE: -piliin magdagdag ng $@ %
?S:d_const:
?S: Ang variable na ito ay may kondisyong tumutukoy sa simbolo ng HASCONST, na
?S: ay nagpapahiwatig sa C program na ito C compiler alam tungkol sa
?S: uri ng const.
?S:.
?C:HASCONST ~ %<:
?C: Ang simbolo na ito, kung tinukoy, ay nagpapahiwatig na alam ng C compiler na ito
?C: yung const type. Hindi na kailangang aktwal na subukan para sa simbolo na iyon
?C: sa loob ng iyong mga programa. Ang paggamit lamang ng "const" na keyword ay
?C: i-trigger ang mga kinakailangang pagsubok.
?C:.
?H:?%<:#$d_const HASCONST /**/
?H:?%<:#ifndef HASCONST
?H:?%<:#define const
?H:?%<:#endif
?H:.
?W:%<:const
?LINT:set d_const
?LINT:kilalang const
: suriin para sa const keyword
echo " "
echo 'Sinusuri upang makita kung alam ng iyong C compiler ang tungkol sa "const"...' >&4
/bin/cat >const.c <<'EOCP'
main ()
{
const char *foo;
}
EOCP
kung $cc -c $ccflags const.c >/dev/null 2>&1 ; pagkatapos
val="$define"
echo "Oo, totoo."
iba
val="$undef"
echo "Hindi, hindi."
fi
itakda ang d_const
eval $setvar

Una nating napansin ang paggamit ng isang ?W: na linya, na karaniwang nagsasabing: "Ang yunit na ito ay gusto kapag ang
const keyword ay ginagamit sa isang C file.". Upang may kondisyong remap const sa isang null
string sa config.h, pinili kong tukuyin nang may kondisyon HASCONST sa pamamagitan ng $d_const.

Gayunpaman, nagdudulot ito ng problema, dahil ang HASCONST simbolo ay hindi gagamitin sa
mga mapagkukunan, tanging ang const ang token ay. At ang ?H: line defining HASCONST ay pahiwatig
binabantayan ng '?HASCONST'. Samakatuwid, dapat nating idagdag ang tahasang '?%<' na hadlang upang sabihin
metaconfig na dapat isama ang mga linyang iyon config_h.SH tuwing may simbolo na '%<'
gets wanted (%< ay tumutukoy sa pangalan ng unit, dito d_const).

Iyan ay halos perpekto, dahil ang ?W: linya ay gusto d_const kailanman const ay ginagamit, kung gayon
ang ?H: na mga linya ay isasama sa config_h.SH file. Gayunpaman, ang nangungunang komento (?C:
linya) na nakakabit sa HASCONST ay mismong binabantayan din sa pamamagitan ng HASCONST, ibig sabihin, mayroon itong implicit
'?HASCONST' pagpilit. Samakatuwid ang pangangailangan para sa pag-alyas ang HASCONST simbolo sa '%<'.

Ang natitirang bahagi ng yunit (ang bahagi ng shell) ay talagang diretso. Simple lang
sinusubukang mag-compile ng sample C program gamit ang const keyword. Kung ito ay maaari, pagkatapos ay ito ay
magtakda $d_const sa pamamagitan ng $setvar fonction (tinukoy ng Setvar.U yunit). Tingnan ang talata
tungkol sa mga espesyal na yunit para sa higit pang mga detalye.

gumawa Command
Sa ?MAKE: command line, maaari kang magsulat ng shell command na ipapatupad bilang-ay o a
espesyal -Pumili utos na nakulong ni metaconfig at na-parse para makita kung ano ang dapat
tapos na. Ang nangungunang '-' ay nariyan lamang upang maiwasan gumawa mula sa pagkabigo kapag bumalik ang utos
isang non-zero status -- hindi talaga kailangan dahil ginagamit namin 'gumawa -n' upang malutas ang
dependencies, ngunit ipinapayo ko sa iyo na panatilihin ito kung sakaling maging mandatory ito sa mga susunod na bersyon.
Ang syntax ng pumili ang utos ay:

-Pumili cmd $@ target_file

saan $@ ay ang karaniwang macro sa loob ng Makefiles na nakatayo para sa kasalukuyang target (ang pangalan
ng unit na ginagawa, na tinanggal ang panghuling .U extension). Ang cmd bahagi ay ang
tunay metaconfig utos na patakbuhin, at ang target_file ay isa pang parameter, kung saan
ang interpretasyon ay nakasalalay sa cmd mismo. Mayroon din itong pinal na extension na .U na hinubad at
karaniwang tumutukoy sa isang unit file, maliban kung ito ay nagsisimula sa './' kung saan ito ay tumutukoy sa isa
ng metaconfig kontrolin ang mga file sa '.MT direktoryo.

Ang magagamit na mga utos ay:

idagdag Idinagdag ang target_file sa I-configure ang.

add.Config_sh
Pinuno ang bahaging iyon ng I-configure ang paggawa ng config.sh file. Ginamit lang
ang mga variable ay idinagdag, ang mga may kundisyon (mula sa mga dependency na may kondisyon) ay
nilaktawan.

add.Null Idinaragdag ang seksyong nagpapasimula sa lahat ng mga variable ng shell na ginamit sa isang walang laman na string.

c_h_weed Gumagawa ng config_h.SH file. Ang mga kinakailangang linya lamang ang naka-print.

cm_h_weed Gumagawa ng confmagic.h file. Ang mga kinakailangang linya lamang ang naka-print. Ito
Ang command ay pinagana lamang kapag ang -M switch ay ibinigay, o kapag a confmagic.h file
mayroon na.

malapit.Config_sh
Idinaragdag ang panghuling simbolo ng 'EOT' sa isang linya nang mag-isa upang tapusin ang narito na dokumento
bumuo ng paggawa ng config.sh file.

prepend Prepends ang nilalaman ng target sa target_file kung walang laman ang file na iyon.

weed Idinaragdag ang unit sa I-configure ang tulad ng idagdag command, ngunit gumawa ng ilang karagdagang mga pagsubok
para tanggalin ang '?simbolo' at '%simbolo' mga linya mula sa target_file kung ang simbolo
ay hindi gusto o may kondisyong gusto. Ang form na '%' ay ginagamit lamang sa loob ng
metaconfig habang gumagawa ng sarili nitong mga .U na file sa '.MT' direktoryo.

punasan Kapareho ng idagdag talaga, ngunit nagsasagawa ng karagdagang pagpapalit ng macro. Ang
ang mga magagamit na macro ay inilarawan sa Hardwired Macros talata

Bilang isang tandaan, metaconfig bumubuo ng a -cond utos sa loob upang harapin ang may kondisyon
dependencies. Hindi mo ito dapat gamitin nang mag-isa, ngunit makikita mo ito kung i-scan ang
nabuo Makefile nasa .MT direktoryo.

Hardwired Macros
Ang mga sumusunod na macro ay kinikilala ng punasan utos at pinalitan bago isama sa
I-configure ang:

Ang base revision number ng package, na nagmula sa .balot.

Ang kasalukuyang petsa.


Ang e-mail address ng nagpapanatili ng package na ito, na nagmula sa iyong
.balot.


Ang pangalan ng pakete, bilang nagmula sa iyong .balot file.


Ang antas ng patch ng metaconfig programa (hindi na ginagamit pabor sa ).


Ang antas ng rebisyon ng SVN ng metaconfig programa.

Ang numero ng bersyon ng metaconfig programa.

Ang mga macro na iyon ay pangunahing ginagamit upang makilala ang metaconfig bersyon na nakabuo ng a
partikular na I-configure ang script at para sa kung aling pakete ito ginawa. Ang e-mail address ng
maintainer ay hardwired sa nangungunang mga tagubilin na I-configure ang prints kapag nagsisimula.

kamakailan lamang metaconfig naiintindihan ng mga bersyon ang isang mas pangkalahatang syntax ng form:

<$variable>

na pinapalitan sa Configure-generation time ng halaga ng nagbabago kinuha mula sa iyong
.balot file. Sa kalaunan, mawawala ang lumang hardwired macro format, at <$baserev>
papalitan sa lahat ng ibinigay na yunit.

espesyal Units
Ang mga sumusunod na espesyal na yunit ay ginagamit upang i-factor ang code at magbigay ng mas mataas na antas
mga pag-andar. Maaari silang gumawa ng shell script na maaaring sourced o isang shell
variable na maaaring eval'ed. Ang pagpasa ng parameter ay ginagawa sa pamamagitan ng mga kilalang variable, alinman
pinangalanan o anonymous tulad ng $1, $2, atbp... (na madaling itakda sa pamamagitan ng shell itakda
operator). Kailan I-configure ang executes, ito ay lumilikha at napupunta sa a UU direktoryo, kaya bawat
ang ginawang script ay namamalagi doon at hindi nakakasagabal sa mga file mula sa iyong package.

Narito ang mga sepcial unit na dapat mong malaman, at kung paano gamitin ang mga ito.

Cppsym.U
Ang yunit na ito ay gumagawa ng shell script na tinatawag na Cppsym, na maaaring gamitin upang matukoy
kung anumang simbolo sa isang listahan ay tinukoy ng C preprocessor o C compiler na mayroon ka
tinukoy. Maaari nitong matukoy ang katayuan ng anumang simbolo, kahit na ang mga simbolo ay nasa
(listahan ng katangian) ay mas madaling matukoy.

Csym.U
Itinatakda nito ang variable na $csym shell, na ginagamit sa loob ng I-configure ang upang suriin kung a
ang ibinigay na simbolo ng C ay tinukoy o hindi. Ang karaniwang paggamit ay:

itakda ang resulta ng simbolo [-fva] [nakaraan]
eval $csym

Itatakda nito ang resulta variable sa 'true' kung ang function [-f], variable [-v] o
Ang array [-a] ay tinukoy, 'false' kung hindi. Kung ang isang nakaraang halaga ay ibinigay at ang -r
switch ay ibinigay sa I-configure ang (Tingnan ang I-configure ang Options talata), pagkatapos ay iyon
ang halaga ay muling ginagamit nang walang pagtatanong.

Ang paraan ng pag-compute na ito ay nakadepende sa sagot na ibinibigay ng user sa tanong
I-configure ang magtatanong tungkol sa kung dapat itong gumanap ng isang nm bunutan o hindi. Kung ang
isinagawa ang pagkuha, ang unit ay tumitingin lamang sa listahan ng simbolo, kung hindi man
nagsasagawa ito ng compile-link test, maliban kung -r ay ibinigay upang muling gamitin ang dating nakalkula
halaga, natural...

End.U
Sa pamamagitan ng pagkopya sa unit na ito sa iyong pribado U direktoryo at pagdaragdag ng mga dependency sa
?MAKE: linya, maaari mong pilitin na i-load ang isang naibigay na unit I-configure ang kahit hindi naman
kung hindi gusto. Ang ilang unit ay maaari lamang pilitin I-configure ang doon.

Filexp.U
Gumagawa ang unit na ito ng shell script filexp na magpapalawak ng mga filename na nagsisimula sa
tildes. Ang karaniwang paggamit ay:

exp_name=`./filex $name`

upang italaga ang pinalawak na pangalan ng file sa exp_name.

Findhdr.U
Ang yunit na ito ay gumagawa ng a findhdr script na ginagamit upang mahanap ang mga file ng header sa
$usrinc o iba pang mga dayuhang lugar gamit ang mga kakayahan ng cpp. Ang script ay binibigyan ng isang
isama ang pangalan ng base ng file tulad ng 'stdio.h' o 'sys/file.h' at ibinabalik nito ang buong landas ng
ang inlcude file at isang zero na status kung natagpuan, o isang walang laman na string at isang non-zero na status
kung hindi mahanap ang file.

Getfile.U
Gumagawa ang unit na ito ng kaunting shell code na dapat kunin para makakuha ng file
pangalanan at gumawa ng ilang mga pagsusuri sa katinuan. Opsyonal, ang isang ~name expansion ay isinasagawa.

Upang magamit ang yunit na ito, $rp at $dflt dapat hawakan ang tanong at ang default na sagot, na
ay ipapasa bilang-ay sa myread script (tingnan ang paparating na Myread.U). Ang $fn
kinokontrol ng variable ang operasyon at ibabalik ang resulta sa $ans.

Upang mahanap ang isang file o direktoryo, ilagay ang 'f' o 'd' sa f~/. Kung may lalabas na '~', pagkatapos ay ~name
pinapayagan ang pagpapalit. Kung may lalabas na '/', mga absolute pathname lang ang tinatanggap at
~Ang mga pagpapalit ng pangalan ay palaging pinalawak bago bumalik. Kung tinukoy ang '+',
Ang mga pagsusuri sa pagkakaroon ay nilaktawan. Kung lalabas ang 'n' sa loob $fn, pagkatapos ay pinapayagan ang gumagamit na
sumagot ng 'wala'.

Karaniwan, maliban kung hiningi mo ang portability, nangyayari ang pagpapalit ng ~name kapag hiniling.
Gayunpaman, may ilang mga pagkakataon na nais mong i-bypass ang portability at pilitin ang
pagpapalit. Maaari mong gamitin ang titik na 'e' (palawakin) upang gawin iyon.

Kung ang espesyal na 'l' (locate) na uri ay ginamit, kung gayon ang $fn variable ay dapat magtapos sa isang ':',
sinusundan ng isang file basename. Kung ang sagot ay isang direktoryo, ang file basename ay magiging
idinagdag bago ang pagsubok para sa pagkakaroon ng file. Ito ay kapaki-pakinabang sa mga tanong na istilo ng paghahanap
ganito:

dflt='~news/lib'
: hindi na kailangang tukuyin ang 'd' o 'f' kapag ginamit ang 'l'
fn='l~:aktibo'
rp='Nasaan ang aktibong file?'
. ./getfile
active="$ans"

Bilang karagdagan, ang titik na 'p' (path) ay maaaring gamitin kasama ng 'l' upang sabihin
makakuha na ang isang sagot na walang '/' sa loob nito ay dapat tanggapin, sa pag-aakalang gagawin nito
nasa PATH ng lahat sa oras na kakailanganin ang halagang ito.

Kapaki-pakinabang din ang posibilidad na tukuyin ang isang listahan ng mga sagot na dapat tanggapin
verbatim, na nilalampasan ang lahat ng mga tseke. Ang listahang ito ay dapat nasa loob ng panaklong at mga item
dapat pinaghihiwalay ng kuwit, na walang mga interleaving space. Huwag kalimutang i-quote ang
nagreresultang string dahil ang panaklong ay makabuluhan sa shell. Halimbawa:

dflt='/bin/install'
fn='/fe~(install,./install)'
rp='Gamitin ang aling programa sa pag-install?'
. ./getfile
install="$ans"

hahayaan ang user na tukuyin lamang ang ganap na kwalipikadong mga landas na tumutukoy sa mga umiiral nang file,
ngunit payagan pa rin ang mga espesyal na "install" at "./install" na mga sagot bilang-ay (ipagpalagay na
Siyempre may haharap sa kanila lalo na sa susunod sa kadena dahil ginagawa nila ito
hindi umaayon sa pangkalahatang inaasahang frame).

Kung ang sagot sa tanong ay 'wala', ang mga pagsusuri sa pagkakaroon ay nilalaktawan at
ibinalik ang walang laman na string. Tandaan na mula noon makakuha tawag myread sa loob, lahat
ang mga tampok na magagamit sa myread mag-apply dito sa.

Kung kailangan ang isang ganap na pinalawak na halaga (halimbawa sa isang Makefile), maaari mong gamitin
ang $ansexp variable na palaging naka-set up nang maayos ng makakuha bilang pinalawak
na bersyon ng $ans. Siyempre, hindi ito magpapalawak ng ~pangalan kung hindi mo pinayagan iyon sa
unang lugar sa $fn variable

Inhdr.U
Ang yunit na ito ay gumagawa ng $inhdr shell variable, na ginagamit sa loob ng I-configure ang upang suriin
kung mayroong isang hanay ng mga header o wala. Ang karaniwang paggamit ay:

itakda ang header i_header [ header2 i_header2 ... ]
eval $inhdr

Magpi-print iyon ng mensahe, na nagsasabi kung natagpuan ang header o hindi at itatakda ang
i_header variable na naaayon. Kung higit sa isang header ang tinukoy at ang una
header ay hindi natagpuan, subukan namin ang susunod na isa, hanggang sa ang listahan ay walang laman o isa ay natagpuan.

Inlibc.U
Ang yunit na ito ay gumagawa ng $inlibc shell variable, na ginagamit sa loob ng I-configure ang upang suriin
kung ang isang ibinigay na C function ay tinukoy o hindi. Ang karaniwang paggamit ay:

itakda ang function na d_func
eval $inlibc

Iyan ay magpi-print ng isang mensahe, na nagsasabi kung ang function ay natagpuan o hindi at nakatakda
$d_func naaayon. Sa panloob, ginamit nito ang $csym gawain.

Loc.U
Ang mahalagang yunit na ito ay gumagawa ng shell script loc na maaaring gamitin upang malaman kung saan
sa isang listahan ng mga direktoryo ang isang naibigay na file ay namamalagi. Ang unang argumento ay tumutukoy sa file sa
na matatagpuan, ang pangalawang argumento ay kung ano ang ibabalik kung nabigo ang paghahanap, at ang
Ang reamining argument ay isang listahan ng mga direktoryo kung saan hahanapin ang file. Para sa
halimbawa:

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

itatakda $dflt sa X kung hindi sendmail.cf Ang file ay natagpuan sa ilalim ng mga nakalistang direktoryo,
o tulad ng isang bagay /usr/lib/sendmail.cf sa ilang mga sistema. Tingnan din Getfile.U.

MailAuthor.U
Kailangang isama ang unit na ito sa ?MAKE: line ng sarili mong pribadong End.U na gagawin
ito sa I-configure ang. Nag-aalok ito sa gumagamit na irehistro ang kanyang sarili sa may-akda, opsyonal
inaabisuhan kapag dumating ang mga bagong patch o awtomatikong natatanggap ang mga ito kapag naibigay.
Kailangan mong mag-install mailagent upang gawin ito (hindi bababa sa bersyon 3.0).

MailList.U
Kailangang isama ang unit na ito sa ?MAKE: line ng sarili mong pribadong End.U na gagawin
ito sa I-configure ang. Nag-aalok ito sa user na mag-subscribe o mag-unsubscribe sa isang mailing list
kung saan nagaganap ang talakayan na may kaugnayan sa package. Kailangan mong tumakbo packinit
at sagutin ang mga tanong na nauugnay sa mailing list para i-set up ang mga tamang variable sa iyong
.balot bago maging operational ang unit na ito.

Myinit.U
Kopyahin ang unit na ito sa iyong pribado U direktoryo upang magdagdag ng iyong sariling mga default na halaga sa ilan
panloob na mga variable. Na-load ang unit na ito sa I-configure ang pagkatapos ng lahat ng default
ang mga initialization ay nagawa na.

Myread.U
Ang yunit na ito ay gumagawa ng myread shell script na dapat kunin upang magawa ang a
basahin. Pinapayagan nito ang mga pagtakas ng shell, default na pagtatalaga at pagsusuri ng parameter, bilang
dokumentado sa yunit ng Instruct.U. Pinapayagan din nito ang dynamic na setting ng -d pagpipilian,
na gagamitin para sa natitirang script execution.

Upang magamit ang yunit na ito, $rp dapat hawakan ang tanong at $dflt dapat naglalaman ng default
sagot. Ang tanong ay ipi-print ng script mismo, at ang resulta ay ibabalik
nasa $ans variable

Narito ang karaniwang paggamit:

dflt='y'
rp='Tanong?'
. ./myread
value="$ans"

Tingnan ang mismong unit para sa higit pang impormasyon.

Oldconfig.U
Ang unit na ito ay dapat na bahagi ng iyong dependency ?MAKE: line kapag sinubukan ng ilan sa iyong mga unit
upang muling gamitin ang isang lumang halaga ng simbolo. Ang yunit na ito ay responsable para sa pagkuha ng mga lumang sagot
mula config.sh o pagbibigay ng mga kapaki-pakinabang na pahiwatig kapag tumatakbo sa isang partikular na platform para sa
unang beses. Tingnan ang I-configure ang Hint talata para sa karagdagang impormasyon tungkol sa mga pahiwatig.

Prefixit.U
Ang layunin ng unit na ito ay makita ang mga pagbabago sa direktoryo ng prefix ng pag-install sa
awtomatikong kalkulahin muli ang naaangkop na mga default mula sa mga nakaraang sagot. Ito ay umaasa sa
halaga ng $oldprefix variable na nagtataglay ng nakaraang direktoryo ng prefix kapag ito
nagbago, at walang laman kung hindi man. Halimbawa, kung ang prefix ay binago mula sa / opt sa
/ usr / lokal, pagkatapos ay babaguhin ang nakaraang binary installation directory mula sa
/opt/bin sa / usr / local / bin, o mananatiling hindi magbabago kung ito ay, sabihin nating, / bin.

Kailangan mong tumawag itakda bago mag-isyu ng isang eval on $prefixit, Tulad ng:

itakda ang dflt var [dir]
eval $prefixit

na magtatakda $dflt sa $var or $prefix/dir depende kung nanatili ang unlapi
pareho man o hindi. Kung dir ay ang string wala, isang solong halaga ng espasyo sa $dflt ay pinananatili bilang-
ay, kahit na nagbabago ang prefix. Kung dir ay tinanggal, kung gayon $dflt ay nakatakda sa isang walang laman
string kung binago ang prefix, sa $var kung hindi man.

Prefixup.U
Ang layunin ng unit na ito ay katulad ng sa Prefixit.U, ibig sabihin, nakakatulong itong ayusin ang
default na string upang tumanggap ng mga pagbabago sa prefix. Gayunpaman, ang variable ng shell $prefixup,
kapag nasuri, ibabalik lamang ang ~mga pagpapalawak ng pangalan, dapat gamitin ng prefix ang naturang pagtakas
mekanismo. Gamitin ito bilang:

itakda ang dflt
eval $prefixup

bago mag-prompt sa pamamagitan ng makakuha halimbawa. Kung ang unlapi ay hindi gumagamit ng ~pangalan
pagpapalawak, kung gayon ang nasa itaas ay magiging isang no-op sa y variable, natural.

Typedef.U
Ang yunit na ito ay gumagawa ng $typedef shell variable, na ginagamit sa loob ng I-configure ang upang suriin
kung mayroong typedef o wala. Ang karaniwang paggamit ay:

itakda ang typedef val_t default [kasama ang ]
eval $typedef

Itatakda nito ang variable val_t sa halaga ng default kung ang typedef ay hindi natagpuan
kabilang sa mga nakalista isama ang mga file, o sa typedef kung natagpuan. Kung walang kasamang mga file ay
tinukoy, tumitingin ang unit lamang. Kung tutukuyin mo ang ilang kasama, lamang
tinitignan ang mga iyon.

Unix.U
Ang layunin ng yunit na ito ay tukuyin ang ilan sa mga pinakakaraniwang UNIX-ism sa pamamagitan ng mga variable
na maaaring mabago mula sa command line o sa pamamagitan ng wastong mga file ng pahiwatig. Sa partikular,
$_exe, $_o at $_a ay nakatakda. Ang lahat ng mga yunit ay dapat sumangguni sa $_o at hindi sa .o direkta.
Ang '.' ay bahagi ng mga variable na ito.

Setvar.U
Ang yunit na ito ay gumagawa ng variable, na ginagamit sa loob ng I-configure ang upang itakda ang a
magtakda/undef value sa isang ibinigay na simbolo, naglalabas ng babala kapag bigla itong nagbago
mula sa dating halaga. Halimbawa:

val="$define"
itakda ang d_variable
eval $setvar

Kung ang nakaraan $d_variable ang halaga ay hindi null at $val ay iba, isang "whoa"
inilabas ang babala.

Whoa.U
Ang yunit na ito ay gumagawa ng whoa script, na naglalabas ng babala kapag ang halaga sa variable
kaninong pangalan $var ay hindi katulad ng dati nitong halaga na hawak $ay. sa
bumalik, $td at $tu hawakan ang tamang halaga sa magtakda or undef ang variable. Tingnan mo
mga halimbawa sa Inlibc.U.

Itinayo Pre-processor
Bawat unit na isasama I-configure ang ay pinapatakbo sa pamamagitan ng built-in na pre-processor. pre-
Ang mga pahayag ng processor ay ipinakilala ng karakter na '@' ('#' ay ang komento ng shell
karakter). Gumagana lamang ito tulad ng ginagawa ng C pre-processor ngunit nagbibigay-daan para sa shell at perl
nakatakas. Narito ang mga magagamit na function:

@kung pagpapahayag
If pagpapahayag ay totoo, ipagpatuloy ang paglo-load ng code hanggang sa @end, @elsif o @else.

@elsif pagpapahayag
Alternatibong pagpipilian. Kung pagpapahayag ay totoo, ipagpatuloy ang paglo-load ng code hanggang @end,
isa pang @elsif o @else.

@else Default na code na ilo-load kung ang @if pagpapahayag ay hindi totoo at wala sa
opsyonal na @elsif ang tumugma. Mag-load hanggang @end.

@end Isara ang conditional loading statement na binuksan ni @if.

@define simbolo
Sinasabi sa pre-processor na simbolo ay tinukoy mula ngayon.

Ang conditional pagpapahayag maaaring magsama ng mga pangalan ng simbolo (totoo ang value kung gusto ang simbolo o
tinukoy sa pamamagitan ng @define o shell/perl escapes. Ang mga atom na iyon ay maaaring pagsamahin gamit ang
tradisyonal na boolean operator '!' para sa negasyon, '&&' para sa lohikal at, at '||' para sa lohikal
o.

Ang text na nakapaloob sa loob ng iisang bracket ay isang shell test, habang ang text sa pagitan ng double braket ay
isang perl na pagsubok. Lalo na ang mga expression:

{ talukap ng alimango teksto }
{{ perlas teksto }}

ay isinalin sa:

if talukap ng alimango teksto >/dev/null 2>&1; pagkatapos ay lumabas sa 0; iba ang labasan 1; fi
kung (perlas teksto) {exit 0;} else {exit 1;}

at ang exit status ay ginagamit sa karaniwang paraan upang makakuha ng boolean value, ibig sabihin, 0 ay totoo at
lahat ng iba ay hindi totoo. Tandaan na ang mga simpleng kundisyon lamang ang maaaring ipahayag sa perl, hanggang
ang ilang kumplikadong code ay maaaring mai-load sa loob metaconfig at pinaandar.

Ang built-in na pre-processor ay maaaring gamitin upang maayos na ibagay ang ilang mga yunit (tingnan ang d_gethname.U para sa isang
kumplikadong halimbawa) depende sa mga simbolo na aktwal na ginagamit ng programa o ng mga file
naroroon sa pamamahagi. Halimbawa, ang Oldconfig.U gumagamit ng pagsubok tulad ng:

@if {test -d ../hints}

at I-configure ang maglalaman lamang ng code na nakadepende sa hint kung mayroong a pahiwatig direktoryo sa
nangungunang antas ng direktoryo ng package. Tandaan na ang mga pagsubok ay pinapatakbo mula sa loob ng '.MT' direktoryo,
kaya kailangan ang '../' sa pagsusulit.

Ang pre-processor ay maaari ding gamitin upang maiwasan ang paglalagay ng walang kwentang code kapag ang isang simbolo ay hindi
tinukoy. Ang mga yunit na tumutukoy sa higit sa isang simbolo ay mapoprotektahan sa ganoong paraan (dahil ang unit ay
na-load sa kabuuan) sa pamamagitan ng pangangalap ng code na umaasa sa simbolo sa loob ng isang @if/@end na pares. Para sa
halimbawa:

@if I_TIME || I_SYS_TIME || I_SYS_TIME_KERNEL
need_time_h='true'
@iba
need_time_h='false'
@katapusan

susubok kung ang source code ay gumagamit ng isa sa tatlong simbolo na kumokontrol
ang oras.h or sys/time.h pagsasama at tukuyin ang simbolo ng shell nang naaayon. Nagbibigay iyon
I-configure ang isang puna sa kung ano ang kailangan ng mga mapagkukunan at maiwasan ang disbentaha ng pagkakaroon ng maayos
frozen na mga yunit.

Sa pamamagitan ng mga linyang '?W:', maaari kang makakuha ng mga intersting kumbinasyon. Halimbawa, ang i_time.U yunit
kailangang malaman kung ginagamit ng mga C source ang istruktura timezone uri. Samakatuwid,
Ang linya:

?W::timezone

ay ginagamit para sa side-effect nito sa pagtukoy ng simbolo timezone para sa pre-processor. Ang
maaaring sabihin ng unit code:

@kung timezone
para sa s_timezone sa '-DS_TIMEZONE' ''; gawin
@iba
s_timezone=''
@katapusan

... code gamit ang s_timezone ...

@kung timezone
tapos
@katapusan

at magkaroon ng dagdag na loop na sumusubok ng dalawang magkakasunod na halaga para sa s_timezone variable, ngunit lamang
kung kinakailangan.

Hindi na ginagamit Mga Simbolo
Ang mga hindi na ginagamit na simbolo ay pinapanatili upang mapagaan ang paglipat sa mas luma metaconfig mga yunit. Maliban kung
ang -o ipinasa ang switch sa metaconfig hindi sila papansinin. Gayunpaman, ang isang Hindi na ginagamit file ay
mabuo, na nagsasabi sa iyo kung aling mga file ang gumagamit ng mga hindi na ginagamit na simbolo at kung ano
ay ang mga bagong simbolo na gagamitin.

Ang buhay para sa mga hindi na ginagamit na simbolo ay isang buong rebisyon, ibig sabihin, aalisin ang mga ito kapag ang
ang susunod na rebisyon ng base ay inisyu (siyempre hindi binibilang ang mga upgrade ng patch). Samakatuwid, ito ay
matalinong isalin ang iyong mga mapagkukunan at simulan ang paggamit ng mga bagong simbolo sa lalong madaling panahon.

I-configure ang Hint
Maaaring mangyari na ang panloob na lohika ng pagsasaayos ay gumagawa ng mga maling pagpipilian. Para sa
halimbawa, sa ilang plataporma, ang vfork() system call ay naroroon ngunit sira, kaya dapat
hindi gagamitin. Hindi posibleng isama ang kaalamang iyon sa mga yunit mismo, dahil
maaaring pansamantalang problema iyon na aayusin ng vendor, o isang bagay na iyon
ay ipinakilala ng isang bagong pag-upgrade ng OS.

Anyway, para sa lahat ng maliliit na problemang masyadong partikular sa system, metaconfig
nagbibigay ng suporta sa mga file ng pahiwatig. Upang magamit ito, kailangan mong lumikha ng isang pahiwatig direktoryo sa
direktoryo ng nangungunang antas ng package, at mayroon nito kapag tumakbo ka metaconfig. I-load niyan ang
bahaging nauugnay sa pahiwatig mula sa Oldconfig.U.

Mula noon, maaari mong paunang itakda ang ilan sa mga variable ng shell I-configure ang ginagamit sa isang OS-specific
.sh file. May code sa loob Oldconfig.U na sumusubok na hulaan kung aling mga pahiwatig na file ang kailangan ng
pag-compute ng karaniwang pangalan batay sa pangalan ng system OS, ang pangalan ng kernel, ang release
numero, atbp... Dahil malamang na mabilis na magbago ang impormasyong ito, hindi ko ito idodokumento
dito. Kailangan mong i-reverse engineer ang code mula sa Oldconfig.U.

Kapag una mong inilabas ang iyong package, dapat na walang laman ang iyong direktoryo ng file ng mga pahiwatig. Kung ang
nagrereklamo ang mga gumagamit ng iyong package na may problema sila I-configure ang mga default sa a
partikular na sistema, kailangan mong makita kung ito ay isang problemang partikular sa platform o a
pangkalahatan. Sa dating kaso, oras na para magpakilala ng bagong file ng pahiwatig, habang nasa
sa huli, dapat rebisahin ang kaukulang yunit.

Halimbawa, ang mga SGI system ay kilala na may sira vfork() system call, sa ngayon
pagsusulat. At ang katumbas na pangalan ng file ng pahiwatig ay sgi.sh. Kaya ang kailangan mo lang gawin ay lumikha
a mga pahiwatig/sgi.sh file kung saan mo isinusulat:

d_vfork="$define"

na palaging i-remap vfork on tinidor (Tingnan ang d_vfork.U). Kapag tumatakbo sa mga SGI system para sa
unang beses, I-configure ang malalaman na mayroong isang mga pahiwatig/sgi.sh file, at na kami ay nasa
isang IRIX machine (ang kernel name ay madalas /irix), samakatuwid ito ay magmumungkahi sgi bilang isang
posibleng pahiwatig. Kung tinanggap ito ng gumagamit, at mula noong $d_vfork ang halaga ay binago sa pamamagitan ng
$setvar tawag, a aba! ay ilalabas upang bigyan ng babala na malapit na nating i-override ang halaga
kinalkula ng I-configure ang.

Tandaan na hindi mo kailangang magbigay lahat ang mga pahiwatig na kilala ni Oldconfig.U. Kung ang isang pahiwatig na file ay
nawawala, hindi ito imumungkahi bilang isang posibleng pagpipilian. Ang mga heuristic na pagsubok ay tumakbo upang makalkula
patumpik-tumpik ang mga posibleng hint candidates. Kung mayroon kang mga bagong halaga o iba't ibang mga pagsubok, mangyaring
ipadala mo sila sa akin...

Sobra Pagpipilian
Kung gagawa ka ng a config.over file sa pinakamataas na antas ng direktoryo, I-configure ang tatanungin ka kung ikaw
nais na i-load ito upang i-override ang mga default na halaga. Ginagawa ito bago ang paglikha ng
config.sh file, kaya binibigyan ka nito ng pagkakataong i-patch ang mga halagang nakaimbak doon.

Naiiba ito sa diskarte ng mga pahiwatig dahil isa itong lokal na file, kung saan ang user
malayang lumikha para sa kanyang sariling paggamit. Hindi ka dapat magbigay ng ganoong file sa iyong sarili, ngunit hayaan ang
alam ng user ang tungkol sa posibilidad na ito.

I-configure ang Options
Ang I-configure ang Maaaring tawagan ang script na may ilang mga opsyon na tinukoy sa command line, sa
bahagyang baguhin ang pag-uugali nito. Narito ang mga pinapayagang opsyon:

-d Gumamit ng mga default para sa lahat ng sagot.

-e Magpatuloy nang walang pagtatanong lampas sa produksyon ng config.sh.

-f file Gamitin ang tinukoy na file bilang default na configuration. Kung hindi ginagamit ang switch na ito,
ang pagsasaayos ay kinuha mula sa config.sh, kapag naroroon.

-h Mag-print ng mensahe ng tulong at lumabas.

-r Gamitin muli ang halaga ng mga simbolo ng C kung maaari. Malalampasan nito ang magastos nm simbolo
pagkuha. Kung ginamit sa unang pagkakataon (na walang nakaraang configuration file),
I-configure ang ay susubukan na mag-compile at mag-link ng isang maliit na programa upang malaman ang tungkol sa
ang pagkakaroon ng isang simbolo, o kawalan nito.

-s Silent mode. Tanging mga string na naka-print sa file descriptor #4 ang makikita sa
screen (iyan ang mahahalagang mensahe). Hindi posibleng ganap na i-off
anumang output, ngunit maaari mong gamitin ang 'I-configure ang -ders > / dev / null 2> & 1' para magkaroon ng buo
batch run na walang output at walang kinakailangang interaksyon ng user.

-D simbolo=halaga
Pre-define simbolo upang pasanin ang tinukoy halaga. Posible ring gamitin ang '-D
simbolo' na gagamit ng default na halaga ng 'define'.

-E Huminto sa dulo ng mga tanong sa pagsasaayos, pagkatapos gumawa ng a
config.sh. Hindi ito gagawa ng anumang 'gumawa manangan' o .SH file extraction.

-K Maalam na gumagamit. Kapag ginamit mo ang opsyong ito, alam mo kung ano ang iyong ginagawa at
Samakatuwid, ang config.sh Ang file ay palaging hahawakan na parang nilayon
muling ginamit, kahit na ito ay maaaring nabuo sa isang alien system. Ito rin
pinipigilan ang pagpapalaglag kapag I-configure ang nakakakita ng hindi magagamit na C compiler o isang maling set
ng mga watawat ng C. Ang mga karagdagang shortcut ay maaaring i-on din ng opsyong ito sa
kinabukasan. Nakadokumento ang opsyong ito sa I-configure ang mensahe ng paggamit, upang ipaalala sa amin
tungkol sa pagkakaroon nito, ngunit ang ibinigay na paglalarawan ay inaasahan na maging sapat na misteryoso.
:-)

-O Payagan ang mga halagang tinukoy sa pamamagitan ng a -D or -U upang i-override ang mga setting mula sa anumang na-load
configuration file. Hindi ito ang default na gawi dahil ang overriding na kalooban
huwag ipalaganap sa mga variable na nagmula sa mga kasalukuyang binabago mo.
Natural, wala -O, ginagawa lang ang setting kapag walang configuration file
na-load, na ligtas dahil ang mga derivative variable ay hindi pa nakalkula...

-S Magsagawa ng variable substitution sa lahat ng .SH file. Maaari mong pagsamahin ito sa
-f lumipat upang magpalaganap ng anumang configuration na gusto mo.

-U simbolo=
Mga paunang hanay simbolo upang magkaroon ng walang laman na halaga. Posible ring gamitin ang '-U simbolo'
na magtatakda simbolo sa 'undef'.

-V I-print ang numero ng bersyon ng metaconfig na nakabuo nito I-configure ang script
at lumabas.

Tumatakbo kapaligiran
Sa pagsisimula, I-configure ang lumilikha ng lokal UU direktoryo at tumatakbo mula doon. Ang direktoryo
ay inalis kapag nagtatapos ang I-configure, ngunit nangangahulugan ito na dapat mong patakbuhin ang script mula sa isang lugar kung saan
maaari kang magsulat, ibig sabihin, hindi mula sa isang read-only na file system.

Maaari kang tumakbo I-configure ang kahit malayo, gaya ng:

../package/Configure

upang i-configure ang mga mapagkukunan na hindi lokal. Lahat ng nabuong file ay ilalagay
ang direktoryo kung saan mo pinapatakbo ang script. Ginagawa ang mahika na ito salamat sa src.U
unit, na nagtatakda ng $src at $rsrc mga variable upang ituro sa mga mapagkukunan ng package. yun
ang landas ay puno o kamag-anak, depende sa kung I-configure ang ay tinawag sa pamamagitan ng isang buong o
kamag-anak na landas.

Mula sa loob ng UU subdirectory, maaari mong gamitin $rsrc upang ma-access ang mga source file (units
na tumutukoy sa mga source file link na pahiwatig ay dapat palaging gumamit ng mekanismong ito at hindi ipagpalagay ang
ang file ay nasa parent directory). Dapat gamitin ng lahat ng Makefile ang $src variable
bilang isang pointer sa mga mapagkukunan mula sa tuktok ng direktoryo ng build (kung saan I-configure ang ay tumatakbo),
direkta man o sa pamamagitan ng isang setting ng VPATH.

Kapag tumatakbo I-configure ang malayuan, ang mga .SH na file ay kinukuha sa direktoryo ng build, hindi
sa punong pinanggagalingan. Gayunpaman, nangangailangan ito ng ilang uri ng a gumawa suporta para makapag-compile
mga bagay sa isang build directory habang ang mga source ay nasa ibang lugar.

paggamit Salamangka Mga redefinition
Sa pamamagitan ng paggamit ng -M switch, maaaring maganap ang ilang magic remappings sa loob ng a confmagic.h
file. Ang file na iyon ay kailangang isama pagkatapos config.h, siyempre, ngunit din pagkatapos ng lahat ng
iba pang kailangan isama ang mga file. Namely:

#include "config.h"
...
... iba inclusions ...
...
#include "confmagic.h"

Karaniwan, confmagic.h ay susubukang i-remap bcopy() on memcpy() kung hindi bcopy() is
magagamit sa lokal, o pagbabago vfork sa tinidor kapag kinakailangan, kaya ginagawa itong walang silbi
abala tungkol sa MAY_VFORK simbolo.

Nakadokumento ang configuration magic na ito sa Glossary file.

Yunit Template
Mayroong isang set ng mga template ng unit sa metaconfig direktoryo ng pinagmulan, na nilayon upang
gamitin ng isang (hindi pa nakasulat) na programa upang mabilis na makagawa ng mga bagong yunit para sa iba't ibang uri ng
mga sitwasyon. Walang dokumentasyon para sa hindi natapos na proyektong ito, ngunit naisip kong banggitin ko ito
sa manual page kung sakaling gusto mong gawin ito sa iyong sarili at pagkatapos ay i-ambag ito...

MGA AUTHORS

Larry Wall[protektado ng email]> para sa bersyon 2.0.
Harlan Stenn[protektado ng email]> para sa mahahalagang extension ng unit.
Raphael Manfredi[protektado ng email]>.
Marami pang ibang nag-ambag para sa metaconfig mga yunit. Tingnan ang credit file para sa isang listahan.

Gumamit ng metaconfig online gamit ang mga serbisyo ng onworks.net