rc - Online sa Cloud

PROGRAMA:

NAME

rc - shell

SINOPSIS

rc [-deiIlnopsvx] [-c utos] [argumento]

DESCRIPTION

rc ay isang command interpreter at programming language na katulad ng sh(1). Ito ay batay sa
AT&T Plan 9 shell ng parehong pangalan. Ang shell ay nag-aalok ng isang C-like syntax (higit pa kaysa sa
ang C shell), at isang malakas na mekanismo para sa pagmamanipula ng mga variable. Ito ay makatwirang maliit
at makatuwirang mabilis, lalo na kung ihahambing sa mga kontemporaryong shell. Ang paggamit nito ay inilaan
upang maging interactive, ngunit ang wika ay angkop sa mga script.

Opsyon

-c Kung -c ay naroroon, ang mga utos ay isinasagawa mula sa kaagad na sumusunod na argumento.
Anumang karagdagang mga argumento sa rc ay inilalagay sa $*. kaya:

rc -c 'echo $*' 1 2 3

nagpi-print out

+1 2 3

-d Ang watawat na ito ay sanhi rc hindi balewalain ang SIGQUIT o SIGTERM. Sa gayon rc maaaring gawin upang itapon
core kung nagpadala ng SIGQUIT. Ang flag na ito ay kapaki-pakinabang lamang para sa pag-debug rc.

-e Kung ang -e na watawat ay naroroon, kung gayon rc ay lalabas kung ang exit status ng isang command ay
mali (nonzero). rc ay hindi lalabas, gayunpaman, kung ang isang kondisyon ay nabigo, hal, isang kung()
utos.

-i Kung ang -i flag ay naroroon o kung ang input sa rc ay mula sa isang terminal (tulad ng tinutukoy
by isatty(3)) pagkatapos rc papasok interactive mode. Iyon ay, isang prompt (mula sa
$prompt(1)) ay ipi-print bago kumuha ng input line, at rc papansinin
PIRMA.

-I Kung ang -I flag ay naroroon, o kung ang input sa rc ay hindi mula sa isang terminal, kung gayon rc
ay hindi nasa interactive na mode. Walang ipi-print na prompt, at SIGINT ang magdudulot
rc para lumabas.

-l Kung ang -l na watawat ay naroroon, o kung rc's argv[0][0] ay isang gitling (-), pagkatapos rc ay kumilos
bilang login shell. Ibig sabihin, tatakbo ito ng mga command mula sa $home/.rcrc, kung ang file na ito
umiiral, bago basahin ang anumang iba pang input.

-n Ang watawat na ito ay sanhi rc upang basahin ang input nito at i-parse ito, ngunit hindi magsagawa ng anuman
mga utos. Ito ay kapaki-pakinabang para sa pagsusuri ng syntax sa mga script. Kung ginamit sa kumbinasyon
na may -x na bandila, rc ay magpi-print ng bawat command habang ito ay na-parse sa isang form na katulad ng
ang ginagamit para sa pag-export ng mga function sa kapaligiran.

-o Pinipigilan ng watawat na ito ang karaniwang kasanayan ng pagsubok na buksan ang /dev/null sa file
descriptor 0, 1, at 2, kung ang alinman sa mga descriptor na iyon ay minana sarado.

-p Pinipigilan ng watawat na ito rc mula sa pagsisimula ng mga function ng shell mula sa kapaligiran. Ito
ay nagbibigay-daan sa rc upang tumakbo sa isang protektadong mode, kung saan ito ay nagiging mas mahirap para sa isang rc
script na babagsak sa pamamagitan ng paglalagay ng mga maling utos sa kapaligiran. (Tandaan na
ang presensya ng watawat na ito ay ginagawa hindi nangangahulugan na ligtas na magpatakbo ng setuid rc mga script;
ang mga karaniwang caveat tungkol sa setuid bit ay nalalapat pa rin.)

-s Ang watawat na ito ay sanhi rc upang basahin mula sa karaniwang input. Ang anumang mga argumento ay inilalagay sa $*.

-v Ang watawat na ito ay sanhi rc upang i-echo ang input nito sa karaniwang error habang binabasa ito.

-x Ang watawat na ito ay sanhi rc upang i-print ang bawat command sa karaniwang error bago ito maisakatuparan.
Maaari itong maging kapaki-pakinabang para sa pag-debug rc script.

UTOS

Ang isang simpleng utos ay isang pagkakasunod-sunod ng mga salita, na pinaghihiwalay ng puting espasyo (espasyo at tab)
mga character na nagtatapos sa isang bagong linya, semicolon (;), o ampersand (&). Ang unang salita ng a
command ang pangalan ng command na iyon. Kung ang pangalan ay nagsisimula sa /, ./, o ../, ang pangalan
ay ginagamit bilang isang ganap na pangalan ng landas na tumutukoy sa isang maipapatupad na file. Kung hindi, ang pangalan ng
ang command ay hinahanap sa isang talahanayan ng mga function ng shell, mga builtin na command, o bilang isang file sa
ang mga direktoryo na pinangalanan ng $path.

likuran Gawain
Isang command na nagtatapos sa & ay pinapatakbo sa background; ibig sabihin, bumabalik kaagad ang shell
sa halip na maghintay na makumpleto ang utos. Ang mga utos sa background ay mayroong /dev/null
nakakonekta sa kanilang karaniwang input maliban kung ang isang tahasang pag-redirect para sa karaniwang input ay
ginagamit.

Mga Subshell
Ang isang utos na may prefix na at-sign (@) ay isinasagawa sa isang subshell. Ito insulates ang
parent shell mula sa mga epekto ng pagbabago ng estado ng mga operasyon tulad ng a cd o isang variable
takdang-aralin. Halimbawa:

@ {cd ..; gumawa}

tatakbo gumawa(1) sa direktoryo ng magulang (..), ngunit iniiwan ang shell na tumatakbo sa kasalukuyang
direktoryo.

Linya pagpapatuloy
Ang isang mahabang lohikal na linya ay maaaring ipagpatuloy sa ilang mga pisikal na linya sa pamamagitan ng pagwawakas sa bawat linya
(maliban sa huli) na may backslash (\). Ang backslash-newline sequence ay itinuturing bilang a
space. Ang backslash ay hindi espesyal sa ibang paraan rc. (Sa karagdagan, sa loob ng mga panipi a
Ang backslash ay nawawala ang espesyal na kahulugan nito kahit na sinusundan ito ng isang bagong linya.)

Pag-quote
rc espesyal na binibigyang kahulugan ang ilang mga karakter; ang mga espesyal na character ay awtomatikong nagwawakas
mga salita. Ang mga sumusunod na character ay espesyal:

# ; & | ^ $ = ` ' { } ( ) < >

Ang nag-iisang quote (') ay pumipigil sa espesyal na pagtrato sa anumang karakter maliban sa sarili nito. Lahat
mga character, kabilang ang mga control character, bagong linya, at backslashes sa pagitan ng dalawang quote
ang mga character ay itinuturing bilang isang hindi naiintindihan na string. Ang isang quote character mismo ay maaaring ma-quote
sa pamamagitan ng paglalagay ng dalawang quote sa isang hilera. Ang minimal na pagkakasunud-sunod na kailangan upang maipasok ang quote character
ay ''''. Ang walang laman na string ay kinakatawan ng ''. kaya:

echo 'Ano'ng plano, Stan?'

nagpi-print out

Anong plano, Stan?

Ang tanda ng numero (#) ay nagsisimula ng komento rc. Lahat ng mga character hanggang ngunit hindi kasama ang
hindi pinapansin ang susunod na bagong linya. Tandaan na ang pagpapatuloy ng backslash ay hindi gumagana sa loob ng a
komento, ibig sabihin, ang backslash ay binabalewala kasama ng lahat ng iba pa.

Pagpapangkat
Ang zero o higit pang mga command ay maaaring ipangkat sa loob ng mga brace (“{” at “}”), at pagkatapos ay ituring bilang
isang utos. Ang mga tirante ay hindi tumutukoy sa saklaw; ang mga ito ay ginagamit lamang para sa pag-uutos
pagpapangkat. Sa partikular, mag-ingat sa utos:

para sa (i) {
utos
} | utos

Dahil ang pipe ay nagbibigkis nang mas mahigpit kaysa para sa, hindi ginagawa ng command na ito ang inaasahan ng user
sa. Sa halip, ilakip ang kabuuan para sa pahayag sa mga braces:

{para sa (i) utos} | utos

Sa kabutihang palad, rcAng balarila ni ay sapat na simple upang maunawaan ito ng isang (tiwala) na gumagamit
sinusuri ang skeletal yacc(1) grammar sa dulo ng man page na ito (tingnan ang seksyon
may karapatan GRAMATIKA).

input at output
Ang karaniwang output ay maaaring i-redirect sa isang file na may

command > file

at ang karaniwang input ay maaaring kunin mula sa isang file na may

command <file

Maaaring lumitaw ang mga pag-redirect saanman sa linya: ang salitang sumusunod sa simbolo ng pag-redirect ay
ang filename at dapat na sinipi kung naglalaman ito ng mga puwang o iba pang mga espesyal na character. Ang mga ito
lahat ay katumbas.

echo 1 2 3 > foo
> foo echo 1 2 3
echo 1 2 > foo 3

Ang mga deskriptor ng file maliban sa 0 at 1 ay maaaring tukuyin din. Halimbawa, upang i-redirect
karaniwang error sa isang file, gamitin ang:

command >[2] file

Upang ma-duplicate ang isang file descriptor, gamitin ang >[n=m]. Kaya upang i-redirect ang parehong pamantayan
output at karaniwang error sa parehong file, gamitin

command > file >[2=1]

Tulad ng sa sh, ang mga pag-redirect ay pinoproseso mula kaliwa hanggang kanan. Kaya ang pagkakasunod-sunod na ito

command >[2=1] > file

kadalasan ay isang pagkakamali. Una nitong kino-duplicate ang karaniwang error sa karaniwang output; pagkatapos
nire-redirect ang karaniwang output sa isang file, na nag-iiwan ng karaniwang error saanman ang karaniwang output
orihinal ay.

Upang isara ang isang file descriptor na maaaring bukas, gamitin ang >[n=]. Halimbawa, upang isara ang file
deskriptor 7:

utos >[7=]

Tandaan na walang mga puwang ang maaaring lumitaw sa mga construct na ito:

command > [2] file

ay magpapadala ng output ng command sa isang file na pinangalanang [2], na may nilalayong filename
lumalabas sa listahan ng argumento ng command.

Upang mailagay ang output ng isang command sa dulo ng isang umiiral nang file, gamitin ang:

command >> file

Kung ang file ay hindi umiiral, pagkatapos ito ay nilikha.

"Narito ang mga dokumento" ay sinusuportahan tulad ng sa sh gamit ang

utos << 'eof-marker'

Ang mga kasunod na linya ay bumubuo ng karaniwang input ng command, hanggang sa isang linya na naglalaman lamang ng
marker, sa kasong ito eof-marker, ay nakatagpo.

Kung ang end-of-file marker ay nakapaloob sa mga quote, pagkatapos ay walang variable na pagpapalit na magaganap
sa loob ng dokumentong ito. Kung hindi, ang bawat variable ay pinapalitan ng espasyo nito-
halaga ng hiwalay na listahan (tingnan Patag Mga Listahan, sa ibaba), at kung ang isang ^ character ay sumusunod sa isang variable
pangalan, ito ay tinanggal. Ito ay nagbibigay-daan sa hindi malabo na paggamit ng mga variable na katabi ng teksto, tulad ng sa

$variable^sundan

Upang isama ang isang literal na $ sa isang dito na dokumento kapag ang isang hindi naka-quote na end-of-file marker ay ginagawa
ginamit, ilagay ito bilang $$.

Bukod pa rito, rc sumusuporta sa "dito mga string", na tulad ng dito mga dokumento, maliban sa input na iyon
ay direktang kinuha mula sa isang string sa command line. Ang kanilang paggamit ay inilarawan dito:

pusa <<< 'ito ay isang here string' | wc

(Ang tampok na ito ay nagbibigay-daan rc upang i-export ang mga function gamit dito ang mga dokumento sa kapaligiran;
hindi inaasahan ng may-akda na mahanap ng mga user na kapaki-pakinabang ang feature na ito.)

Pipa
Dalawa o higit pang mga command ay maaaring pagsamahin sa isang pipeline sa pamamagitan ng paglalagay ng vertical bar (|) sa pagitan
sila. Ang karaniwang output (file descriptor 1) ng command sa kaliwa ay nakatali sa
karaniwang input (file descriptor 0) ng command sa kanan. Ang notasyon |[n=m]
ay nagpapahiwatig na ang file descriptor n ng kaliwang proseso ay konektado sa file descriptor m of
ang tamang proseso. |[n] ay isang shorthand para sa |[n=0]. Bilang isang halimbawa, upang i-pipe ang pamantayan
pagkakamali ng isang utos sa wc(1), gamitin ang:

utos |[2] wc

Tulad ng mga pag-redirect ng file, walang mga puwang ang maaaring mangyari sa construct na tumutukoy sa may bilang na file
mga deskriptor.

Itinuturing na totoo ang exit status ng pipeline kung at kung ang bawat command sa
totoo ang paglabas ng pipeline.

Command as Mga argumento
Ang ilang mga utos, tulad ng cmp(1) o Diff(1), kunin ang kanilang mga argumento sa command line, at gawin
hindi basahin ang input mula sa karaniwang input. Ito ay maginhawa kung minsan upang bumuo ng nonlinear
pipelines upang ang isang utos tulad ng cmp maaaring basahin ang output ng dalawang iba pang mga utos nang sabay-sabay.
rc ganito ba:

cmp <{command} <{command}

inihahambing ang output ng dalawang command sa braces. Tandaan: dahil sa ganitong paraan ng pag-redirect
ay ipinatupad gamit ang ilang uri ng tubo, at dahil hindi maaari hanapin ko(2) sa isang tubo, mga utos
gamit na iyon hanapin ko(2) mabibitin. Halimbawa, ilang bersyon ng Diff(1) gamitin hanapin ko(2) sa kanilang
inputs.

Ang data ay maaaring ipadala pababa sa isang pipe sa ilang mga utos gamit tee(1) at ang bersyon ng output ng
ang notasyong ito:

echo hi doon | tee >{sed 's/^/p1 /'} >{sed 's/^/p2 /'}

Kontrol Mga istruktura

Ang mga sumusunod ay maaaring gamitin para sa control flow in rc:

Kung hindi Pahayag
kung (pagsusulit) {
cmd
} iba pa cmd
Ang pagsusulit ay executed, at kung ang return status nito ay zero, ang unang command ay
naisakatuparan, kung hindi man ang pangalawa ay. Ang mga braces ay hindi sapilitan sa paligid ng mga utos.
Gayunpaman, ang ibang pahayag ay wasto lamang kung ito ay sumusunod sa isang malapit na brace sa pareho
linya. Kung hindi, ang if ay itinuturing na isang simple-if:

kung (pagsusulit)
utos

Habang at para loops
habang (pagsusulit) cmd
rc nagpapatupad ng pagsusulit at nagsasagawa ng utos hangga't ang pagsusulit ay totoo.

para sa (ay in listahan) cmd
rc set ay sa bawat elemento ng listahan (na maaaring naglalaman ng mga variable at backquote
pagpapalit) at pagtakbo cmd. Kung “sa listahan” ay tinanggal, kung gayon rc magtatakda ay sa bawat isa
elemento ng $*. Halimbawa:

para sa (i sa `{ls -F | grep '\*$' | sed 's/\*$//'}) { commands }

ay magtatakda ng $i sa pangalan ng bawat file sa kasalukuyang direktoryo na maipapatupad.

lumipat
lumipat (listahan) { kaso ... }
rc tumitingin sa loob ng braces pagkatapos ng switch para sa mga pahayag na nagsisimula sa salita
kaso. Kung ang alinman sa mga pattern na sumusunod na kaso ay tumugma sa listahang ibinigay upang lumipat,
pagkatapos ay ang mga utos hanggang sa susunod na case statement ay naisakatuparan. Ang
metacharacter *, [o ? hindi dapat sinipi; ang pagtutugma ay isinasagawa lamang laban sa
ang mga string sa listahan, hindi laban sa mga pangalan ng file. (Ang pagtutugma para sa mga pahayag ng kaso ay ang
katulad ng para sa ~ utos.)

Lohikal Operator
Mayroong isang bilang ng mga operator sa rc na nakadepende sa exit status ng isang command.

utos && utos

executes ang unang command at pagkatapos ay executes ang pangalawang command kung at lamang kung ang una
paglabas ng command na may zero exit status ("totoo" sa Unix).

utos || utos

executes ang unang command at pagkatapos ay executes ang pangalawang command kung at lamang kung ang una
paglabas ng command na may nonzero exit status (“false” sa Unix).

! utos

tinatanggihan ang exit status ng isang command.

PATTERN PAGKAKITA

Mayroong dalawang anyo ng pagtutugma ng pattern sa rc. Ang isa ay tradisyonal na shell globbing. Ito
nangyayari sa pagtutugma para sa mga pangalan ng file sa mga listahan ng argumento:

argumento ng command argument ...

Kapag ang mga character *, [ o ? mangyari sa isang argumento o utos, rc tumitingin sa argumento
bilang isang pattern para sa pagtutugma laban sa mga file. (Salungat sa pag-uugali na ipinakita ng iba pang mga shell,
rc gagawa lamang ng pagtutugma ng pattern kung ang isang metacharacter ay nangyayari nang hindi naka-quote at literal na in
ang input. kaya,

foo='*'
echo $foo

ay palaging umaalingawngaw lamang ng isang bituin. Upang mapalawak ang mga hindi literal na metacharacter, isang
dapat gamitin ang eval statement upang muling i-scan ang input.) Nagaganap ang pagtutugma ng pattern
ayon sa mga sumusunod na panuntunan: a * tumutugma sa anumang numero (kabilang ang zero) ng mga character.
A ? tumutugma sa anumang solong karakter, at isang [ na sinusundan ng isang bilang ng mga character na sinusundan ng
a ] tumutugma sa isang character sa klase na iyon. Ang mga patakaran para sa pagtutugma ng klase ng character ay
kapareho ng para sa ed(1), maliban na ang pagtanggi sa klase ng karakter ay nakamit
na may tilde (~), hindi ang caret (^), dahil iba na ang ibig sabihin ng caret rc.

rc tumutugma din sa mga pattern laban sa mga string na may ~ command:

~ pattern ng pattern ng paksa ...

~ nagtatakda ng $status sa zero kung at kung ang isang ibinigay na pattern ay tumutugma sa alinmang elemento ng
listahan ng paksa. Sa gayon

~ foo f*

nagtatakda ng katayuan sa zero, habang

~ (bar baz) f*

nagtatakda ng katayuan sa isa. Ang null list ay tumugma sa null list, kaya

~ $foo ()

sinusuri upang makita kung ang $foo ay walang laman o wala. Maaari rin itong makamit sa pamamagitan ng pagsubok

~ $#foo 0

Tandaan na sa loob ng isang ~ command rc ay hindi tumutugma sa mga pattern laban sa mga pangalan ng file, kaya hindi
kinakailangan upang sipiin ang mga karakter *, [ at ?. gayunpaman, rc ay nagpapalawak ng paksa laban sa
mga filename kung naglalaman ito ng mga metacharacter. Kaya, ang utos

~ * ?

nagbabalik ng totoo kung ang alinman sa mga file sa kasalukuyang direktoryo ay may isang solong-character na pangalan.
Kung ang ~ command ay binibigyan ng isang listahan bilang unang argumento nito, pagkatapos ay isang matagumpay na tugma laban sa
alinman sa mga elemento ng listahang iyon ay magsasanhi ng ~ upang bumalik ng totoo. Halimbawa:

~ (foo goo zoo) z*

ay totoo.

MGA LISTA AT MGA VARIABLE

Ang pangunahing istraktura ng data sa rc ay ang listahan, na isang pagkakasunod-sunod ng mga salita. Mga panaklong
ay ginagamit sa mga listahan ng pangkat. Ang walang laman na listahan ay kinakatawan ng (). Walang hierarchical ang mga listahan
istraktura; ang isang listahan sa loob ng isa pang listahan ay pinalawak kaya ang panlabas na listahan ay naglalaman ng lahat ng
mga elemento ng panloob na listahan. Kaya, ang mga sumusunod ay lahat ng katumbas

isa dalawa tatlo

(isa dalawa tatlo)

((isa dalawa tatlo)))

Tandaan na ang null string, '', at ang null list, (), ay dalawang magkaibang bagay.
Ang pagtatalaga ng null string sa isang variable ay isang wastong operasyon, ngunit hindi nito inaalis ang nito
kahulugan.

null = '' walang laman = () echo $#null $#empty

gumagawa ng output

1 0

listahan Konklusyon
Dalawang listahan ang maaaring pagsamahin ng concatenation operator (^). Ang pagsasama ay gumagana ayon
sa mga sumusunod na panuntunan: kung ang dalawang listahan ay may parehong bilang ng mga elemento, kung gayon
ang pagsasama ay magkapares:

echo (a- b- c-)^(1 2 3)

gumagawa ng output

a-1 b-2 c-3

Kung hindi man, kahit isa sa mga listahan ay dapat magkaroon ng isang elemento, at pagkatapos ay ang
distributive ang concatenation:

cc -^(O gc) (malloc alloca)^.c

ay may epekto ng pagsasagawa ng utos

cc -O -g -c malloc.c alloca.c

Ang isang salita ay isang listahan ng haba ng isa, kaya

echo foo^bar

gumagawa ng output

foobar

Libre Carets
rc naglalagay ng mga caret (concatenation operator) nang libre sa ilang partikular na sitwasyon, upang
mag-save ng ilang pag-type sa ngalan ng user. Halimbawa, ang halimbawa sa itaas ay maaari ding i-type
sa bilang:

opts=(O gc) files=(malloc alloca) cc -$opts $files.c

rc nag-iingat na maglagay ng libreng caret sa pagitan ng "-" at $opts, gayundin sa pagitan ng $files
at .c. Ang panuntunan para sa mga libreng caret ay ang mga sumusunod: kung ang isang salita o keyword ay kaagad
na sinusundan ng isa pang salita, keyword, dollar-sign o backquote, pagkatapos rc naglalagay ng caret
sa pagitan nila.

Variable
Ang isang listahan ay maaaring italaga sa isang variable, gamit ang notasyon:

ay = listahan

Ang espesyal na variable * ay maaari ding italaga sa paggamit ng notasyong ito; rc ay walang itakda builtin.

Maaaring gamitin ang anumang hindi walang laman na sequence ng mga character, maliban sa isang sequence na may kasamang mga digit lang
bilang isang variable na pangalan. Anumang karakter maliban sa = ay maaaring gamitin, ngunit ang mga espesyal na karakter ay dapat
sinipi. Ang lahat ng mga variable na tinukoy ng gumagamit ay na-export sa kapaligiran.

Ang halaga ng isang variable ay isinangguni sa operator ng dolyar ($):

$ay

Anumang variable na hindi naitalaga ng isang halaga ay nagbabalik ng null na listahan, (), kapag
sinangguni. Pinapayagan ang maraming sanggunian:

a = foo
b = a
echo $$ b

mga kopya

foo

Ang kahulugan ng variable ay maaari ding alisin sa pamamagitan ng pagtatalaga ng null list sa isang variable:

ay=()

Para gumana nang tama ang "libreng pag-aalaga", rc dapat gumawa ng ilang mga pagpapalagay tungkol sa kung ano
maaaring lumitaw ang mga character sa isang variable na pangalan. rc Ipinapalagay na ang isang variable na pangalan ay binubuo lamang
ng mga alphanumeric na character, underscore (_) at star (*). Upang sumangguni sa isang variable na may
iba pang mga character sa pangalan nito, sipiin ang variable na pangalan. kaya:

echo $'we$Ird:Variab!le'

Lokal Variable
Anumang bilang ng mga variable na takdang-aralin ay maaaring gawing lokal sa isang utos sa pamamagitan ng pag-type:

a=foo b=bar ... utos

Ang utos ay maaaring isang tambalang utos, kaya halimbawa:

landas=. kung=() {
...
}

nagtatakda ng landas patungo sa . at nag-aalis ng mga if para sa tagal ng isang mahabang compound command.

Paiba-iba Mga subscript
Maaaring ma-subscript ang mga variable kasama ng notasyon

$var(n)

saan n ay isang listahan ng mga integer (pinagmulan 1). Ang pambungad na panaklong ay dapat sumunod kaagad
ang variable na pangalan. Ang listahan ng mga subscript ay hindi kailangang maayos o natatangi. kaya,

a=(isa dalawa tatlo)
echo $a(3 3 3)

mga kopya

tatlo tatlo tatlo

If n tumutukoy sa isang hindi umiiral na elemento, pagkatapos ay $var(n) ibinabalik ang null list. Ang notasyon
$n, Kung saan n ay isang integer, ay isang shorthand para sa $*(n). Kaya, rcAng mga argumento ni ay maaaring i-refer
sa bilang $1, $2, at iba pa.

Tandaan din na ang listahan ng mga subscript ay maaaring ibigay ng alinman sa rclistahan ng mga operasyon:

$var(`{awk 'BEGIN{for(i=1;i<=10;i++)print i;exit; }'})

ibinabalik ang unang 10 elemento ng $var.

Upang mabilang ang bilang ng mga elemento sa isang variable, gamitin

$#var

Nagbabalik ito ng isang listahan ng isang elemento, na may bilang ng mga elemento sa $var.

Patag Mga Listahan
Upang lumikha ng isang listahan ng isang elemento mula sa isang listahan ng maraming elemento, kasama ang mga bahagi
space-separated, gamitin ang dollar-caret ($^) operator:

$^var

Ito ay kapaki-pakinabang kapag ang mga normal na panuntunan sa pagsasama-sama ng listahan ay kailangang i-bypass. Halimbawa,
para magdagdag ng isang tuldok sa dulo ng $path, gamitin ang:

echo $^path.

backquote Paghalili
Ang isang listahan ay maaaring mabuo mula sa output ng isang command sa pamamagitan ng paggamit ng backquote substitution:

`{ utos }

nagbabalik ng isang listahan na nabuo mula sa karaniwang output ng command sa mga braces. Nakasanayan na ni $ifs
hatiin ang output sa mga elemento ng listahan. Bilang default, ang $ifs ay may value na space-tab-newline.
Maaaring tanggalin ang mga braces kung ang utos ay isang salita. Kaya `ls ay maaaring gamitin sa halip
ng `{ls}. Ang huling feature na ito ay kapaki-pakinabang kapag tinutukoy ang mga function na lumalawak sa kapaki-pakinabang
mga listahan ng argumento. Ang madalas na paggamit ay:

fn src { echo *.[chy] }

sinundan ng

wc `src

(Ito ay magpi-print ng word-count ng lahat ng C source file sa kasalukuyang direktoryo.)

Upang ma-override ang halaga ng $ifs para sa isang pagpapalit ng backquote, gamitin ang:

`` (ifs-list) { utos }

Pansamantalang babalewalain ang $ifs at hahatiin ang output ng command gaya ng tinukoy ni
ang listahan na sumusunod sa double backquote. Halimbawa:

`` ($nl :) {cat / etc / passwd}

naghihiwalay / etc / passwd sa mga patlang, ipagpalagay na ang $nl ay naglalaman ng isang bagong linya bilang halaga nito.

ESPESYAL MGA VARIABLE

Maraming mga variable ang kilala rc at espesyal na ginagamot. Sa sumusunod na listahan,
"default" ay nagpapahiwatig na rc nagbibigay sa variable ng default na halaga sa pagsisimula; "walang-export"
ay nagpapahiwatig na ang variable ay hindi kailanman na-export; at "read-only" ay nagpapahiwatig na isang pagtatangka
upang itakda ang variable ay tahimik na walang epekto.

Gayundin, ang ibig sabihin ng "alias" ay ang variable ay naka-alyas sa parehong pangalan sa mga capitals. Para sa
halimbawa, ang isang pagtatalaga sa $cdpath ay nagiging sanhi ng isang awtomatikong pagtatalaga sa $CDPATH, at vice-
kabaligtaran. Kung itinakda ang $CDPATH kung kailan rc ay nagsimula, ang halaga nito ay na-import sa $cdpath. $cdpath
at ang $path ay rc mga listahan; Ang $CDPATH at $PATH ay mga listahang pinaghihiwalay ng tutuldok. Ang mga pangalan lamang ang nabaybay
sa mga kabisera ay iniluluwas sa kapaligiran.

* (walang-export)
Ang listahan ng argumento ng rc. Ang $1, $2, atbp. ay kapareho ng $*(1), $*(2), atbp.

0 (default na walang pag-export)
Ang variable na $0 ay nagtataglay ng halaga ng argv[0] kung saan rc ay tinawag.
Bukod pa rito, ang $0 ay nakatakda sa pangalan ng isang function para sa tagal ng pagpapatupad
ng function na iyon, at ang $0 ay nakatakda din sa pangalan ng file na binibigyang kahulugan
ang tagal ng isang . utos. Ang $0 ay hindi isang elemento ng $*, at hindi kailanman itinuturing bilang
isa.

apid (no-export)
Nagsimula sa background ang process ID ng huling proseso.

apids (no-export read-only)
Isang listahan na ang mga elemento ay ang mga ID ng proseso ng lahat ng mga proseso sa background
buhay pa, o namatay na at hindi pa hinihintay.

bqstatus (walang-export)
Ang katayuan ng paglabas ng rc forked upang isagawa ang pinakakamakailang backquote substitution.
Tandaan na, hindi tulad ng $status, ang $bqstatus ay palaging isang listahan ng elemento (tingnan ang EXIT
STATUS sa ibaba). Halimbawa:

echo foo |grep bar; anong status

mga kopya

katayuan=(0 1)

samantalang

x=`{echo foo |grep bar}; ano ang bqstatus

mga kopya

bqstatus=1

cdpath (alias)
Isang listahan ng mga direktoryo na hahanapin ang target ng a cd utos. Ang walang laman na string
ay kumakatawan sa kasalukuyang direktoryo. Tandaan na kung ang $cdpath variable ay hindi
naglalaman ng kasalukuyang direktoryo, kung gayon ang kasalukuyang direktoryo ay hindi hahanapin;
pinapayagan nito ang paghahanap ng direktoryo na magsimula sa isang direktoryo maliban sa kasalukuyang
direktoryo.

kasaysayan
Ang $history ay naglalaman ng pangalan ng isang file kung saan nakadugtong ang mga command bilang rc bumabasa
sila. Pinapadali nito ang paggamit ng isang stand-alone na programa sa kasaysayan (tulad ng
kasaysayan(1)) na nag-parse ng mga nilalaman ng history file at ipinapakita ang mga ito sa rc
para sa muling interpretasyon. Kung hindi nakatakda ang $history, kung gayon rc ay hindi nagdaragdag ng mga utos sa
anumang file.

tahanan (alias)
Ang default na direktoryo para sa builtin cd command, at ang direktoryo kung saan rc
mukhang mahanap ang initialization file nito, .rcrc, if rc ay sinimulan bilang isang pag-login
kabibi

kung (default)
Ang panloob na field separator, na ginagamit para sa paghahati-hati ng output ng backquote
mga utos para sa panunaw bilang isang listahan. Sa pagsisimula, rc nagtatalaga ng listahang naglalaman ng
character space, tab, at newline sa $ifs.

landas (alias)
Ito ay isang listahan ng mga direktoryo upang maghanap para sa mga utos. Nakatayo ang walang laman na string
para sa kasalukuyang direktoryo. Kung hindi nakatakda ang $PATH o $path sa oras ng pagsisimula,
Ipinapalagay ng $path ang isang default na halaga na angkop para sa iyong system. Ito ay karaniwang
(/ usr / local / bin / usr / bin /usr/ucb / bin .)

pid (default na walang-export)
Sa pagsisimula, ang $pid ay sinisimulan sa numeric process ID ng kasalukuyang tumatakbo
rc.

prompt (default)
Ang variable na ito ay nagtataglay ng dalawang senyas (sa form ng listahan, siyempre) iyon rc mga kopya.
$prompt(1) ay naka-print bago basahin ang bawat command, at $prompt(2) ay nakalimbag kapag
ang input ay inaasahang magpapatuloy sa susunod na linya. rc nagtatakda ng $prompt sa ('; ' '') ni
default. Ang dahilan nito ay na ito ay nagbibigay-daan sa isang rc user upang kumuha ng mga utos mula sa
nakaraang mga linya gamit ang isang mouse, at upang ipakita ang mga ito sa rc para sa muling interpretasyon; ang
semicolon prompt ay binabalewala lang ng rc. Ang null $prompt(2) mayroon din nito
katwiran: isang rc script, kapag nai-type nang interactive, ay hindi mag-iiwan ng $prompt(2)'s
sa screen, at samakatuwid ay maaaring kunin ng mouse at direktang ilagay sa a
file para gamitin bilang shell script, nang hindi kinakailangan ang karagdagang pag-edit.

prompt (function)
Kung ang function na ito ay tinukoy, pagkatapos ito ay maipapatupad sa bawat oras rc ay malapit nang mag-print
$promptNa (1).

katayuan (no-export read-only)
Ang exit status ng huling command. Kung lumabas ang command na may numeric na halaga,
ang numerong iyon ay ang katayuan. Kung namatay ang command na may signal, ang status ay ang
pangalan ng signal na iyon; kung ang isang core file ay ginawa, ang string na "+core" ay nakadugtong.
Ang halaga ng $status para sa isang pipeline ay isang listahan, na may isang entry, tulad ng nasa itaas, para sa bawat isa
proseso sa pipeline. Halimbawa, ang utos

ls | wc

karaniwang nagtatakda ng $status sa (0 0).

bersyon (default)
Sa pagsisimula, ang unang elemento ng variable ng listahan na ito ay sinisimulan sa isang string
na nagpapakilala sa bersyong ito ng rc. Ang pangalawang elemento ay pinasimulan sa isang string
na maaaring matagpuan ng ident(1) at ang Ano utos ng sccsNa (1).

Mga function

rc ang mga function ay magkapareho sa rc script, maliban na ang mga ito ay naka-imbak sa memorya at ay
awtomatikong na-export sa kapaligiran. Ang isang function ng shell ay idineklara bilang:

fn name { commands }

rc ini-scan ang kahulugan hanggang sa close-brace, upang ang function ay maaaring sumasaklaw ng higit sa isa
linya. Maaaring alisin ang kahulugan ng function sa pamamagitan ng pag-type

pangalan ng fn

(Maaaring tukuyin ang isa o higit pang mga pangalan. May kasamang kahulugan, lahat ng pangalan ay tumatanggap
ang parehong kahulugan. Ito ay minsan ay kapaki-pakinabang para sa pagtatalaga ng parehong signal handler sa
maraming signal. Kung walang kahulugan, ang lahat ng pinangalanang function ay tatanggalin.) Kapag ang isang function ay
executed, $* ay nakatakda sa mga argumento sa function na iyon para sa tagal ng command.
Kaya isang makatwirang kahulugan para sa l, isang shorthand para sa ls(1), ay maaaring:

fn l { ls -FC $* }

ngunit hindi

fn l { ls -FC } # MALI

MGA PAG-ALAM AT Mga TANDA

rc kinikilala ang isang bilang ng mga signal, at pinapayagan ang gumagamit na tukuyin ang mga function ng shell na kumikilos
bilang tagapangasiwa ng signal. rc sa pamamagitan ng default traps SIGINT kapag ito ay nasa interactive na mode. SIGQUIT
at SIGTERM ay binabalewala, maliban kung rc ay na-invoke gamit ang -d flag. Gayunpaman, gumagamit-
ang tinukoy na mga humahawak ng signal ay maaaring isulat para sa mga ito at sa lahat ng iba pang signal. Ang paraan upang tukuyin
ang tagapangasiwa ng signal ay sumulat ng isang function sa pamamagitan ng pangalan ng signal sa lower case. kaya:

fn sighup { echo hangup; rm /tmp/rc$pid.*; labasan }

Bilang karagdagan sa mga signal ng Unix, rc kinikilala ang artipisyal na signal na SIGEXIT na nangyayari bilang
rc ay malapit nang lumabas.

Upang maalis ang kahulugan ng tagapangasiwa ng signal, alisin ito na parang ito ay isang regular
function. Halimbawa:

fn sign

ibinabalik ang handler ng SIGINT sa default na halaga. Upang huwag pansinin ang isang senyales, itakda ang
halaga ng signal handler sa {}. kaya:

fn sign {}

nagiging sanhi ng SIGINT na hindi papansinin ng shell. Ang mga senyales lamang na hindi pinapansin ang ipinapasa
sa mga programang pinapatakbo ng rc; hindi na-export ang mga function ng signal.

Sa System V-based Unix system, rc hindi ka papayag na ma-trap ang SIGCLD.

BUILTIN UTOS

Ang mga built-in na utos ay isinasagawa sa konteksto ng shell, ngunit kung hindi man ay eksaktong katulad nito
iba pang mga utos. Bagaman !, ~ at @ ay hindi mahigpit na nagsasalita ng mga builtin na utos, magagawa nila
kadalasang ginagamit nang ganoon.

. [-i] file [arg ...]
Binabasa file bilang input sa rc at isinasakatuparan ang mga nilalaman nito. Sa isang -i flag, ang input ay
interactive. Kaya mula sa loob ng isang shell script,

. -i /dev/tty

ginagawa ang "tama".

masira Breaks mula sa kaloob-looban para sa o habang, tulad ng sa C. Ito ay isang error sa invoke masira
sa labas ng isang loop. (Tandaan na walang masira keyword sa pagitan ng mga command sa switch
mga pahayag, hindi katulad ng C.)

builtin utos [arg ...]
Isinasagawa ang utos na binabalewala ang anumang kahulugan ng function ng parehong pangalan. Ito
Ang command ay naroroon upang payagan ang mga function na may parehong mga pangalan tulad ng mga builtin na gamitin ang
nakapaloob na builtin o binary. Halimbawa:

fn ls { builtin ls -FC $* }

ay isang makatwirang paraan upang ipasa ang isang default na hanay ng mga argumento sa ls(1), samantalang

fn ls { ls -FC $* } # MALI

ay isang non-terminating recursion, na magiging sanhi ng rc na maubos ang stack space nito at
(sa huli) wakasan kung ito ay naisakatuparan.

cd [direktoryo]
Binabago ang kasalukuyang direktoryo sa direktoryo. Hinahanap ang variable na $cdpath
posibleng mga lokasyon ng direktoryo, kahalintulad sa paghahanap ng $path para sa executable
mga file. Nang walang argumento, cd binabago ang kasalukuyang direktoryo sa $home.

miss [-n] [--] [arg ...]
Ini-print ang mga argumento nito sa karaniwang output, na tinapos ng isang bagong linya. Ang mga argumento ay
pinaghihiwalay ng mga espasyo. Kung ang unang argumento ay -n walang pinal na bagong linya ang naka-print. Kung
ang unang argumento ay --, pagkatapos ang lahat ng iba pang argumento ay literal na echoed. Ito ay
ginagamit para sa pag-echo ng literal -n.

eval [listahan]
Pinagsasama-sama ang mga elemento ng listahan na may mga puwang at pinapakain ang nagresultang string sa rc
para sa muling pag-scan. Ito lang ang oras na muling na-scan ang input rc.

exec [arg ...]
Pumapalit rc sa ibinigay na utos. Kung ang exec ay naglalaman lamang ng mga pag-redirect, kung gayon
nalalapat ang mga pag-redirect na ito sa kasalukuyang shell at hindi lalabas ang shell. Para sa
Halimbawa,

exec >[2] err.out

naglalagay ng karagdagang output sa karaniwang error sa file err.out.

lumabas [katayuan]
Gawing lumabas ang kasalukuyang shell kasama ang ibinigay na exit katayuan. Kung walang argumento ay
ibinigay, ang kasalukuyang halaga ng $status ay ginagamit.

limitasyon [-h] [mapagkukunan [halaga]]
Katulad sa csh(1) limitasyon builtin, ang utos na ito ay gumagana sa BSD-style
mga limitasyon ng mapagkukunan ng isang proseso. Ang -h na watawat ay nagpapakita/nagbabago sa mga mahirap na limitasyon. Ang
mga mapagkukunan na maaaring ipakita o baguhin ay cputime, laki ng mga file, laki ng datos, laki ng stacks,
coredumpsize, paggamit ng memorya, at, kung saan sinusuportahan, mga deskriptor, paggamit ng memorya, memoryrss,
maxproc, memorylocked, at mga filelock. Halimbawa:

limitahan ang coredumpsize 0

hindi pinapagana ang mga core dump. Para magtakda ng soft limit na katumbas ng hard limit:

limitahan `{limit -h laki ng data}

newpgrp
Naglalagay rc sa isang bagong pangkat ng proseso. Ang builtin na ito ay kapaki-pakinabang para sa paggawa rc kumilos na tulad ng
isang shell ng kontrol sa trabaho sa isang pagalit na kapaligiran. Ang isang halimbawa ay ang NeXT Terminal
program, na tahasang ipinapalagay na ang bawat shell na tinidor nito ay maglalagay ng sarili sa isang
bagong pangkat ng proseso.

pagbabalik [n]
Nagbabalik mula sa kasalukuyang function, na may status n, Kung saan n ay isang wastong katayuan sa paglabas,
o isang listahan ng mga ito. Kaya ito ay legal na magkaroon

bumalik (sippipe 1 2 3)

(Ito ay karaniwang ginagamit upang payagan ang isang function na bumalik na may exit status ng a
dati nang naisagawa ang pipeline ng mga utos.) Kung n ay tinanggal, pagkatapos ay naiwan ang $status
hindi nagbabago. Ito ay isang error sa pag-invoke pagbabalik kapag wala sa loob ng isang function.

ilipat [n]
Tinatanggal n mga elemento mula sa simula ng $* at inilipat ang iba pang mga elemento pababa ng
n. n default sa 1.

umask [mask]
Itinatakda ang kasalukuyang umask (tingnan umask(2)) sa octal mask. Kung walang argumento ay
kasalukuyan, ang kasalukuyang halaga ng mask ay naka-print.

maghintay [pid]
Naghihintay para sa proseso na may tinukoy pid, na dapat ay sinimulan ni rc, Upang
labasan. Kung hindi pid ay tinukoy, rc naghihintay na lumabas ang lahat ng proseso ng anak nito.

ano ang [-b] [-f] [-p] [-s] [-v] [--] [pangalan ...]
Nagpi-print ng kahulugan ng mga pinangalanang bagay. Para sa builtin, builtin foo ay nakalimbag;
para sa mga function, kabilang ang mga humahawak ng signal, ang kanilang mga kahulugan ay naka-print; para sa
maipapatupad na mga file, ang mga pangalan ng landas ay naka-print; at para sa mga variable, ang kanilang mga halaga ay
nakalimbag. Nililimitahan ng mga flag ang output sa mga builtin, function, executable program,
mga tagapangasiwa ng signal, at mga variable, ayon sa pagkakabanggit. Kung hindi pangalans ay tinukoy, rc mga listahan
lahat ng bagay ng ganoong uri. (Ito ay hindi pinahihintulutan para sa -p.) Kung walang mga argumento,
whatis ay katumbas ng whatis -fv, at nagpi-print ng mga halaga ng lahat ng mga variable ng shell
at mga function.

Tandaan na ang ano ang ang output ay angkop para sa input sa rc; sa pamamagitan ng pag-save ng output ng ano ang
sa isang file, dapat na posible na muling likhain ang estado ng rc sa pamamagitan ng pag-source sa file na ito
na may . utos. Isa pang tala: whatis -s > file ay hindi maaaring gamitin upang iimbak ang
estado ng rcAng mga tagapangasiwa ng signal sa isang file, dahil ang mga builtin na may mga pag-redirect ay pinapatakbo
sa isang subshell, at rc palaging ibinabalik ang mga humahawak ng signal sa kanilang default na halaga pagkatapos
isang tinidor().

Dahil sa ano ang Gumagamit getopt(3) upang mai-parse ang mga argumento nito, maaari mong gamitin ang espesyal
argumento -- upang wakasan ang mga watawat nito. Pinapayagan ka nitong gumamit ng mga pangalan na nagsisimula sa a
gitling, tulad ng kasaysayan(1) mga utos. Halimbawa,

ano ang ---p

HALIMBAWA

Ang ilipat ang builtin ay nagbabago lamang ng $*. Maaaring ilipat ng function na ito ang anumang variable (maliban sa $lshift).

fn lshift { lshift=$*; *=$$1; ilipat ang $lshift(2); $lshift(1)=$* }

Gamit ang kahulugang ito sa lugar,

walrus = (mga sapatos na nagpapadala ng sealing-wax cabbages kings)
lshift walrus 3
ano ang walrus

mga kopya

walrus=(mga hari ng repolyo)

Ang operator na $^var ay nag-flatten ng isang listahan sa pamamagitan ng paghihiwalay sa bawat elemento na may puwang. Ang function na ito
nagbibigay-daan sa separator na maging isang arbitrary string.

fn lflat {
lflat=$*; *=$$1
habang () {
echo -n $1; shift
~ $#* 0 && break
echo -n $lflat(2)
}

Gamit ang kahulugang ito sa lugar,

hops=(uunet mcvax ukc tlg)
lflat hops !

mga print (na walang huling bagong linya)

uunet!mcvax!ukc!tlg

EXIT STATUS

Ang katayuan ng paglabas ng rc ay karaniwang kapareho ng sa huling utos na naisakatuparan. Kung ang
ang huling utos ay isang pipeline, rc lalabas sa 0 kung ginawa ng bawat utos sa pipeline; kung hindi ito
paglabas 1.

rc ay maaaring gawin upang lumabas sa isang partikular na katayuan gamit ang lumabas builtin.

GRAMATIKA

Narito ang rcgrammar ni, na-edit upang alisin ang mga semantic na aksyon.

%term ANDAND BACKBACK BANG CASE COUNT DUP ELSE END FLAT FN FOR IF IN
%term OROR PIPE REDIR SUB SUBSHELL SWITCH TWIDDLE HABANG WORD HUH

%left HABANG ')' IBA
%left ANDAND OROR '\n'
%left BANG SUBSHELL
%kaliwa sa PIPE
%right '$'
%kaliwa sa SUB

%simulan ang rc

%%

rc: dulo ng linya
| pagtatapos ng error

wakas: END /* EOF */ | '\n'

cmdsa: cmd ';' | cmd '&'

linya: cmd | linya ng cmdsa

katawan: cmd | cmdsan katawan

cmdsan: cmdsa | cmd '\n'

brace: '{' body '}'

magulang: '(' katawan ')'

italaga: unang '=' na salita

epilog: /* walang laman */ | redir epilog

redir: DUP | REDIR salita

kaso: CASE words ';' | Mga salitang CASE '\n'

cbody: cmd | kaso cbody | cmdsan cbody

iftail: cmd %prec ELSE
| brace ELSE optnl cmd

cmd : /* walang laman */ %prec WHILE
| simple lang
| brace epilog
| KUNG paren optnl iftail
| PARA sa '(' salita SA mga salita ')' optnl cmd
| PARA sa '(' salita ')' optnl cmd
| HABANG paren optnl cmd
| SWITCH '(' word ')' optnl '{' cbody '}'
| TWIDDLE optcaret salita salita
| cmd ANDAND optnl cmd
| cmd OROR optnl cmd
| cmd PIPE optnl cmd
| redir cmd %prec BANG
| magtalaga ng cmd %prec BANG
| BANG optcaret cmd
| SUBSHELL optcaret cmd
| FN words brace
| Mga salitang FN

optcaret: /* walang laman */ | '^'

simple: una | simpleng salita | simpleng redir

una: comword | unang '^' espada

espada: comword | keyword

salita: espada | salitang '^' espada

comword: '$' espada
| '$' sword SUB words ')'
| COUNT espada
| FLAT na espada
| '' espada
| '' brace
| BACKBACK word brace | BACKBACK salitang espada
| '(' mga salita ')'
| REDIR brace
| SALITA

keyword: PARA SA | SA | HABANG | KUNG | PALITAN
| FN | IBA | KASO | TWIDDLE | BANG | SUBSHELL

mga salita: /* walang laman */ | salita salita

optnl: /* walang laman */ | optnl '\n'

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