Prefazione del traduttore
1.0 Introduzione
1.1 Comandi elementari
1.2 Comandi in background
1.3 Redirezione dell'input e
dell'output
1.4 Pipeline e filtri
1.5 Generazione di nomi di file
1.6 Quotatura
1.7 I prompt
1.8 La shell e il login
1.9 Sommario
2.0 Procedure di shell
2.1 Controllo di flusso - for
2.2 Controllo di flusso - case
2.3 Sintassi "here document"
2.4 Variabili di shell
2.5 Il comando test
2.6 Controllo di flusso - while
2.7 Controllo di flusso - if
2.8 Raggruppamento di comandi
2.9 Debugging delle procedure di
shell
2.10 Il comando man
3.0 Parametri keyword
3.1 Trasmissione dei parametri
3.2 Sostituzione dei parametri
3.3 Sostituzione dei comandi
3.4 Valutazione e quotatura
3.5 Trattamento degli errori
3.6 Intercettamento delle
interruzioni
3.7 Esecuzione dei comandi
3.8 Invocare la shell
Ringraziamenti
Appendice A - Grammatica
Appendice B - Meta-caratteri e Parole
Riservate
Questo documento descrive la shell sh. Nei moderni sistemi UNIX sono disponibili altre shell più moderne e potenti, ma la shell sh è ancora disponibile per ragioni di compatibilità. Inoltre la shell bash (Bourne-Again SHell), molto diffusa sui sistemi GNU/Linux, costituisce essenzialmente una estensione della sh. In questi sistemi non è generalmente disponibile una versione propria di sh, ma la shell bash può essere invocata col nome sh per ottenere la massima compatibilità con sh. Per tali ragioni è più semplice e conveniente imparare prima la shell sh. Se desiderate potete poi imparare le estensioni della bash consultando bash (1).
Con la traduzione italiana del testo presente spero di poter contribuire a diminuire gli sforzi di chi vuole imparare da sé ad usare un sistema UNIX, per studio, per lavoro, per scelta o per qualsiasi altro motivo. Nella traduzione ho cercato di essere il più fedele possibile al testo originale. Quando volevo aggiungere qualche precisazione l'ho fatto sempre sotto forma di note che trovate riunite alla fine di questo documento. Sono ben accetti commenti ed osservazioni che potete indirizzare ad uno degli indirizzi di email indicati nel mio sito.
who
è un comando che stampa i nomi degli utenti che sono loggati
attualmente nel sistema. Il comando
ls -l
stampa la lista dei file nella directory corrente. L'argomento
-l dice ad ls di stampare oltre il nome del file
anche le informazioni di stato, come la dimensione e la data di
creazione di ogni file [1].
cc pgm.c &
chiama in causa compilatore C per compilare il file pgm.c.
Il carattere & finale è un operatore che ordina
alla shell di non aspettare che il comando completi la sua
esecuzione. [2] Per rendere più facile tenere traccia di un
processo lanciato in background, la shell riporta il numero del
processo subito dopo averlo creato. La lista dei processi
attualmente attivi si può ottenere usando il comando
ps.
ls -l >file
La notazione >file viene interpretata dalla shell e non
viene passata come argomento ad ls. Se il file non
esiste allora la shell lo crea; altrimenti il contenuto originale
del file viene sostituito con l'output di ls.
L'output può essere appeso ad un file usando la notazione
ls -l >>file
Anche in questo caso il file viene creato se non esiste
già.
L'input standard di un comando può essere preso da un file invece che dal terminale scrivendo, per esempio,
wc <file
Il comando wc legge il suo standard input (in questo esempio
rediretto da file) e stampa il numero di caratteri, parole e
linee trovate. Se quello che ci occorre è solo il numero di
linee allora può essere usato questo comando
wc -l <file
ls -l | wc
Due comandi connessi in questo modo costituiscono una
pipeline e l'effetto complessivo è lo stesso di
ls -l >file; wc <file
salvo che non viene usato nessun file. Invece quello che
accade è che i due processi vengono connessi tramite una
pipe (vedi pipe (2)) e vengono eseguiti in parallelo.
Le pipe sono unidirezionali e la sincronizzazione tra i processi viene fatta bloccando wc quando non c'è niente da leggere e bloccando ls quando la pipe è piena.
Un filtro è un comando che legge il suo standard input, trasformandolo in qualche modo, e stampa il risultato come output. Un filtro del genere, chiamato grep, seleziona dal suo input quelle linee che contengono la stringa specificata. Per esempio,
ls | grep old
stampa quelle linee, se ci sono, dell'output di ls che
contengono la stringa old. Un'altro esempio molto utile di
filtro è sort. Per esempio,
who | sort
stamperà una lista alfabeticamente ordinata di tutti gli
utenti loggati.
Una pipeline può constare di più di due comandi, per esempio,
ls | grep old | wc -l
stampa quanti sono i file nella directory corrente che contengono
la stringa old.
ls -l main.c
stampa informazioni relative al file main.c.
La shell fornisce un meccanismo per generare una lista di nomi di file che corrispondono ad un modello di ricerca (pattern). Per esempio,
ls -l *.c
genera, come argomenti di ls, tutti i nomi dei file nella
directory corrente che terminano in .c. Il carattere *
è un pattern che corrisponderà a qualsiasi stringa,
inclusa la stringa nulla. In generale i pattern possono
utilizzare i seguenti metacaratteri:
[a-z]*
fa corrispondenza con tutti i nomi nella directory corrente che
iniziano con una delle lettere dalla a alla z.
/usr/fred/test/?
è il modello di tutti i nomi nella directory
/usr/fred/test che constano di un singolo carattere. [3] Se non
viene trovato nessun nome di file che corrisponde al pattern,
allora il modello viene passato, invariato, come un argomento.
Questo meccanismo è utile sia per risparmiarsi la digitazione sia per selezionare alcuni nomi secondo il pattern specificato. Può essere utile anche per ricercare dei file. Per esempio,
echo /usr/fred/*/core
trova e stampa i nomi di tutti i file core nelle
sotto-directory di /usr/fred. [4]
(echo è un comando standard di UNIX che stampa i suoi
argomenti, separati da spazi bianchi.) Quest'ultima
funzionalità può essere costosa, perché
richiede la scansione di tutte le sotto-directory di
/usr/fred.
C'è un'eccezione alle regole generali date prima sul significato dei pattern. Il carattere `.' all'inizio di un nome di file deve essere indicato esplicitamente nel pattern.
echo *
perciò stamperà tutti i nomi dei file nella directory
corrente che non iniziano per `.'.
echo .*
visualizzerà tutti i nomi dei file che iniziano con
`.'. Questo comportamente evita corrispondenze non volute
con i nomi di file ` .' e `..' che indicano `la
directory corrente' e la `directory genitore'
rispettivamente. (Si noti che anche ls per default non
visualizza le informazioni relative ai file `.' e `
.. '.)
echo \?
visualizzerà un ? singolo, mentre
echo \\
mostra un \ singolo. Per consentire ad una stringa troppo lunga di
essere continuata su più di una linea la sequenza
\newline viene ignorata.
Il \ è conveniente per quotare caratteri singoli. Ma quando più di un carattere di una stringa abbisogna della quotatura il meccanismo precedente è prolisso e soggetto ad errori. Una stringa di caratteri può essere quotata racchiudendola tra apici singoli. Per esempio,
echo xx'****'xx
visualizzerà
xx****xx
La stringa quotata non può contenere una virgoletta singola
ma può contenere degli accapi, che vengono mantenuti. Questo
meccanismo di quoting è il più semplice e ne è
raccomandato l'uso ove necessario.
E' disponibile anche un terzo meccanismo di quoting che usa gli apici doppi e impedisce l'interpretazione speciale solo di alcuni (e non tutti) i metacaratteri. La discussione dettagliata di questo meccanismo viene rimandata alla sezione 3.4.
PS1=yesdear
che imposta la stringa yesdear come prompt. Se viene
digitato un finelinea quando è richiesto dell'input
ulteriore per completare il comando corrente allora la shell
visualizzerà il prompt `> '. Talvolta l'emissione
di questo prompt avviene per errore perché si è
dimenticato di digitare un segno di quotatura di chiusura. Se
questo prompting di secondo livello avviene per errore, allora
occorre premere il tasto di interruzione (DEL [5] ) per forzare la shell ad ignorare il comando
corrente ed avviare la lettura di un altro comando. Anche questo
prompt può essere cambiato ad esempio tramite l'istruzione,
PS2=more
sh file [ args ... ]
richiama la shell per leggere i comandi da file. Un file del
genere viene detto procedura di comandi oppure procedura
di shell. Con la chiamata possono essere passati anche degli
argomenti a cui lo script file fa riferimento usando i
parametri posizionali $1, $2, .... Per esempio, se il file
wg contiene
who | grep $1
allora
sh wg fred
è equivalente a
who | grep fred
I file in UNIX hanno tre attributi indipendenti, lettura (read),
scrittura (write) ed esecuzione (execute). Il comando
UNIX chmod (1) può essere usato per rendere
eseguibile un file. Per esempio,
chmod +x wg
garantirà che il file wg ha attivo il bit di
eseguibilità. Dopodiché, il comando [6]
wg fred
è equivalente a
sh wg fred
Ciò permette di usare in modo intercambiabile i programmi e
le procedure di shell. In entrambi i casi viene creato un nuovo
processo per eseguire il comando.
In aggiunta a fornire nomi per riferirsi ai parametri posizionali, la shell rende disponibile il numero stesso dei parametri posizionali nella variabile $#. Il nome del file che si sta eseguendo è invece disponibile come valore di $0.
Il parametro speciale della shell $* viene sostituito con tutti i parametri posizionali eccetto $0. Un tipico uso di questo parametro viene fatto per imporre degli argomenti di default, come in,
nroff -T450 -ms $*
che semplicemente postpone alcuni argomenti a quelli di default
già dati.
...
fred mh0123
bert mh0789
...
Il testo di tel è
for i
do grep $i /usr/lib/telnos; done
Il comando
tel fred
stampa quelle linee in /usr/lib/telnos che contengono la
stringa fred.
tel fred bert
stampa le linee che contengono fred seguite da quelle che
contengono bert.
La shell riconosce la seguente notazione generale per il ciclo for :
for nome in w1 w2 ...
do lista-comandi
done
Una lista-comandi è una sequenza di uno o più
comandi semplici separati o terminati da un accapo o un punto e
virgola. Per di più, le parole riservate come do e
done vengono riconosciute solo se vengono dopo un accapo o
un punto e virgola. nome è una variabile della shell
a cui vengono assegnate le parole w1 w2... a turno,
ogni volta che viene eseguita la lista-comandi che segue il
do . Se in w1 w2... viene omesso allora
il loop viene eseguito una volta per ciascun parametro posizionale;
vale a dire, è come se ci fosse in $*.
Un altro esempio di uso del ciclo for è il comando create il cui testo è [7]
for i do >$i; done
Il comando
create alpha beta
crea due file vuoti alpha e beta nella directory
corrente. La notazione >file può essere usata da
sola per creare o cancellare i contenuti di un file. Notare inoltre
che un punto e virgola (o un accapo) è richiesto prima
done.
case $# in
1) cat >>$1 ;;
2) cat >>$2 <$1 ;;
*) echo \'usage: append [ from ] to\' ;;
esac
è un commando di append. Quando viene chiamato con un
solo argomento come in
append file
$# è la stringa 1 e quindi lo standard input viene
copiato alla fine di file usando il comando cat.
append file1 file2
appende il contenuto di file1 in file2. Se il numero
di argomenti forniti ad append è diverso da 1 o 2
allora viene stampato un messaggio che indica come si usa
correttamente.
La forma generale di un comando case è
case parola in pattern) lista-comandi;;
... esac
La shell verifica se la parola corrisponde con ciascun
pattern, nell'ordine in cui i modelli appaiono. Se
viene trovata una corrispondenza, viene eseguita la
lista-comandi associata e l'esecuzione del case si
conclude. Dal momento che il pattern * fa corrispondenza con
qualsiasi stringa, può essere usato come caso di default.
Attenzione che non viene fatto alcun controllo per garantire che
solo uno dei pattern corrisponde all'argomento del case. La prima
corrispondenza trovata definisce l'insieme di comandi che deve
essere eseguito. Nell'esempio qui sotto i comandi che seguono il
secondo pattern * non saranno mai eseguiti.
case $# in
*) ... ;;
*) ... ;;
esac
Un altro esempio di uso del costrutto case è utile
per distinguere tra differenti tipi di un argomento.
L'esempio seguente è un frammento di un comando tipo
cc.
for i
do case $i in
-[ocs]) ... ;;
-*) echo \'unknown flag $i\' ;;
*.c) /lib/c0 $i ... ;;
*) echo \'unexpected argument $i\' ;;
esac
done
Per far sì che si possano associare gli stessi comandi a
più di un pattern, il comando case prevede l'uso di
pattern alternativi separati da |. Per esempio,
case $i in
-x|-y) ...
esac
è equivalente a
case $i in
-[xy]) ...
esac
Per quanto riguarda il quoting, si applicano le solite convenzioni,
cosicché
case $i in
\?) ...
farà corrispondenza col carattere ?.
for i
do grep $i <<!
...
fred mh0123
bert mh0789
...
!
done
In questo esempio la shell considera le linee tra <<!
e ! come lo standard input per il comando grep. La
stringa ! è arbitraria, essendo il documento
terminato da una linea che consiste della sola stringa che segue
<< [8].
Se ci fossero dei parametri all'interno di una here document, sarebbero sostituiti prima che venga resa disponibile come input al comando grep. Ciò viene illustrato dalla seguente procedura chiamata edg.
ed $3 <<%
g/$1/s//$2/g
w
%
La chiamata
edg stringa1 stringa2 file
è in questo caso equivalente al comando
ed file <<%
g/stringa1/s//stringa2/g
w
%
che cambia tutte le occorrenze di stringa1 nel file
file in stringa2. Si può impedire la
sostituzione di una variabile usando il \ per quotare il carattere
speciale $ come in questo esempio
ed $3 <<+
1,\$s/$1/$2/g
w
+
(Questa versione del comando edg è equivalente alla
precedente salvo che ed stamperà un ? se non
c'è alcuna occorrenza della stringa $1. ) La
sostituzione delle variabili all'interno di un documento
here può disattivata del tutto quotando la stringa di
terminazione, per esempio,
grep $i <<\#
...
#
In tal caso il documento viene trasmesso senza modifiche al comando
grep. Quest'ultima è la forma più efficiente
da utilizzarsi allorquando la sostituzione delle variabili non
è richiesta in un documento here.
user=fred box=m000 acct=mh0000
che assegna valori alle variabili user, box e acct.
Ad una variabile può essere assegnata la stringa nulla ad
esempio col comando,
null=
Il valore di una variabile viene sostituito facendo precedere il
suo nome con $; per esempio,
echo $user
stamperà fred.
Le variabili possono essere usate anche interattivamente come abbreviazioni per stringhe usate di frequente. Per esempio,
b=/usr/fred/bin
mv pgm $b
sposterà il file pgm dalla directory corrente nella
directory /usr/fred/bin. È disponibile una notazione
più generale per indicare la sostituzioni dei parametri (o
delle variabili), che è del tipo,
echo ${user}
in tal caso è equivalente a
echo $user
e viene usata quando il nome del parametro da sostituire è
seguito da una lettera o una cifra, per evitare ambiguità.
Per esempio,
tmp=/tmp/ps
ps a >${tmp}a
dirigerà l'output di ps al file /tmp/psa,
mentre,
ps a >$tmpa
indicherebbe invece la sostituzione del valore della variabile
tmpa.
Fatta eccezione per $?, tutte le variabili seguenti sono predefinite, nel senso che hanno un valore iniziale o corrente calcolato direttamente dalla shell [9]. La variabile $? viene riassegnata dopo l'esecuzione di ciascun comando.
ps a >/tmp/ps$$
...
rm /tmp/ps$$
MAIL=/usr/mail/fred
cd /usr/fred/bin
rende /usr/fred/bin. la directory corrente.
cat wn
stamperà sul terminale il file chiamato wn in quella
directory. Il comando cd senza argomenti è
equivalente a
cd $HOME
Anche questa variabile di solito viene impostata nel file profile
dell'utente, eseguito automaticamente dalla shell dopo il
login.
PATH=:/usr/fred/bin:/bin:/usr/bin
specifica che i comandi eseguibili devono essere cercati prima
nella directory corrente (la stringa nulla che precede il primo
segno di :), e poi nelle directory /usr/fred/bin,
/bin e infine in /usr/bin, nell'ordine specificato. In
questo modo i singoli utenti possono avere i loro comandi `privati'
e potervi accedere facilmente indipendentemente da quale sia la
loro directory corrente. Se invece il nome di un comando contiene
uno /, allora il path di ricerca non viene utilizzato,
perché non viene fatta alcuna ricerca; viene fatto solo un
singolo tentativo di eseguire il comando nel percorso
specificato.
test -f file
ritorna lo stato di uscita zero se file esiste, altrimenti
ritorna uno stato di terminazione diverso da zero. In generale
test valuta un predicato e ne ritorna il risultato come suo
stato di uscita. Di seguito viene fornita una lista di alcuni degli
argomenti di test utilizzati più di frequente. Per la
lista completa vedere test (1).
while lista-comandi1
do lista-commandi2
done
Il valore testato dal ciclo while è lo stato di
uscita dell'ultimo comando singolo tra quelli che seguono la
keyword while. Ogni volta che gira il ciclo viene eseguita
la lista-comandi1; se il valore ritornato è zero
allora verrà eseguita la lista-commandi2 e il ciclo
continuerà a girare; altrimenti, il ciclo termina. Per
esempio,
while test $1
do ...
shift
done
è equivalente a
for i
do ...
done
shift è un comando di shell che rinomina i parametri
posizionali $2, $3, ... in $1, $2, ..., procedimento
che provoca la perdita del parametro $1.
Un altro tipico utilizzo di un ciclo while/until consiste nell'aspettare che si verifichi un qualche evento esterno e poi lanciare dei comandi quando si è verificato. In un ciclo di tipo until la condizione di terminazione va negata rispetto al ciclo while corrispondente. Per esempio,
until test -f file
do sleep 300; done
comandi
continuerà a ciclare finché non esiste file.
Ogni volta che gira il ciclo si aspetta per 5 minuti prima di
testare di nuovo l'esistenza del file. (Presumibilmente un altro
processo alla fine creerà il file.)
if lista-comandi
then lista-comandi
else lista-comandi
fi
qui viene testato il valore ritornato dall'ultimo singolo comando
che segue la parola chiave if.
Il comando if può essere usato insieme al comando test per verificare l'esistenza di un file
if test -f file
then processa file
else fa qualcos'altro
fi
Un esempio d'uso combinato dei costrutti if, case e
for si trova nella sezione 2.10.
Un comando di tipo if per effettuare test multipli del tipo
if ...
then ...
else if ...
then ...
else if ...
...
fi
fi
fi
può essere riscritto adoperando una estensione della
notazione if in questo modo,
if ...
then ...
elif ...
then ...
elif ...
...
fi
L'esempio successivo è il comando touch che cambia la
data e l'ora di `ultima modifica' ad una lista di file. Questo
comando può essere usato in congiunzione con make (1)
per forzare la ricompilazione di un certo insieme di file.
flag=
for i
do case $i in
-c) flag=N ;;
*) if test -f $i
then ln $i junk$$; rm junk$$
elif test $flag
then echo file \'$i\' does not exist
else >$i
fi
esac
done
Il flag -c in questo comando viene utilizzato per forzare la
creazione dei file specificati dopo il flag stesso come argomenti,
nel caso questi non esistano già. In assenza del flag
-c, se un file non esiste, viene stampato un messaggio di
errore. Alla variabile di shell flag viene assegnata una
stringa non nulla non appena viene incontrato l'argomento
-c. I comandi
ln ...; rm ...
creano un link al file e subito dopo lo rimuovono, causando
così l'aggiornamento della data di ultima modifica.
La sequenza
if comando1
then comando2
fi
può essere abbreviata in
comando1 && comando2
Invece,
comando1 || comando2
produce l'esecuzione di comando2 solo se fallisce il
comando1. In entrambi i casi il valore che viene ritornato
dalla sequenza è quello dell'ultimo comando singolo
eseguito.
{ lista-comandi ; }
oppure
( lista-comandi )
Nel primo modo la lista-comandi viene eseguita come parte
del processo corrente. Nella seconda forma invece la
lista-comandi viene eseguita in un processo a sé
stante. Per esempio,
(cd x; rm junk )
esegue rm junk nella directory x senza cambiare la
directory corrente della shell di invocazione.
I comandi
cd x; rm junk
hanno identico effetto sul file ma fanno rimanere la shell
invocante nella directory x.
set -v
(v sta per verbose, prolisso) e fa sì che le linee di
codice della procedura siano stampate nel momento che vengono
lette. È utile per aiutare ad isolare gli errori di
sintassi. Questa modalità di debugging può essere
azionata anche dall'esterno, senza dover modificare il sorgente
della procedura per mezzo del comando
sh -v proc ...
dove proc è il nome della procedura di shell da
invocare. Questo flag -v può essere usato insieme al
flag -n che impedisce l'esecuzione dei comandi successivi
all'impostazione del flag (questi vengono letti, ma semplicemente
ignorati; da notare che il comando set -n dato al terminale
lo rende inutile, in quanto tutti i comandi dati non verranno
eseguiti, finché non si digita il carattere di end-of-file.)
Il comando
set -x
produce una traccia di esecuzione. Dopo che è stata
effettuata la sostituzione di eventuali parametri, ogni comando
viene stampato proprio poco prima della sua esecuzione (Provate ad
impostare questi flag al terminale per vedere l'effetto che hanno)
[11]. Entrambi i flag -v e -x possono essere
disabilitati tramite
set -
L'insieme dei flag correntemente attivati nella shell è
disponibile nella variabile speciale $-.
$ man sh
$ man -t ed
$ man 2 fork
Il primo comando fa stampare la sezione del manuale relativa alla
shell sh. Dal momento che non è stata specificata
esplicitamente alcuna sezione, viene visualizzata la manpage di
sh nella sezione 1. Il secondo esempio effettua la
composizione del testo (opzione -t) della sezione del
manuale del comando ed. L'ultimo stampa la pagina di manuale
della system call fork dalla sezione 2.
cd /usr/man
: 'colon is the comment command'
: 'default is nroff ($N), section 1 ($s)'
N=n s=1
for i
do case $i in
[1-9]*) s=$i ;;
-t) N=t ;;
-n) N=n ;;
-*) echo unknown flag \'$i\' ;;
*) if test -f man$s/$i.$s
then ${N}roff man0/${N}aa man$s/$i.$s
else : 'look through all manual sections'
found=no
for j in 1 2 3 4 5 6 7 8 9
do if test -f man$j/$i.$j
then man $j $i
found=yes
fi
done
case $found in
no) echo \'$i: manual page not found\'
esac
fi
esac
done
Figura 1. Una versione del comando man
user=fred comando
esegue comando con la variabile user impostata al
valore fred. Il flag -k [13] impone
alla shell di interpretare in questo modo gli argomenti della forma
nome=valore in qualsiasi punto della lista degli argomenti e
non solo se precedono il nome del comando. Questi nomi
vengono spesso chiamati parametri con nome o parametri keyword. Se
rimangono degli argomenti che non sono del tipo nome=valore
nella lista dei parametri, saranno disponibili come parametri
posizionali $1, $2, ....
Il comando set può essere usato anche per assegnare valori ai parametri posizionali dall'interno di una procedura. Per esempio,
set - *
imposta $1 al primo nome di file nella directory corrente,
$2 al prossimo, e così via. Notare che il primo
argomento di set, -, serve per garantire un corretto trattamento
dei suoi parametri nel caso in cui il primo nome di file cominci
con un -.
export user box
marca per l'esportazione le variabili user e box.
Quando viene invocata una procedura di shell vengono fatte delle
copie di tutte le variabili esportabili ad uso interno della
procedura chiamata. Le modifiche di tali variabili all'interno
della procedura non hanno effetto sui valori che queste hanno nella
shell chiamante. È in generale giusto affermare che una
procedura di shell non può modificare lo stato del suo
chiamante senza una esplicita richiesta di modifica da parte del
chiamante. (La condivisione di descrittori di file rappresenta
un'eccezione a questa regola.)
Quei nomi per cui si vuole mantenere costante il loro valore possono essere dichiarati come readonly, ossia "a sola lettura". La sintassi di questo comando è la stessa del comando export,
readonly name ...
Successivi tentativi di assegnare valori a variabili readonly
saranno illegali.
echo $d
oppure
echo ${d}
non visualizzerà niente. Può anche essere stabilita
una stringa di default come in
echo ${d-.}
che stamperà il valore della variabile d se questa
è settata altrimenti visualizza un `.'. La stringa di
default viene valutata utilizzando le usuali convenzioni per la
quotatura cosicché
echo ${d-'*'}
stampa * se la variabile d non è inizializzata
[14]. Analogamente
echo ${d-$1}
visualizza il valore di d se è settata, altrimenti
visualizza il valore di $1 (se è settata a qualche
valore). Ad una variabile può essere assegnato un valore di
default usando la notazione
echo ${d=.}
che effettua la stessa sostituzione condizionale di stringhe di
echo ${d-.}
e inoltre nel caso in cui d non fosse stata inizializzata
precedentemente, la imposta sulla stringa `.'. (La notazione
${...=...} non può essere utilizzata con i
parametri posizionali.)
Nel caso in cui non esista un valore di default ragionevole per una variabile, risulta utile la notazione
echo ${d?messaggio}
che visualizza il valore della variabile d se questa ne ha
uno, altrimenti la shell stampa il messaggio e l'esecuzione
della procedura di shell viene interrotta. Se manca il
messaggio viene stampato un messaggio standard [15]. Una procedura di shell che richieda l'impostazione
preventiva di alcuni parametri potrebbe iniziare come segue.
: ${user?} ${acct?} ${bin?}
...
I due punti (:) rappresentano un vero e proprio comando
interno (built in) della shell che non fa nulla tranne che valutare
i suoi argomenti. In questo esempio se almeno una delle variabili
user, acct o bin non è settata, allora la
shell abbandonerà l'esecuzione della procedura.
d=`pwd`
equivale a
d=/usr/fred/bin
L'intera stringa racchiusa tra gli accenti gravi (`...`)
viene considerata un comando da eseguire e viene sostituita con
l'output del comando. Il comando va scritto usando le usuali
convenzioni di quotatura salvo che un ` deve essere escapato
usando un \. Per esempio,
ls `echo "$1"`
è equivalente a
ls $1
La sostituzione dei comandi ha luogo in tutti i contesti in cui
avviene la sostituzione dei parametri (inclusi i documenti
here) e il trattamente del testo risultante è lo
stesso in entrambi i casi. Questo meccanismo permette di utilizzare
i comandi esterni per la manipolazione delle stringhe all'interno
delle procedure di shell. Un esempio di questo tipo di comandi
è basename, il quale rimuove da una stringa il
suffisso specificato. Per esempio,
basename main.c .c
stamperà la stringa main. Un suo uso tipico è
illustrato dal seguente frammento di codice preso da un comando
tipo cc.
case $A in
...
*.c) B=`basename $A .c`
...
esac
Questo inizializza B con la porzione iniziale di $A
che rimane dopo aver rimosso il suffisso .c.
Ecco altri due esempi.
Inizialmente, viene fatta l'analisi sintattica dei comandi, secondo la grammatica data nell'appendice A. Prima che un comando venga eseguito hanno luogo le seguenti sostituzioni.
echo $X
visualizzerebbe $y.
echo ''
trasmette la stringa vuota come primo argomento al comando
echo, mentre
echo $null
produrrà la chiamata di echo senza alcun argomento se
la variabile null non è settata o è stata
inizializzata alla stringa nulla.In aggiunta ai meccanismi di quoting descritti prima usando il \ e gli '...', viene fornito un terzo meccanismo di quoting che utilizza le virgolette doppie. All'interno delle virgolette doppie avviene la sostituzione di parametri e comandi, ma non avviene la generazione dei nomi dei file e l'interpretazione dei bianchi. I caratteri della lista che segue hanno un significato speciale all'interno degli apici doppi e possono essere quotati utilizzando \.
echo "$x"
passa il valore della variabile x come argomento singolo al
comando echo. [16] Allo stesso modo
echo "$*"
trasmette i parametri posizionali come un unico argomento ed
è equivalente a
echo "$1 $2 ..."
La notazione $@ è la stessa di $* tranne
quando viene quotata.
echo "$@"
passa i parametri posizionali, non valutati, e come argomenti
multipli ad echo ed equivale a
echo "$1" "$2" ...
La tabella seguente indica, per ciascun meccanismo di quoting, come
vengono valutati i metacaratteri della shell.
metacarattere
\ $ * ` " '
' n n n n n t
` i n n t n n
" i i n i t n
t terminatore
i interpretato
n non interpretato
Figura 2. Meccanismi di quotatura
Per quei casi in cui si desidera effettuare più di una valutazione di una stringa è necessario usare il comando built-in eval. Per esempio, se la variabile X vale $y, e se y ha il valore pqr allora
eval echo $X
stamperà la stringa pqr.
In generale il comando eval valuta i suoi argomenti (così come fanno tutti i comandi) e considera il risultato come un input per la shell. L'input viene letto e il comando(i) risultante viene eseguito. Per esempio,
wg='eval who|grep'
$wg fred
è lo stesso di
who|grep fred
In questo esempio, si ha bisogno di utilizzare eval
poichè non vi è nessuna interpretazione dei
metacaratteri, quale è |, dopo che è stata
effettuata la sostituzione. [17]
L'esecuzione di un comando (vedere anche il paragrafo 3.7) può fallire per qualcuno dei motivi che seguono.
Quei segnali marcati con un asterisco producono core dump [18] se non vengono gestiti. Tuttavia, la shell stessa ignora il segnale di quit, che è l'unico segnale esterno che può causare un dump. I segnali di questa lista di potenziale interesse per i programmi della shell sono l'1, 2, 3, 14 e il 15.
trap 'rm /tmp/ps$$; exit' 2
imposta un gestore per il segnale numero 2 di interruzione dal
terminale (terminal interrupt), quindi se viene ricevuto questo
segnale saranno eseguiti i comandi
rm /tmp/ps$$; exit
exit è un'altro comando incorporato nella shell che
fa terminare l'esecuzione di una procedura di shell. Il comando
exit è necessario perché altrimenti, dopo che
il gestore è stato invocato, la shell riprenderebbe
l'esecuzione della procedura dal punto in cui era stata interrotta.
I segnali di UNIX possono essere gestiti in uno di tre modi diversi. Possono essere ignorati, e in tal caso il segnale non viene proprio mandato al processo che lo ignora. Possono essere catturati, e in questo caso il processo deve decidere quale azione intraprendere quando riceve il segnale. Infine, si può rinunciare a gestirli, lasciando che causino la terminazione del processo senza che questi intraprenda alcuna azione aggiuntiva. Se un segnale viene predisposto per essere ignorato all'entrata di una procedura di shell, per esempio per il fatto che la procedura è stata invocata in background (vedere a proposito il paragrafo 3.7) allora eventuali comandi trap che riguardano i segnali ignorati (e i relativi segnali) nel codice della procedura di shell vengono pure ignorati. [19]
L'uso di trap viene illustrato da questo versione modificata del comando touch (Figura 4) già presentato nel paragrafo 2.7. L'operazione di pulizia consiste nel rimuovere il file temporaneo junk$$.
flag=
trap 'rm -f junk$$; exit' 1 2 3 15
for i
do case $i in
-c) flag=N ;;
*) if test -f $i
then ln $i junk$$; rm junk$$
elif test $flag
then echo file \'$i\' does not exist
else >$i
fi
esac
done
Figura 4. Il comando touch
Il comando trap compare prima della creazione del file temporaneo; altrimenti sarebbe lo stesso possibile che il processo muoia senza che sia stato rimosso il file.
Dato che non c'è alcun segnale numero 0 in UNIX, questo numero viene utilizzato dalla shell per indicare quali comandi debbano essere eseguiti all'uscita della procedura di shell. [20]
Una procedura può, essa stessa, decidere di ignorare alcuni segnali specificando la stringa nulla come argomento a trap. Il seguente frammento di codice è stato preso dal comando nohup. [24]
trap '' 1 2 3 15
e fa sì che i segnagli di hangup, interrupt, quit e
kill siano ignorati sia dalla procedura, sia dai comandi da
essa invocati.
Le trap possono essere azzerate tramite comandi del tipo
trap 2 3
che resetta le trap per i segnali 2 e 3 ai loro valori di default.
Una lista dei valori correnti delle trap si può ottenere
scrivendo
trap
La procedura scan (Figura 5) rappresenta
un esempio d'uso di trap senza uscita. scan considera
ciascuna sottodirectory della directory corrente, cambia in quella
directory, usa il nome della directory come un prompt, ed esegue i
comandi digitati al terminale finché viene incontrata la
fine del file di input o viene ricevuto un interrupt. Gli interrupt
vengono ignorati durante l'esecuzione dei comandi richiesta, ma
possono causare la terminazione quando la scan è in
attesa dell'input.
d=`pwd`
for i in *
do if test -d $d/$i
then cd $d/$i
while echo "$i:"
trap exit 2
read x
do trap : 2; eval $x; done
fi
done
Figura 5. Il comando scan
read x è un comando interno che legge una linea dallo standard input e mette il risultato nella variabile x. Ritorna uno stato di uscita diverso da zero se incontra l'end-of-file oppure se riceve un interrupt. [21]
trap '' 1 2 3 15
exec $*
Il comando trap fa sì che i segnali specificati siano
ignorati dai comandi eseguiti successivamente e l'exec fa
sì che il comando specificato prenda il posto della shell.
Abbiamo già descritto la maggior parte dei modi in cui l'input e l'output può essere rediretto. Nel seguito la parola è soggetta solamente alla sostituzione parametrica e dei comandi. Non ha luogo su parola la generazione di nomi di file o l'interpretazione dei bianchi cosicché, per esempio,
echo ... >*.c
stamperà il suo output in un file il cui nome è
proprio *.c. Le specifiche di redirezione di input e di
output vengono valutate da sinistra verso destra così come
appaiono nel comando.
... 2>file
avvia un comando con lo standard error (descrittore di file 2)
rediretto in file.
... 2<&1
esegue un comando con il suo standard output e output per i
messaggi (stderr) fusi tra loro. (Più precisamente quello
che accade è che il descrittore numero 2 viene creato
duplicando il descritto di file numero 1, che rappresenta lo
standard output, ma l'effetto risultante consiste nella fusione dei
due flussi.)
L'ambiente di esecuzione di un comando avviato sullo sfondo tipo
list *.c | lpr &
viene modificato in due modi. Dapprima, lo standard input di
default di tale comando diventa il file vuoto /dev/null.
Questo impedisce che due processi (la shell e il comando), che
stanno girando in parallelo, tentino entrambi di leggere lo stesso
input. Se non fosse presa questa precauzione, il risultato sarebbe
una grande confusione. Per esempio,
ed file &
permetterebbe sia all'editor che alla shell di leggere lo stesso
input quasi contemporaneamente.
Le altre modifiche che vengono fatte all'ambiente di esecuzione di un programma in background consistono nel disattivare il trapping dei segnali di QUIT e di INTERRUPT, di modo che vengano ignorati dal comando. Questo permette di utilizzare questi segnali al terminale senza provocare la terminazione non voluta dei comandi eseguiti sullo sfondo. Per questo motivo la convenzione adottata da UNIX per un segnale è che se viene impostato al valore SIG_IGN=1 (che indica di ignorare il segnale) allora non deve essere cambiata la politica di gestione del segnale, nemmeno per un breve tempo. È per questa ragione, ossia per aderire a questa convenzione, che i comandi di shell trap non hanno alcun effetto su un segnale ignorato. [25]
Vorrei ringraziare Dennis Ritchie e John Mashey per le numerose discussioni durante il progetto della shell. Esprimo riconoscenza anche ai membri del Computing Science Research Center e a Joe Maranzano per i loro commenti sulla prima stesura di questo documento.
if then else elif fi
case in esac
for while until do done
{ }
[1] Più precisamente ls -l visualizza la data e l'ora di ultima modifica del file, che può essere posteriore alla data e ora di creazione del file, a meno che il file non sia stato mai modificato dopo esser stato creato. In realtà la data di creazione di solito non viene memorizzata, viene memorizzata solo la data di ultimo accesso, di ultima modifica e di cambiamento di stato (dell'inode associato al file). Si veda a proposito stat(2). Quindi non si può sapere con certezza quando è stato creato un file.
[2] Un uso piuttosto comune dell'operatore & nei moderni sistemi multimediali consiste nell'eseguire in background la riproduzione audio. Per la decompressione di audio nel popolare formato MPEG si possono usare appositi programmi come mpg123(1).
[3] Un `?' all'inizio di un pattern non fa corrispondenza col `.', quindi il file speciale che rappresenta la directory corrente non viene listato. Un `?' usato in una posizione diversa dalla prima invece può fare match anche con `.'.
[4] Nell'esempio, la ricerca viene limitata ad un livello di directory ma se ad es. scrivo /usr/*/*/core la ricerca avviene per tutte le sotto-sotto-directory di /usr/. Ancora più costosa è una ricerca del tipo /*/*/*/core, ecc.
[5] Oggigiorno solitamente il carattere DEL non viene più usato come carattere di interruzione. Al suo posto è molto più diffuso l'uso della combinazione CTL-C o CTL-Break.
[6] Se, ad esempio, il comando si trova nella directory corrente ma quest'ultima non si trova nel path dell'utente con cui si sta lavorando, per eseguire questo comando è necessario indicarne il percorso, altrimenti la shell non riuscirà a trovarlo. Il modo più semplice e generale consiste nell'indicare il percorso relativo rispetto alla directory corrente: ./wg fred
[7] Qui l'accapo o il ; prima del do può essere omesso perché mancando la parte in non c'è rischio di ambiguità.
[8] Notare che non ci devono essere spazi o altri caratteri prima o dopo la stringa che termina una "here document", vale a dire che la stringa terminante deve trovarsi su una linea a sé stante per essere riconosciuta.
[9] Si noti che i nomi di queste variabili non seguono la sintassi generale (una lettera seguita da zero, uno o più lettere o cifre o _). Si tratta di variabili speciali e non è possibile assegnargli direttamente un valore tramite una istruzione di assegnazione.
[10] Se si tratta di comandi da eseguire, questo però avviene solo se il path fissato contiene la directory corrente. Vedere a proposito la descrizione della successiva variabile di shell predefinita ($PATH).
[11] La differenza tra -v ed -x è notevole e vale la pena di ripeterla. -v stampa le linee di codice come vengono lette dall'interprete, mentre -x stampa le linee di codice che vengono eseguite proprio prima della loro esecuzione. Ad esempio dato il seguente file for.sh:
: file for.sh echo begin for i in a b c do echo $i done echo endgli effetti dei due flag, singoli e combinati con -n, sono i seguenti:
$ sh for.sh begin a b c end $ sh -v for.sh : file for.sh echo begin begin for i in a b c do echo $i done a b c echo end end $ sh -vn for.sh : file for.sh echo begin for i in a b c do echo $i done echo end $ sh -x for.sh + : file for.sh + echo begin begin + echo a a + echo b b + echo c c + echo end end $ sh -xn for.sh $Anche se possibile, non è consigliabile o utile combinare il flag -x con -v. Combinare -x con -n è ancora più inutile, perché non produce alcun effetto: nessun comando viene effettivamente eseguito e quindi niente viene stampato.
[12] Questa versione, anche se molto semplice, ha alcune interessanti proprietà: il numero di sezione si riferisce a tutti i nomi di manpage che seguono; se un numero di sezione non è esatto, viene presentata la prima manpage trovata scandendo le sezioni dalla prima all'ultima, se esiste. Si noti che il primo argomento di nroff o troff è rispettivamente il file man0/naa o man0/taa che si suppone contenga opportune macro istruzioni per semplificare la formattazione. In pratica invece di utilizzare il markup primitivo di nroff/troff, si utilizzano le macro riunite in questi file, che permettono di formattare un documento specificandone i componenti logici, molto similmente a come si fa con HTML, anziché le puntuali caratteristiche tipografiche.
[13] Ricordo che un flag si può porre come argomento di sh oppure settare interattivamente o in uno script di shell tramite il comando set, come gli altri visti prima.
[14] Se una variabile viene settata alla stringa nulla, ad esempio con un comando del tipo:
varname=allora varname non risulta più essere una variabile non inizializzata, perché presente nello spazio di ambiente. Per rimuovere la variabile dallo spazio di ambiente utilizzare il comando interno unset.
[15] Provate interattivamente:
$ unset d
$ echo ${d?}
sh: d: parameter null or not set
[16] Questo esempio dovrebbe chiarire ulteriormente le cose:
$ cat >args <<\! > for i do echo $i; done > ! $ chmod +x args $ x="i'm a good boy" $ ./args '$x' $x $ ./args $x i'm a good boy $ ./args "$x" i'm a good boyun altro modo per creare lo script di shell args che stampa tutti i suoi argomenti su linee a sé stanti è il seguente:
$ echo 'for i do echo $i; done' >args
[17] Può essere utile effettuare la prova interattivamente, con l'utente col quale siete loggati al posto di fred, ad esempio nel mio caso ant:
$ wg='eval who|grep'
$ echo $wg
eval who|grep
$ $wg ant
ant ttyv0 Jan 5 15:16
$
$ wg='who|grep'
$ $wg ant
who|grep: not found
$
$ wg='who | grep'
$ $wg ant
usage: who [file]
who am i
[18] Immagine della memoria salvata su disco, che può essere utilizzata per il debugging. Core è un vecchio nome dato alla memoria, risalente all'epoca delle memorie a nuclei magnetici (le matrici di anellini di ferrite).
[19] La ragione per cui le trap vengono ignorate in questo caso sarà evidente nel paragrafo 3.7.
[20] Un
trap 'echo the end' 0 ...ha un effetto simile alla funzione di <stdlib.h> atexit(3) del linguaggio C:
#include <stdio.h>
#include <stdlib.h>
void end()
{ puts("the end");
}
main()
{ atexit(end);
...
}
con la differenza che il trap per il segnale 0 della shell viene
sempre chiamato, anche se l'esecuzione viene interrotta ad esempio
per il sopraggiungere del segnale SIGINT.
[21] Si noti che la condizione del while è composta da tre comandi (echo, trap, read), di cui l'ultimo è read, che col suo valore di ritorno determina la condizione di uscita: il while termina normalmente quando read ritorna un codice di stato di uscita non nullo (ad esempio ritorna 1 se si preme l'end-of-file, solitamente Ctrl-D). Il corpo del while è invece costituito dalle due istruzioni trap ed eval.
[22] Il richiamo di sistema fork(2) realizza quello che potremmo definire una specie di clonazione dei processi o se volete l'analogo di divisione in due di una cellula. Quando un processo (denominato processo padre) invoca la fork, nell'ipotesi che non si verifichi qualche errore, viene creato un nuovo processo (processo figlio) che è la copia esatta del processo padre chiamante, nel senso che condividono lo stesso spazio codice, mentre lo spazio dati viene duplicato e i processi continuano a girare entrambi dal punto di codice successivo alla chiamata di fork. La fork, che non ha alcun argomento, tuttavia restituisce valori differenti, anche se sempre dello stesso tipo intero, al processo padre e al processo figlio: al processo figlio restituisce uno zero, mentre al processo padre restituisce il PID (process ID) assegnato al processo figlio, il modo che il padre possa sapere chi è suo figlio! Inoltre, siccome condividono lo stesso codice, un test sul valore restituito dalla fork è l'unico modo per far prendere strade diverse al flusso di esecuzione del padre rispetto al figlio, cosa generalmente desiderata, in quanto due processi che facciano la stessa cosa in parallelo non servono a molto. Questo frammento di codice C, per semplicità senza il controllo degli errori, chiarisce l'uso di fork:
pid_t childPID;
childPID=fork();
if (childPID == 0)
{ /* continuazione del processo figlio */
}
else
{ /* continuazione del processo padre */
}
Un processo padre può anche decidere di bloccarsi in attesa
della terminazione dei suoi processi figli, per raccoglierne poi lo
stato di ritorno (si veda a proposito wait(2)). Quella tra processi
padre e figli è una relazione del tipo uno-a-molti, nel
senso che un padre può avere molti figli, ad es. una shell
può avere molti job eseguiti in background.
[23] Ad esempio con XFree è consigliabile, per ragioni di sicurezza, usare exec per avviare la X manualmente da terminale testuale su postazioni pubbliche:
$ exec startxin questo modo se lasciate la consolle incustodita e qualche malintenzionato dovesse killare la X non guadagnerebbe accesso di shell.
[24] Il comando nohup(1) invoca un altro comando in modo che il segnale numero 1 di hangup (SIGHUP) venga ignorato. Questo può essere utile se volete fare il logout e lasciare qualche comando in background.
[25] La trap verifica che il segnale non sia stato impostato a SIG_IGN e in tal caso non fa niente. Ogni altro programma (compresi i programmi in C compilati) dovrebbe fare altrettanto per rispettare la convenzione.