rcplan9 - Online sa Cloud

PROGRAMA:

NAME

rc, cd, eval, exec, exit, flag, rfork, shift, wait, whatis, ., ~ - command language

SINOPSIS

rc [ -srdiIlxepvV ] [ -c utos ] [ file [ arg ... ]]

DESCRIPTION

Rc ay ang Plan 9 shell. Nagsasagawa ito ng mga command line na nabasa mula sa isang terminal o isang file o, kasama ang
ang -c bandila, mula sa mga rc listahan ng argumento.

Utos Linya
Ang command line ay isang sequence ng mga command, na pinaghihiwalay ng mga ampersand o semicolon (& or ;),
winakasan ng isang bagong linya. Ang mga utos ay isinasagawa sa pagkakasunud-sunod mula kaliwa hanggang kanan. Rc
hindi naghihintay ng utos na sinusundan ng & upang tapusin ang pagpapatupad bago simulan ang
sumusunod na utos. Sa tuwing may utos na sinusunod & ay naisakatuparan, ang process id nito ay
nakatalaga sa rc nagbabago $apid. Sa tuwing may utos hindi sinundan ng & paglabas o ay
winakasan, ang rc nagbabago $status nakakakuha ng mensahe ng paghihintay ng proseso (tingnan maghintay(3)); ito ay
maging null string kung matagumpay ang command.

Ang isang mahabang command line ay maaaring ipagpatuloy sa mga susunod na linya sa pamamagitan ng pag-type ng backslash (\)
sinundan ng isang bagong linya. Ang sequence na ito ay itinuturing na parang blangko. Ang backslash ay
hindi sa kabilang banda ay isang espesyal na karakter.

Isang tanda ng numero (#) at anumang sumusunod na mga character hanggang sa (ngunit hindi kasama) ang susunod na bagong linya
ay binabalewala, maliban sa mga panipi.

Simple Command
Ang isang simpleng utos ay isang pagkakasunud-sunod ng mga argumento na may interspersed na I/O redirections. Kung ang
unang argumento ay ang pangalan ng isang rc function o ng isa sa mga rc built-in na mga utos, ito ay
isinagawa ng rc. Kung hindi, kung ang pangalan ay nagsisimula sa isang slash (/), dapat ito ang pangalan ng path
ng programang isasagawa. Ang mga pangalan na walang inisyal na slash ay hinahanap sa a
listahan ng mga pangalan ng direktoryo na nakaimbak sa $landas. Ang unang maipapatupad na file ng ibinigay na pangalan
matatagpuan sa isang direktoryo sa $landas ay ang programa na isasagawa. Upang maging executable, ang gumagamit
dapat magkaroon ng pahintulot (tingnan stat(3)) at ang file ay dapat na isang executable
binary para sa kasalukuyang uri ng CPU ng makina, o isang script ng shell. Ang mga script ng shell ay nagsisimula sa a
linya na naglalaman ng buong pangalan ng path ng isang shell (karaniwan ay /bin/rc), prefix ng

Ang unang salita ng isang simpleng command ay hindi maaaring maging isang keyword maliban kung ito ay sinipi o kung hindi man
nakabalatkayo. Ang mga keyword ay
para sa habang kung hindi lumipat fn ~ ! @

Mga argumento at Variable
Ang ilang mga constructions ay maaaring gamitin kung saan mga rc Ang syntax ay nangangailangan ng isang argumento upang lumitaw.
Sa maraming mga kaso, ang halaga ng isang construction ay isang listahan ng mga argumento sa halip na isang solong
string.

Ang pinakasimpleng uri ng argumento ay ang hindi sinipi na salita: isang pagkakasunod-sunod ng isa o higit pang mga character
wala sa alinman ang blangko, tab, bagong linya, o alinman sa mga sumusunod:
# ; & | ^ $ = ` ' { } ( ) < >
Isang hindi naka-quote na salita na naglalaman ng alinman sa mga character * ? [ ay isang pattern para sa pagtutugma
laban sa mga pangalan ng file. Ang karakter * tumutugma sa anumang pagkakasunud-sunod ng mga character, ? tumutugma sa alinman
nag-iisang karakter, at [klase] tumutugma sa anumang karakter sa klase. Kung ang unang karakter
of klase is ~, ang klase ay kinukumpleto. Ang klase maaari ring maglaman ng mga pares ng mga character
pinaghiwalay ng -, na nakatayo para sa lahat ng character sa leksikal na paraan sa pagitan ng dalawa. Ang karakter /
dapat na tahasang lumitaw sa isang pattern, pati na rin ang unang character ng pangalan ng path
components . at ... Ang isang pattern ay pinapalitan ng isang listahan ng mga argumento, isa para sa bawat landas
pangalan na tumugma, maliban na ang isang pattern na tumutugma sa walang mga pangalan ay hindi pinapalitan ng walang laman na listahan,
ngunit sa halip ay nakatayo para sa sarili. Ang pagtutugma ng pattern ay ginagawa pagkatapos ng lahat ng iba pang mga operasyon. kaya,
x=/ Tmp echo $x^/*.c
posporo / tmp /*.c, sa halip na tumugma /*.c at pagkatapos ay prefixing / Tmp.

Ang isang sinipi na salita ay isang pagkakasunod-sunod ng mga character na napapalibutan ng mga solong panipi ('). Isang quote
ay kinakatawan sa isang sinipi na salita ng isang pares ng mga panipi ('').

Ang bawat isa sa mga sumusunod ay isang argumento.
(argumento)
Ang halaga ng isang pagkakasunod-sunod ng mga argumento na nakapaloob sa mga panaklong ay isang listahan na binubuo
ang mga miyembro ng bawat elemento ng sequence. Ang mga listahan ng argumento ay walang recursive
istraktura, kahit na ang kanilang syntax ay maaaring magmungkahi nito. Ang mga sumusunod ay buo
katumbas:
echo hi sa lahat
((echo) (hi there) everyone)
$argumento
$argumento(subskrip)
Ang argumento pagkatapos ng $ ay ang pangalan ng isang variable na ang halaga ay pinapalitan.
Maramihang mga antas ng hindi direksyon ay posible, ngunit ng kaduda-dudang utility. Variable
ang mga halaga ay mga listahan ng mga string. Kung argumento ay isang numero n, ang halaga ay ang nth
elemento ng $*, maliban kung $* ay wala n mga elemento, kung saan ang halaga ay walang laman.
If argumento ay sinusundan ng isang nakakulong na listahan ng mga subscript, ang halaga
ang substituted ay isang listahan na binubuo ng mga hiniling na elemento (pinagmulan 1). Ang
dapat sundin ng panaklong ang variable na pangalan na walang mga puwang. Maaari ring kunin ang mga subscript
ang form m-n or m- upang ipahiwatig ang pagkakasunod-sunod ng mga elemento. Mga takdang-aralin sa mga variable
ay inilarawan sa ibaba.
$#argumento
Ang halaga ay ang bilang ng mga elemento sa pinangalanang variable. Ang isang variable ay hindi kailanman
itinalaga ang isang halaga ay may zero na elemento.
$"argumento
Ang value ay isang string na naglalaman ng mga bahagi ng pinangalanang variable
pinaghihiwalay ng mga puwang. Ang isang variable na may zero na elemento ay nagbubunga ng walang laman na string.
`{utos}
rc nagpapatupad ng utos at binabasa ang karaniwang output nito, hinahati ito sa isang listahan ng
argumento, gamit ang mga character sa $ifs bilang mga separator. Kung $ifs ay hindi nakatakda kung hindi man,
ang halaga nito ay ' \t\n'.
<{utos}
>{utos}
Ang utos ay pinaandar nang asynchronous kasama ang karaniwang output o karaniwang input nito
konektado sa isang tubo. Ang halaga ng argumento ay ang pangalan ng isang file na tinutukoy
ang kabilang dulo ng tubo. Pinapayagan nito ang pagtatayo ng mga non-linear na pipeline.
Halimbawa, ang sumusunod ay nagpapatakbo ng dalawang utos luma at bago at gamit cmp upang ihambing
kanilang mga output
cmp <{luma} <{bago}
argumento^argumento
Ang ^ pinagsasama ng operator ang dalawang operand nito. Kung ang dalawang operand ay may pareho
bilang ng mga bahagi, ang mga ito ay pinagsama nang pairwise. Kung hindi, pagkatapos ay isang operand
dapat mayroong isang bahagi, at ang isa ay dapat na walang laman, at ang pagsasama ay
distributive.

Libre Carets
Sa karamihan ng mga pangyayari, rc ipapasok ang ^ awtomatikong operator sa pagitan ng mga salita na
hindi pinaghihiwalay ng puting espasyo. Sa tuwing isa sa $ ' ` sumusunod sa isang sinipi o hindi sinipi na salita o
ang isang hindi sinipi na salita ay sumusunod sa isang sinipi na salita na walang intervening na mga blangko o tab, a ^ ay ipinasok
sa pagitan ng dalawang. Kung ang isang salitang hindi sinipi ay agad na kasunod a $ at naglalaman ng isang karakter
maliban sa isang alphanumeric, underscore, o *Sa ^ ay ipinasok bago ang unang tulad
karakter. Sa gayon

cc -$mga watawat $stem.c

ay katumbas ng

cc -^$mga watawat $stem^.c

I / O redirections
Ang pagkakasunod-sunod >file nire-redirect ang karaniwang output file (file descriptor 1, karaniwang ang
terminal) sa pinangalanan file; >>file nagdaragdag ng karaniwang output sa file. Ang pamantayan
input file (file descriptor 0, normal din ang terminal) ay maaaring i-redirect mula sa isang file
ayon sa pagkakasunod-sunod <file, o mula sa isang inline na `dito dokumento' ayon sa pagkakasunod-sunod <<eof-marker.
Ang mga nilalaman ng isang dito na dokumento ay mga linya ng text na kinuha mula sa command input stream up
sa isang linyang walang laman kundi ang eof-marker, na maaaring naka-quote o hindi naka-quote
salita. Kung eof-marker ay hindi sinipi, mga variable na pangalan ng form $salita magkaroon ng kanilang mga halaga
pinalitan mula sa mga rc kapaligiran. Kung $salita ay sinusundan ng isang caret (^), ang caret ay
tinanggal. Kung eof-marker ay sinipi, walang pagpapalit na nagaganap.

Maaaring ilapat ang mga pag-redirect sa isang file-descriptor maliban sa karaniwang input o output ni
pagiging kwalipikado sa operator ng pag-redirect na may numero sa mga square bracket. Halimbawa, ang
diagnostic output (file descriptor 2) ay maaaring i-redirect sa pamamagitan ng pagsulat cc basura.c >[2]basura.

Ang isang file descriptor ay maaaring i-redirect sa isang bukas na descriptor sa pamamagitan ng pagsulat >[fd0=fd1] or
<[fd0=fd1]. Fd1 ay isang naunang binuksan na file descriptor at fd0 nagiging bagong kopya (sa
kahulugan ng dup(3)) nito. Maaaring isara ang isang file descriptor sa pamamagitan ng pagsulat >[fd0=] or <[fd0=].

Ang mga pag-redirect ay isinasagawa mula kaliwa hanggang kanan. Samakatuwid, cc basura.c > / dev / null >[2=1] at
cc basura.c >[2=1] > / dev / null may iba't ibang epekto: ang una ay naglalagay ng karaniwang output
/ dev / null at pagkatapos ay naglalagay ng diagnostic output sa parehong lugar, kung saan ang pangalawa ay nagdidirekta
diagnostic output sa terminal at nagpapadala ng karaniwang output sa / dev / null.

Compound Command
Isang pares ng mga utos na pinaghihiwalay ng isang pipe operator (|) ay isang utos. Ang karaniwang output ng
ang kaliwang utos ay ipinadala sa pamamagitan ng isang tubo sa karaniwang input ng tamang utos. Ang
maaaring palamutihan ang pipe operator upang gumamit ng iba't ibang mga deskriptor ng file. |[fd] nag-uugnay ang
output dulo ng pipe sa file descriptor fd sa halip na 1. |[fd0=fd1] nag-uugnay sa output sa
fd1 ng kaliwang command at input sa fd0 ng tamang utos.

Isang pares ng mga utos na pinaghihiwalay ng && or || ay isang utos. Sa alinmang kaso, ang kaliwang utos
ay naisakatuparan at ang exit status nito ay napagmasdan. Kung ang operator ay && ang tamang utos ay
naisakatuparan kung ang katayuan ng kaliwang command ay null. || nagiging sanhi ng tamang utos na maisakatuparan
kung ang katayuan ng kaliwang command ay hindi null.

Ang exit status ng isang command ay maaaring baligtad (non-null ay binago sa null, null ay binago
sa non-null) sa pamamagitan ng unahan nito ng a !.

Ang | operator ay may pinakamataas na nauuna, at kaliwa-kaugnay (ibig sabihin, mas mahigpit ang pagkakatali sa
kaliwa kaysa sa kanan). ! may intermediate precedence, at && at || may pinakamababa
karapatan sa pangunguna.

Ang unary @ operator, na may precedence na katumbas ng !, nagiging sanhi ng operand nito na maisakatuparan sa a
subshell.

Ang bawat isa sa mga sumusunod ay isang utos.
if ( listahan ) utos
A listahan ay isang pagkakasunod-sunod ng mga utos, na pinaghihiwalay ng &, ;, o bagong linya. Ito ay pinaandar
at kung ang exit status nito ay null, ang utos ay naisakatuparan.
if hindi utos
Ang kaagad na naunang utos ay dapat na kung(listahan) utos. Kung ito
kundisyon ay non-zero, ang utos ay naisakatuparan.
para sa(pangalan in argumento) utos
para sa(pangalan) utos
Ang utos ay isinasagawa nang isang beses para sa bawat isa argumento na may argumentong itinalaga sa pangalan.
Kung ang listahan ng argumento ay tinanggal, $* Ginagamit.
habang (listahan) utos
Ang listahan ay paulit-ulit na isinasagawa hanggang ang exit status nito ay hindi null. Sa bawat oras na ito
nagbabalik ng null status, ang utos ay pinaandar. Isang walang laman listahan ay kinuha upang magbigay ng null
status.
lumipat (argumento){listahan}
Ang listahan ay naghahanap ng mga simpleng utos na nagsisimula sa salita kaso. (Ang paghahanap
ay nasa `top level' lamang ng listahan. Yan ay, kaso sa nested constructs ay
hindi mahanap.) Argumento ay itinutugma laban sa bawat salitang sumusunod kaso gamit ang
pattern-matching algorithm na inilarawan sa itaas, maliban doon / at ang mga unang karakter
of . at .. hindi kailangang itugma nang tahasan. Kapag may nakitang tugma, mag-utos
ang listahan ay isinasagawa hanggang sa susunod na sumusunod kaso utos (sa pinakamataas na antas) o
ang closing brace.
{listahan}
Ang mga braces ay nagsisilbing baguhin ang pagpapangkat ng mga utos na ipinahiwatig ng mga priyoridad ng operator. Ang
katawan ay isang pagkakasunod-sunod ng mga utos na pinaghihiwalay ng &, ;, o bagong linya.
fn pangalan{listahan}
fn pangalan
Ang unang form ay tumutukoy sa isang function na may ibinigay pangalan. Sa dakong huli, sa tuwing a
utos na ang unang argumento ay pangalan ay nakatagpo, ang kasalukuyang halaga ng
ang natitirang listahan ng argumento ng command ay itatalaga sa $*, pagkatapos i-save ito
kasalukuyang halaga, at rc ipapatupad ang listahan. Ang pangalawang anyo ay nag-aalis pangalan's
kahulugan ng function.
fn nota{listahan}
fn nota
Ang isang function na may espesyal na pangalan ay tatawagin kapag rc tumatanggap ng katumbas
tala; tingnan mo ipagbigay-alam(3). Ang mga wastong pangalan ng tala (at kaukulang mga tala) ay buntong hininga
(hangup), sign (makatakip), sigalrm (alarma), At sigfpe (floating point trap).
Bilang default rc lalabas sa pagtanggap ng anumang signal, maliban kapag interactive na tumakbo, sa
kung aling kaso ang nakakaabala at humihinto na karaniwang sanhi rc upang itigil ang anumang ginagawa nito at
magsimulang magbasa ng bagong utos. Ang pangalawang anyo ay sanhi rc upang mahawakan ang isang senyas sa
default na paraan. Rc kinikilala ang isang artipisyal na tala, sigexit, na nangyayari kung kailan rc is
malapit na matapos ang execute.
pangalan=argumento utos
Anumang utos ay maaaring unahan ng isang pagkakasunud-sunod ng mga takdang-aralin na may interspersed
mga pag-redirect. Ang mga takdang-aralin ay mananatiling may bisa hanggang sa katapusan ng utos,
maliban kung ang utos ay walang laman (ibig sabihin, ang mga takdang-aralin ay nag-iisa), kung saan sila
ay epektibo hanggang sa mapawalang-bisa ng mga susunod na takdang-aralin.

Built-in Command
Ang mga utos na ito ay isinasagawa sa loob ng rc, kadalasan dahil nagbabago ang kanilang pagpapatupad o
depende sa rcpanloob na estado.
. file ...
Isagawa ang mga utos mula sa file. $* ay nakatakda para sa tagal hanggang sa natitira sa
sumusunod na listahan ng argumento file. talaksan ay hinahanap para sa paggamit $landas.
builtin utos ...
Isakatuparan utos gaya ng dati maliban sa anumang function na pinangalanan utos ay hindi pinapansin pabor
ng built-in na kahulugan.
cd [dir]
Baguhin ang kasalukuyang direktoryo sa dir. Ang default na argumento ay $bahay. dir is
hinanap sa bawat isa sa mga direktoryo na binanggit sa $cdpath.
eval [arg ...]
Ang mga argumento ay pinagsama-samang pinaghihiwalay ng mga puwang sa isang string, basahin bilang
input sa rc, at naisakatuparan.
exec [utos ...]
Ang pagkakataong ito ng rc pinapalitan ang sarili sa ibinigay (hindi built-in) utos.
bandila f [+-]
Alinman sa set (+), malinaw (-), o pagsubok (ni + ni -) ang bandila f, Kung saan f ay isang
solong karakter, isa sa mga flag ng command line (tingnan ang Invocation, sa ibaba).
lumabas [katayuan]
Lumabas gamit ang ibinigay na katayuan sa paglabas. Kung walang ibinigay, ang kasalukuyang halaga ng $status is
ginagamit.
rfork [nNeEsfFm]
Maging isang bagong pangkat ng proseso gamit ang rfork(flag) saan flag ay binubuo ng
bitwise O ng rfork mga flag na tinukoy ng mga titik ng opsyon (tingnan tinidor(2)). Kung hindi
flag ay ibinigay, sila ay default sa ens. ang flag at ang kanilang mga kahulugan ay: n is
RFNAMEG; N is RFCNAMEG; e is RFENVG; E is RFCENVG; s is RFNOTEG; f is RFFDG; F is
RFCFDG, At m is RFNOMNT.
ilipat [n]
Tanggalin ang una n (default 1) mga elemento ng $*.
maghintay [pid]
Maghintay para sa proseso sa ibinigay pid para lumabas. Kung hindi pid ay ibinigay, lahat
ang mga natitirang proseso ay hinihintay.
ano ang pangalan ...
I-print ang halaga ng bawat isa pangalan sa isang form na angkop para sa input sa rc. Ang output ay isang
pagtatalaga sa anumang variable, ang kahulugan ng anumang function, isang tawag sa builtin para
anumang built-in na command, o ang nakumpletong pathname ng anumang executable file.
~ paksa huwaran ...
Ang paksa ay tumutugma laban sa bawat isa huwaran sa pagkakasunod-sunod. Kung ito ay tumutugma sa alinman
pattern, $status ay nakatakda sa zero. Kung hindi, $status ay nakatakda sa isa. Ang mga pattern ay
kapareho ng para sa pagtutugma ng pangalan ng file, maliban doon / at ang unang karakter ng . at
.. hindi kailangang itugma nang tahasan. Ang pattern ay hindi napapailalim sa pangalan ng file
pagtutugma bago ang ~ Ang utos ay naisakatuparan, kaya hindi na kailangang isama ang mga ito
mga panipi.

kapaligiran
Ang kapaligiran ay isang listahan ng mga string na ginawang magagamit sa pagpapatupad ng mga binary ng kernel.
Rc lumilikha ng isang entry sa kapaligiran para sa bawat variable na ang halaga ay hindi walang laman, at para sa bawat isa
function. Ang string para sa isang variable na entry ay may pangalan ng variable na sinusundan ng = at ang
halaga. Kung ang halaga ay may higit sa isang bahagi, ang mga ito ay pinaghihiwalay ng SOH (001)
mga karakter. Ang string para sa isang function ay ang rc input na tumutukoy sa function.
Ang pangalan ng isang function sa kapaligiran ay ang pangalan ng function na sinusundan ng

Kailan rc magsisimulang ipatupad ito ay nagbabasa ng variable at mga kahulugan ng function mula sa kapaligiran nito.

espesyal Variable
Ang mga sumusunod na variable ay itinakda o ginagamit ng rc.
$* Itakda sa rclistahan ng argumento ni sa panahon ng pagsisimula. Sa tuwing a . utos o a
function ay naisakatuparan, ang kasalukuyang halaga ay nai-save at $* tumatanggap ng bagong argumento
listahan. Ang na-save na halaga ay naibalik sa pagkumpleto ng . o function.
$apid Sa tuwing magsisimula ang isang proseso nang asynchronously sa &, $apid ay nakatakda sa proseso nito
id.
$bahay Ang default na direktoryo para sa cd.
$ifs Ang mga input field separator na ginagamit sa mga pamalit na backquote. Kung $ifs ay hindi nakatakda
in rckapaligiran ni, ito ay sinisimulan sa blangko, tab at bagong linya.
$landas Ang path ng paghahanap na ginamit upang mahanap ang mga command at input file para sa . utos. Kung hindi
itinakda sa kapaligiran, ito ay sinisimulan sa pamamagitan ng pag-parse ng $ PATH variable (tulad ng sa
sh(1)) o ni landas=(. / bin). Ang mga variable $landas at $ PATH ay pinananatili
magkasama: ang mga pagbabago sa isa ay makikita sa isa pa.
$pid Itakda sa panahon ng pagsisimula sa rcid ng proseso.
$prompt Kailan rc ay tumatakbo nang interactive, ang unang bahagi ng $prompt ay naka-print bago
binabasa ang bawat utos. Ang pangalawang bahagi ay naka-print sa tuwing may bagong linya
nai-type at higit pang mga linya ay kinakailangan upang makumpleto ang utos. Kung hindi nakatakda sa
kapaligiran, ito ay pinasimulan ng prompt=('% ' ' ').
$status Itakda sa mensahe ng paghihintay ng huling naisakatuparan na programa. (maliban kung nagsimula sa &).
! at ~ magbago din $status. Ang halaga nito ay ginagamit upang kontrolin ang pagpapatupad sa &&, ||,
if at habang mga utos. Kailan rc paglabas sa end-of-file ng input nito o sa pag-execute
an lumabas utos na walang argumento, $status ang exit status nito.

Pagsamba
If rc ay nagsimula nang walang mga argumento na nagbabasa ng mga utos mula sa karaniwang input. Kung hindi nito
ang unang argumento na hindi bandila ay ang pangalan ng isang file kung saan magbabasa ng mga utos (ngunit tingnan ang -c
sa ibaba). Ang mga kasunod na argumento ay nagiging paunang halaga ng $*. Rc tumatanggap ng mga sumusunod
mga flag ng command-line.
-c pisi Ang mga utos ay binabasa mula sa pisi.
-s I-print ang exit status pagkatapos ng anumang command kung saan ang status ay non-null.
-e Lumabas kung $status ay hindi null pagkatapos magsagawa ng isang simpleng utos.
-i If -i ay naroroon, o rc ay hindi binibigyan ng mga argumento at ang karaniwang input nito ay a
terminal, ito ay tumatakbo nang interactive. Ang mga utos ay sinenyasan para sa paggamit $prompt.
-I Sinisigurado rc ay hindi tumatakbo nang interactive.
-l If -l ay ibinigay o ang unang character ng argument zero ay -, rc nagbabasa ng mga utos
mula $home/lib/profile, kung mayroon ito, bago basahin ang normal na input nito.
-p Isang no-op.
-d Isang no-op.
-v Echo input sa file descriptor 2 habang binabasa ito.
-x I-print ang bawat simpleng command bago ito isagawa.
-r I-print ang impormasyon sa pag-debug (panloob na anyo ng mga utos habang isinasagawa ang mga ito).

SOURCE

/src/cmd/rc

Gamitin ang rcplan9 online gamit ang mga serbisyo ng onworks.net