[inizio] [indice generale] [precedente] [successivo] [indice analitico] [contributi]


48. Bash: comandi interni

I comandi interni sono quelli eseguiti direttamente dalla shell, come se si trattasse di funzioni. La tabella 48.1 mostra l'elenco di alcuni dei comandi a disposizione, suddivisi in base all'origine.

Comando Descrizione
sh : Non fa nulla: esegue solo una simulazione di espansione e ridirezione.
" . Legge ed esegue i comandi di un file indicato come argomento.
" break Termina un ciclo `for', `while' o `until'.
" cd Cambia la directory corrente.
" continue Riprende la prossima iterazione di un ciclo `for', `while' o `until'.
" eval Concatena ed esegue gli argomenti come un comando unico.
" exec Esegue un comando rimpiazzando la shell.
" exit Termina il funzionamento della shell.
" export Marca le variabili in modo che siano passate all'ambiente dei processi figli.
" getopts Analizza le opzioni dagli argomenti di uno script o funzione.
" hash Determina e memorizza i percorsi assoluti dei programmi indicati.
" kill Invia un segnale a un processo.
" pwd Emette il percorso della directory attuale.
" readonly Protegge le variabili contro la scrittura.
" return Termina una funzione restituendo un valore preciso.
" shift Fa scalare verso sinistra il contenuto dei parametri posizionali.
" test Valuta un'espressione condizionale.
" times Emette i tempi di utilizzo accumulati.
" trap Specifica i comandi da eseguire quando la shell riceve segnali.
" umask Determina la maschera dei permessi per la creazione dei file.
" unset Elimina le variabili.
" wait Attende la conclusione dei processi figli.
csh logout Termina l'esecuzione di una shell di login
" source Esegue la stessa funzione del punto singolo (`.').
ksh let Esegue dei calcoli.
" alias Crea un alias di un comando.
" unalias Elimina un alias di un comando.
bash builtin Esegue un comando interno in modo esplicito.
" bind Visualizza o modifica la configurazione della tastiera.
" command Esegue un comando interno o un programma.
" declare Dichiara delle variabili.
" echo Emette gli argomenti attraverso lo standard output.
" enable Abilita o disabilita dei comandi interni.
" help Emette informazioni sui comandi interni.
" local Crea delle variabili locali.
" logout Termina l'esecuzione di una shell di login.
" read Legge una riga dallo standard input e lo assegna a una variabile.
" type Determina il tipo di comando.
" ulimit Fornisce il controllo sulle risorse disponibili.
" set Configura una grande quantità di elementi.

Tabella 48.1: Alcuni comandi interni della shell Bash.

È bene ricordare che dal punto di vista della shell, il valore numerico zero corrisponde a Vero dal punto di vista logico, e nello stesso modo, qualunque valore diverso da zero corrisponde a Falso.

48.1 :

:[<argomenti>]

Ciò che inizia con il simbolo `:' non viene eseguito. Si ottiene solo l'espansione degli argomenti e l'esecuzione della ridirezione. Il valore restituito alla fine è sempre zero.

48.2 source

. <file-script> [<argomenti>]

source <file-script> [<argomenti>]

Vengono letti ed eseguiti i comandi contenuti nel file indicato. Se il nome del file non fa riferimento a un percorso, questo viene cercato all'interno dei vari percorsi indicati dalla variabile `PATH'. Se vengono forniti degli argomenti a questo script, questi diventano i suoi parametri posizionali. Il valore restituito dallo script è:

48.3 alias

alias [<nome>[=<valore>]]...

Il comando `alias' permette di definire un alias, oppure di leggere il contenuto di un alias particolare, o di elencare tutti gli alias esistenti.

Se viene utilizzato senza argomenti, emette attraverso lo standard output la lista degli alias nella forma `<nome>=<valore>'. Se viene indicato solo il nome di un alias, ne viene emesso il nome e il contenuto. Se si utilizza la sintassi completa si crea un alias nuovo.

La coppia `<nome>=<valore>' deve essere scritta senza lasciare spazi prima e dopo del segno di uguaglianza (`='). In particolare, se si lascia uno spazio prima dell'indicazione del valore, questo verrà interpretato come il nome di un altro alias.

Il comando `alias' restituisce il valore Falso quando è stato indicato un alias inesistente senza valore da assegnare; negli altri casi, restituisce Vero.

48.4 bg

bg [<specificazione-del-job>]

Mette sullo sfondo il job indicato, come se fosse stato avviato aggiungendo il simbolo e-commerciale (`&') alla fine. Se non viene specificato il job, viene messo sullo sfondo quello corrente, dal punto di vista della shell. Se l'operazione riesce, il valore restituito è zero.

Il controllo sui job è descritto nella sezione 46.6.

48.5 bind

bind [-m <mappa-dei-tasti>] [-ldv] [-q <funzione>]

bind [-m <mappa-dei-tasti>] -f file

bind [-m <mappa-dei-tasti>] <sequenza-di-tasti>:<funzione>

Visualizza o modifica la configurazione legata all'uso della tastiera attraverso la libreria `readline'. La sintassi è la stessa che può essere utilizzata nel file di configurazione `~/.inputrc'.

Alcune opzioni

-m <mappa-dei-tasti>

Usa la mappa della tastiera indicata per nome. I nomi a disposizione sono: `emacs', `emacs-standard', `emacs-meta', `emacs-ctlx', `vi', `vi-move', `vi-command' e `vi-insert'. In particolare, `vi' equivale a `vi-command' e `emacs' equivale a `emacs-standard'.

-l

Elenca i nomi di tutte le funzioni di `readline'.

-v

Elenca i nomi delle funzioni attuali e i loro collegamenti.

-d

Scarica i nomi delle funzioni e i collegamenti in modo che possano essere riletti.

-f file

Legge le informazioni legate all'uso della tastiera dal file indicato.

-q <funzione>

Emette la sequenza di tasti connessa con la funzione indicata.

Il valore restituito è zero, a meno che siano fornite opzioni sconosciute.

48.6 break

break [n]

Interrompe un ciclo `for', `while' o `until'. Se viene specificato il valore numerico n, l'interruzione riguarda n livelli. Il valore n deve essere maggiore o uguale a uno. Se n è maggiore dei cicli annidati in funzione, vengono semplicemente interrotti tutti. Il valore restituito è zero purché ci sia un ciclo da interrompere.

48.7 builtin

builtin <comando-interno> [<argomenti>]

Esegue il comando interno indicato passandogli gli argomenti eventuali. Può essere utile quando si vuole definire una funzione con lo stesso nome di un comando interno. Restituisce il valore Falso se il nome indicato non corrisponde a un comando interno.

48.8 cd

cd [<directory>]

Cambia la directory corrente. Se non viene specificata la destinazione, si intende la directory contenuta nella variabile `HOME' (che di solito corrisponde alla directory personale dell'utente). Il funzionamento di questo comando può essere alterato dal contenuto della variabile `CDPATH' che può indicare una serie di percorsi di ricerca per la directory su cui ci si vuole spostare. Di norma, la variabile `CDPATH' è opportunamente vuota, in modo da fare riferimento semplicemente alla directory corrente.

48.9 command

command [-pVv] <comando> [<argomento>...]

Esegue un comando con gli argomenti eventuali. In questo caso, per comando si intende un comando interno oppure un programma. Sono escluse le funzioni.

Alcune opzioni

-p

La ricerca del programma avviene all'interno di una serie di percorsi di ricerca predefiniti e non quindi in base al contenuto di `PATH'.

-v

Emette il nome del programma, così come è stato fornito.

-V

Emette il nome del programma, così come è stato fornito, oltre ad altre informazioni.

48.10 continue

continue [n]

Riprende, a partire dall'iterazione successiva, un ciclo `for', `while' o `until'. Se viene specificato il valore numerico n, il salto riguarda n livelli. Il valore n deve essere maggiore o uguale a uno. Se n è maggiore dei cicli annidati in funzione, si fa riferimento al ciclo più esterno. Il valore restituito è zero, a meno che non ci sia alcun ciclo da riprendere.

48.11 declare

declare [<opzioni>] [<nome>[=<valore>]]

Permette di dichiarare delle variabili ed eventualmente anche di attribuirgli dei valori. Se non vengono forniti nomi di variabili da creare, vengono visualizzati i nomi di quelle esistenti con i loro valori.

Alcune opzioni

-a

Indica che si tratta di un array.

-f

Utilizza solo nomi di funzione.

-r

Fa in modo che le variabili indicate siano disponibili solo in lettura, e cioè che sia impedito l'ulteriore assegnamento di valori.

-x

Fa in modo che le variabili indicate siano rese disponibili anche ai programmi eseguiti a partire dalla sessione attuale di funzionamento della shell. Si dice che le variabili vengono esportate.

-i

La variabile viene trattata come un intero. Di conseguenza, prima di assegnarle un valore viene eseguita una valutazione di tipo aritmetico.

Utilizzando il segno `+' al posto del trattino che contrassegna le opzioni, si intende la disattivazione dell'opzione stessa.

Il valore restituito è zero se non sono stati commessi degli errori.

48.12 echo

echo [-neE] [<argomento>...]

Emette gli argomenti separati da uno spazio. Restituisce sempre il valore zero. `echo' riconosce alcune sequenze di escape che possono essere utili per formattare il testo da visualizzare. Queste sono elencate nella tabella 48.2.

Codice Descrizione
\\ Inserisce la barra obliqua inversa (`\').
\a Inserisce il codice <BEL> (avvisatore acustico).
\b Inserisce il codice <BS> (backspace).
\c Alla fine di una stringa previene l'inserimento di una nuova riga.
\f Inserisce il codice <FF> (formfeed).
\n Inserisce il codice <LF> (linefeed).
\r Inserisce il codice <CR> (carriage return).
\t Inserisce una tabulazione normale (<HT>).
\v Inserisce una tabulazione verticale (<VT>).
\nnn Inserisce il carattere corrispondente al codice ottale n.

Tabella 48.2: Elenco delle sequenze di escape riconosciute da `echo'.

Alcune opzioni

-n

Sopprime il codice di interruzione di riga finale, in modo che il testo emesso successivamente prosegua di seguito.

-e

Abilita l'interpretazione delle sequenze di escape descritte più avanti.

-E

Disabilita l'interpretazione delle sequenze di escape anche dove questo potrebbe costituire la modalità predefinita.

48.13 enable

enable [-n] [-all] [<nome>...]

Abilita o disabilita i comandi interni. Ciò permette l'esecuzione di un programma con lo stesso nome di un comando interno, senza dover indicare il percorso di questo programma.

Alcune opzioni

-n

Disabilita i nomi indicati. Se non viene usata questa opzione si intende che i nomi indicati vengono abilitati. Se non viene indicato alcun nome di comando, con questa opzione si ottiene l'elenco di tutti i comandi interni disabilitati, senza questa opzione si ottiene l'elenco dei comandi interni abilitati.

-a | -all

Se questa opzione viene usata da sola, si ottiene l'elenco di tutti i comandi interni con l'indicazione di quelli disabilitati.

`enable' restituisce il valore zero, a meno che sia stato fornito il nome di un comando interno inesistente.

48.14 eval

eval [<argomento>...]

Esegue gli argomenti come parte di un comando unico. Restituisce il valore restituito dal comando rappresentato dagli argomenti. Se non vengono indicati argomenti, o se questi sono vuoti, restituisce Vero.

48.15 exec

exec [[-] <comando> [<argomenti>]]

Se viene specificato un comando (un programma), questo viene eseguito rimpiazzando la shell, in modo da non generare un nuovo processo. Se sono stati indicati degli argomenti, questi vengono passati regolarmente al comando. Se prima del comando si inserisce un trattino (`-'), l'argomento zero passato al comando conterrà un trattino. Se il comando non può essere eseguito per qualsiasi motivo e ci si trova all'interno di una shell non interattiva, questo termina l'esecuzione restituendo una segnalazione di errore.

Il fatto di rimpiazzare la shell implica che, al termine dell'esecuzione del programma, non ci sarà più la shell. Se si trattava di una finestra di terminale, questa potrebbe semplicemente chiudersi, oppure, se si trattava di una shell di login potrebbe essere riavviata la procedura di accesso.

48.16 exit

exit [n]

Termina l'esecuzione della shell restituendo il valore n. Se viene omessa l'indicazione esplicita del valore da restituire, viene utilizzato quello dell'ultimo comando eseguito.

48.17 export

export [-nf] [<nome>[=<parola>]...]

export -p

Le variabili elencate (o le funzioni) vengono segnate per l'esportazione, nel senso che vengono trasferite all'ambiente dei programmi eseguiti successivamente all'interno della shell stessa.

Alcune opzioni

-f

I nomi si riferiscono a funzioni.

-p

Vengono elencati i nomi esportati (variabili e funzioni). È il comportamento predefinito quando non sono stati indicati dei nomi.

-n

Elimina la proprietà di esportazione agli elementi elencati.

`export' restituisce zero se non sono stati commessi degli errori.

48.18 fg

fg [<job>]

Pone il job indicato in primo piano, ovvero in foreground. Se non viene specificato il job, si intende quello attuale, ovvero, l'ultimo a essere stato messo sullo sfondo (background).

Il controllo sui job è descritto nella sezione 46.6.

48.19 getopts

getopts <stringa-di-opzioni> <nome-di-variabile> [<argomenti>]

Il comando interno `getopts' è qualcosa di diverso dalle solite cose. Serve per facilitare la realizzazione di script in cui si devono analizzare le opzioni della riga di comando. Ogni volta che viene chiamato, `getopts' analizza l'argomento successivo nella riga di comando, e restituisce le informazioni relative attraverso delle variabili di ambiente. Per la precisione, `getopts' analizza gli argomenti finali della sua stessa riga comando (quelli che sono stati indicati nello schema sintattico come un elemento facoltativo), e in mancanza di questi, utilizza il contenuto del parametro `$@'. In pratica, scrivere

getopts <stringa-di-opzioni> <nome-di-variabile>

è esattamente uguale a

getopts <stringa-di-opzioni> <nome-di-variabile> $@

`getopts' dipende in particolare dalla variabile `OPTIND', che contiene l'indice di scansione di questi argomenti. Il suo valore iniziale predefinito è pari a uno, corrispondente al primo elemento, e viene incrementato ogni volta che si utilizza `getopts'. Se per qualche motivo si dovesse ripetere una scansione (degli stessi, o di altri argomenti), occorrerebbe inizializzare nuovamente tale variabile al valore uno.

Per funzionare, `getopts' richiede due informazioni: una stringa contenente le lettere delle opzioni previste, e il nome di una variabile di ambiente da creare e inizializzare di volta in volta con il nome dell'opzione individuata. Se è previsto che un'opzione di quelle da scandire sia seguita da un argomento, quell'argomento viene inserito nella variabile di ambiente `OPTARG'. La stringa che definisce le lettere delle opzioni è composta proprio da quelle stesse lettere, che possono essere seguite dal simbolo due punti (`:') se si vuole specificare la presenza di un argomento di queste.

Per cominciare, si osservi l'esempio seguente, in cui viene mostrato uno script elementare anche se piuttosto lungo:

#!/bin/bash
echo "Indice opzioni: $OPTIND"
getopts a:b:c:defg OPZIONE -a ciao -b come -c stai -d -e -f -g -h -i
echo "Opzione \"${OPZIONE}\" con argomento ${OPTARG}."

echo "Indice opzioni: $OPTIND"
getopts a:b:c:defg OPZIONE -a ciao -b come -c stai -d -e -f -g -h -i
echo "Opzione \"${OPZIONE}\" con argomento ${OPTARG}."

echo "Indice opzioni: $OPTIND"
getopts a:b:c:defg OPZIONE -a ciao -b come -c stai -d -e -f -g -h -i
echo "Opzione \"${OPZIONE}\" con argomento ${OPTARG}."

echo "Indice opzioni: $OPTIND"
getopts a:b:c:defg OPZIONE -a ciao -b come -c stai -d -e -f -g -h -i
echo "Opzione \"${OPZIONE}\" con argomento ${OPTARG}."

echo "Indice opzioni: $OPTIND"
getopts a:b:c:defg OPZIONE -a ciao -b come -c stai -d -e -f -g -h -i
echo "Opzione \"${OPZIONE}\" con argomento ${OPTARG}."

echo "Indice opzioni: $OPTIND"
getopts a:b:c:defg OPZIONE -a ciao -b come -c stai -d -e -f -g -h -i
echo "Opzione \"${OPZIONE}\" con argomento ${OPTARG}."

echo "Indice opzioni: $OPTIND"
getopts a:b:c:defg OPZIONE -a ciao -b come -c stai -d -e -f -g -h -i
echo "Opzione \"${OPZIONE}\" con argomento ${OPTARG}."

echo "Indice opzioni: $OPTIND"
getopts a:b:c:defg OPZIONE -a ciao -b come -c stai -d -e -f -g -h -i
echo "Opzione \"${OPZIONE}\" con argomento ${OPTARG}."

echo "Indice opzioni: $OPTIND"
getopts a:b:c:defg OPZIONE -a ciao -b come -c stai -d -e -f -g -h -i
echo "Opzione \"${OPZIONE}\" con argomento ${OPTARG}."

Come si può notare, `getopts' viene avviato sempre nello stesso modo (soprattutto con gli stessi argomenti da scandire); inoltre, subito prima viene visualizzato il contenuto della variabile `OPTIND', e dopo viene visualizzato il risultato della scansione. Ecco cosa si ottiene:

Indice opzioni: 1
Opzione "a" con argomento ciao.
Indice opzioni: 3
Opzione "b" con argomento come.
Indice opzioni: 5
Opzione "c" con argomento stai.
Indice opzioni: 7
Opzione "d" con argomento .
Indice opzioni: 8
Opzione "e" con argomento .
Indice opzioni: 9
Opzione "f" con argomento .
Indice opzioni: 10
Opzione "g" con argomento .
Indice opzioni: 11
./cacca1.sh: illegal option -- h
Opzione "?" con argomento .
Indice opzioni: 11
./cacca1.sh: illegal option -- i
Opzione "?" con argomento .

In pratica, sono valide solo le opzioni dalla lettera «a» alla lettera «g», e le prime tre (dalla «a» alla «c») richiedono un argomento. Si può osservare che le opzioni `-h' e `-i', che sono state aggiunte volutamente, sono in più, e `getopts' ne ha segnalato la presenza come un errore.

Vale la pena di osservare anche l'andamento dell'indice rappresentato dalla variabile `OPTIND': nel caso delle opzioni `-a', `-b', e `-c', l'incremento è di due unità perché c'è anche un argomento di queste.

`getopts' restituisce un valore diverso da zero (Falso) tutte le volte che si verifica un errore. In questo modo, diventa agevole il suo inserimento al posto di un'espressione condizionale, come nell'esempio seguente, in cui si fa la scansione delle opzioni fornite allo script, ovvero quelle contenute nel parametro `$@':

#!/bin/bash
while getopts a:b:c:defg OPZIONE
do
    echo "Opzione \"${OPZIONE}\" con argomento ${OPTARG}."
done

Al primo errore, il ciclo termina, e non viene mostrato il messaggio relativo.

In condizioni normali, è più probabile che si utilizzi una struttura `case' per analizzare la scansione delle opzioni, come nell'esempio seguente, dove in più, è stato aggiunta anche l'inizializzazione della variabile `OPTIND' a titolo precauzionale, per garantire che la scansione parta dall'inizio:

#!/bin/bash
OPTIND=1
while getopts :a:b:c:defg OPZIONE
do
    case $OPZIONE in
        a) echo "Opzione \"a\" con argomento $OPTARG."		;;
        b) echo "Opzione \"b\" con argomento $OPTARG."		;;
        c) echo "Opzione \"c\" con argomento $OPTARG."		;;
        d) echo "Opzione \"d\" che non richiede argomento."	;;
        e) echo "Opzione \"e\" che non richiede argomento."	;;
        f) echo "Opzione \"f\" che non richiede argomento."	;;
        g) echo "Opzione \"g\" che non richiede argomento."	;;
        *) echo "È stata indicata un'opzione illegale."		;;
    esac
done

Questo esempio è diverso da quelli precedenti, soprattutto per la stringa di definizione delle opzioni da scandire: questa stringa inizia con il simbolo due punti (`:'). In questo modo, si vuole evitare che `getopt' restituisca Falso quando si verifica un errore negli argomenti.

`getopts' utilizza anche un'altra variabile di ambiente: `OPTERR'. Questa variabile contiene normalmente il valore uno, e se le viene assegnato zero, si inibiscono tutte le segnalazioni di errore.

48.20 hash

hash [-r] [<comando>...]

Per ciascun comando indicato, viene determinato e memorizzato il percorso assoluto.

Alcune opzioni

-r

Fa sì che la shell perda le locazioni memorizzate.

Se non viene dato alcun argomento, viene emessa l'informazione circa i comandi memorizzati.

Restituisce Vero se non si verificano errori.

48.21 help

help [<modello>]

Mostra una guida sui comandi interni. Se viene fornito il modello, si ottiene una guida dettagliata su tutti i comandi che combaciano con il modello stesso, altrimenti viene emesso un elenco dei comandi interni.

Il valore restituito è zero a meno che il modello fornito non combaci con alcun comando.

48.22 jobs

jobs [-lnp] [<job>...]

Quello mostrato rappresenta lo schema sintattico dell'utilizzo comune di `jobs', che serve a elencare i job attivi.

Alcune opzioni

-l

Elenca i numeri di processo, o PID, in aggiunta alle normali informazioni.

-p

Elenca solo il PID del primo processo del gruppo di quelli appartenenti al job.

-n

Mostra solo i job che hanno cambiato stato dall'ultima notifica.

Se viene indicato esplicitamente un job, l'elenco risultante sarà ristretto alle sole informazioni su quel job.

Restituisce zero a meno che sia incontrata un'opzione non ammessa o sia stata fornita l'indicazione di un job impossibile.

Il controllo sui job è descritto nella sezione 46.6.

48.23 kill

kill [-s <segnale>] [<pid> | <job>]...

kill [-l [<numero-del-segnale> | <numero-del-segnale>]...]

Invia il segnale indicato al processo identificato dal numero del PID o dal job. Il segnale viene definito attraverso un nome, come per esempio `SIGKILL', o un numero di segnale. Il nome del segnale non è sensibile alla differenza tra maiuscole e minuscole e può essere indicato anche senza il prefisso `SIG'. Se non viene indicato il tipo di segnale da inviare, si intende `SIGTERM'. Un argomento `-l' elenca i nomi dei segnali corrispondenti ai numeri eventualmente indicati.

Restituisce Vero se almeno un segnale è stato inviato con successo, o Falso se avviene un errore di qualunque tipo.

Esempi

kill -s SIGHUP %1

Invia il segnale `SIGHUP' al job numero uno.

kill -s HUP %1

Esattamente come nell'esempio precedente.

kill -HUP %1

Esattamente come nell'esempio precedente.

kill -l

Elenca i nomi di segnale abbinati al numero corrispondente.

kill -l 1

Restituisce il nome corrispondente al segnale numero uno: `HUP'.

kill -l HUP

Restituisce il numero corrispondente al segnale `HUP': uno.

48.24 let

let <argomento> [<argomento>...]

Permette di eseguire operazioni aritmetiche con l'utilizzo di variabili. Ogni argomento è un'espressione aritmetica che deve essere risolta. Se l'ultimo argomento viene risolto generando un risultato pari a zero, `let' restituisce il valore uno, altrimenti restituisce zero.

Esempi

let PIPPO=123+45[Invio]

Calcola la somma di 123 e 45 e l'assegna alla variabile `PIPPO'.

echo $PIPPO[Invio]

168

---------

let PIPPO1=123+45 PIPPO2=256+64[Invio]

Calcola la somma di 123 e 45 assegnandola alla variabile `PIPPO1' e la somma di 256 e 64 assegnandola alla variabile `PIPPO2'.

let PIPPO1=PIPPO1+PIPPO2[Invio]

Somma il contenuto della variabile `PIPPO1' con quello di `PIPPO2' e assegna il risultato nuovamente a `PIPPO1'.

echo $PIPPO1[Invio]

478

48.25 local

local [<variabile-locale>[=<valore>]...]

Per ogni argomento, crea una variabile locale con il nome indicato e gli assegna il valore che appare dopo il simbolo di uguaglianza (`='). Prima e dopo il simbolo `=' non si possono lasciare spazi. Quando il comando `local' viene usato dentro una funzione, fa sì che la variabile abbia una visibilità ristretta a quella funzione e ai suoi discendenti. Se non viene indicato alcun argomento, `local' emette un elenco di variabili locali attraverso lo standard output. È un errore usare `local' quando non ci si trova all'interno di una funzione. `local' restituisce zero a meno che `local' sia usato fuori da una funzione, o siano stati fatti altri errori.

48.26 logout

logout

Termina il funzionamento di una shell di login.

48.27 pwd

pwd

Emette il percorso assoluto della directory corrente. Se è stato usato il comando interno `set -P', i percorsi che utilizzano collegamenti simbolici vengono tradotti in percorsi reali. Restituisce zero se non si verifica alcun errore mentre si legge il percorso della directory corrente.

48.28 read

read [-a <array>] [-p <prompt>] [-r] [<variabile>...]

Viene letta una riga dallo standard input, e la prima parola di questa riga viene assegnata alla prima variabile indicata come argomento, la seconda parola alla seconda variabile, e così via. All'ultima variabile indicata nella riga di comando viene assegnato la parte restante della riga dello standard input che non sia stata distribuita diversamente. Per determinare la separazione in parole della riga dello standard input si utilizzano i caratteri contenuti nella variabile `IFS'. Se non vengono fornite variabili a cui assegnare questi dati, la riga letta viene assegnata alla variabile `REPLY'.

`read' restituisce zero, purché non sia incontrata la fine del file prima di poter leggere la riga dello standard input.

Alcune opzioni

-r

Utilizzando questa opzione, la barra obliqua inversa (`\') seguita dal codice di interruzione di riga, cosa che di solito viene interpretata come simbolo di continuazione, non viene ignorata, e il simbolo `\' viene inteso come parte della riga.

-a <array>

Se viene fornita questa opzione, assieme al nome di una variabile array, si ottiene l'assegnamento sequenziale delle parole all'interno degli elementi di questo array (partendo dalla posizione zero).

-p <prompt>

Permette di definire un invito particolare. Questo viene visualizzato solo se l'input proviene da un terminale.

48.29 readonly

readonly [<variabile>...]

readonly [-f <funzione>...]

readonly -p

Le variabili o le funzioni indicate vengono marcate per la sola lettura e i valori di queste non possono essere cambiati dagli assegnamenti successivi. Se non viene fornito alcun argomento, e se viene indicata l'opzione `-p', viene emessa una lista di tutti i nomi a sola lettura. Un argomento `--' disabilita il controllo delle opzioni per il resto degli argomenti. Restituisce zero se non sono stati commessi degli errori.

48.30 return

return [n]

Termina l'esecuzione di una funzione restituendo il valore n. Se viene omessa l'indicazione di questo valore, la funzione che termina restituisce il valore restituito dall'ultimo comando eseguito al suo interno. Se il comando `return' viene utilizzato al di fuori di una funzione, ma sempre all'interno di uno script, termina l'esecuzione dello script stesso. In particolare, se questo script era stato eseguito attraverso il comando `.', ovvero `source', viene restituito un valore secondo le stesse regole della conclusione di una funzione, se invece questo script era stato eseguito in maniera diversa, il valore restituito è sempre Falso.

48.31 set

set [{-|+}x]...

set [{-|+}o [<modalità>]

set <parametro-posizionale>...

set -- [<valore-parametro-1> [<valore-parametro-2>...]]

Questo comando, se usato senza argomenti, emette l'impostazione generale della shell, nel senso che vengono visualizzate tutte le variabili di ambiente e le funzioni. Se si indicano degli argomenti si intendono alterare alcune modalità (opzioni) legate al funzionamento della shell Bash.

Quasi tutte le modalità in questione sono rappresentate da una lettera alfabetica, con un qualche significato mnemonico. L'attivazione di queste modalità può essere verificata osservando il contenuto del parametro `$-':

echo $-

Si potrebbe ottenere una stringa come quella seguente:

imH

Le lettere che si vedono («i», «m» e «H») rappresentano ognuna l'attivazione di una modalità particolare, e `set' può intervenire solo su alcune di queste. Gli argomenti normali del comando `set' sono le lettere delle modalità che si vogliono attivare o disattivare: se le lettere sono precedute dal segno `-' si specifica l'attivazione di queste, mentre se sono precedute dal segno `+' si specifica la loro disattivazione.

`set' può essere usato per modificare le modalità di funzionamento anche attraverso l'opzione `-o', oppure `+o', che deve essere seguita da una parola chiave che rappresenta la modalità stessa. I segni `-' e `+' rappresentano ancora l'attivazione o la disattivazione della modalità corrispondente. Le modalità a cui si accede attraverso l'opzione `-o' (o `+o') non sono esattamente le stesse che si possono controllare altrimenti.

Il comando `set' può servire anche per modificare il contenuto dei parametri `$1', `$2',... Per questo, se ci sono degli argomenti che seguono la definizione dell'ultima modalità, vengono interpretati come i valori da assegnare ordinatamente a questi parametri. In particolare, se si utilizza la forma `set --', si interviene su tutti i parametri: se non si indicano argomenti, si eliminano tutti i parametri; se ci sono altri argomenti, questi diventano ordinatamente i nuovi parametri, mentre tutti quelli precedenti vengono eliminati.

Se viene utilizzato il comando `set -o', si ottiene l'elenco delle impostazioni attuali.

`set' restituisce Vero se non viene incontrata un'opzione errata.

Definizione di alcune modalità

{-|+}a

{-|+}o allexport

Le variabili che vengono modificate o create, sono marcate automaticamente per l'esportazione verso l'ambiente per i comandi avviati dalla shell.

{-|+}b

{-|+}o notify

Fa in modo che venga riportato immediatamente lo stato di un job sullo sfondo che termina. Altrimenti, questa informazione viene emessa subito prima dell'invito primario successivo.

{-|+}e

{-|+}o errexit

Termina immediatamente se un comando qualunque conclude la sua esecuzione restituendo uno stato diverso da zero. La shell non esce se il comando che fallisce è parte di un ciclo `until' o `while', di un'istruzione `if', di una lista `&&' o `||', o se il valore restituito dal comando è stato invertito per mezzo di `!'.

{-|+}f

{-|+}o noglob

Disabilita l'espansione di percorso (quello che riguarda i caratteri jolly nei nomi di file e directory).

{-|+}h

Localizza e memorizza la posizione dei programmi alla prima occasione in cui questi vengono eseguiti, in modo da rendere più rapido un eventuale avvio successivo.

{-|+}m

{-|+}o monitor

Il controllo dei job è attivato. Questa modalità è attiva in modo predefinito per le shell interattive.

{-|+}n

{-|+}o noexec

Legge i comandi, ma non li esegue. Ciò può essere usato per controllare gli errori di sintassi di uno script di shell. Questo valore viene ignorato dalle shell interattive.

{-|+}p

{-|+}o privileged

Attiva la modalità di funzionamento privilegiato. In questa modalità, il file indicato all'interno della variabile `BASH_ENV' non viene elaborato e le funzioni di shell non vengono ereditate dall'ambiente. Questa modalità è abilitata automaticamente all'avvio se i numeri UID e GID efficaci non equivalgono ai numeri UID e GID reali. Una cosa del genere si ottiene quando l'eseguibile `bash' ha il bit SUID attivo, per cui sono stati guadagnati i privilegi di un altro utente, quello proprietario del file eseguibile. Disattivare questa modalità fa sì che UID e GID efficaci tornino a essere uguali a quelli reali (perdendo i privilegi di prima).

{-|+}t

Termina l'esecuzione dopo aver letto ed eseguito un comando.

{-|+}u

{-|+}o nounset

Fa in modo che venga considerato un errore l'utilizzo di variabili non impostate (predisposte) quando si effettua l'espansione di una variabile (o di un parametro). In tal caso, quindi, la shell emette un messaggio di errore e, se il funzionamento non è interattivo, termina restituendo un valore diverso da zero.

{-|+}v

{-|+}o verbose

Emette le righe inserite nella shell appena queste vengono lette.

{-|+}x

{-|+}o xtrace

Nel momento in cui si eseguono dei comandi, viene emesso il comando stesso attraverso lo standard output preceduto da quanto contenuto nella variabile `PS4'.

{-|+}B

{-|+}o braceexpand

Viene attivata l'espansione delle parentesi graffe (predefinito).

{-|+}C

{-|+}o noclobber

Disabilita la sovrascrittura dei file preesistenti a seguito di una ridirezione dell'output attraverso l'uso degli operatori `>', `>&' e `<>'. Questa impostazione può essere scavalcata (in modo da riscrivere i file) utilizzando l'operatore di ridirezione `>|' al posto di `>' ( 46.5).

In generale sarebbe meglio evitare di intervenire in questo modo, dal momento che ciò non è conforme allo standard di utilizzo normale.

{-|+}P

{-|+}o physical

Se attivato, non segue i collegamenti simbolici quando esegue i comandi che, come `cd', cambiano la directory corrente. Vengono usate invece le directory reali. L'azione di seguire i collegamenti simbolici non è così ovvia come sembra; alla fine viene proposto un esempio.

{-|+}o emacs

Fa in modo che la riga di comando funzioni secondo lo stile Emacs. Si tratta della modalità predefinita quando la shell è interattiva, a meno che sia stata avviata con l'opzione `-nolineediting'.

{-|+}o interactive-comments

Permette di ignorare i commenti (`#' e il resto della riga) anche durante l'esecuzione di una shell interattiva

{-|+}o posix

Cambia il comportamento della shell dove le operazioni predefinite differiscono dallo standard POSIX 1003.2 per farlo combaciare con lo standard.

{-|+}o vi

Fa in modo che la riga di comando funzioni secondo lo stile VI.

Esempi

Se `/usr/sys' è un collegamento simbolico a `/usr/local/sys/', valgono le operazioni seguenti.

cd /usr/sys[Invio]

echo $PWD[Invio]

/usr/sys

cd ..[Invio]

echo $PWD[Invio]

/usr

Se invece è stato attivato `set -P', la stessa cosa funziona nel modo seguente:

cd /usr/sys[Invio]

echo $PWD[Invio]

/usr/sys

cd ..[Invio]

echo $PWD[Invio]

/usr/local

L'esempio seguente riguarda invece l'utilizzo di `set' per modificare il gruppo dei parametri:

set -- ciao come stai?[Invio]

echo $1[Invio]

ciao

echo $2[Invio]

come

echo $3[Invio]

stai?

48.32 shift

shift [n]

I parametri posizionali da n+1 in avanti sono spostati a partire da `$1' in poi (`$0' non viene coinvolto). Se n è 0, nessun parametro viene cambiato. Se n non è indicato, il suo valore predefinito è uno. Il valore di n deve essere un numero non negativo minore o uguale a `$#' (cioè al numero di parametri posizionali esistenti). Se n è più grande di `$#', i parametri posizionali non vengono modificati.

Restituisce un valore maggiore di zero se n è più grande di `$#' o minore di zero; altrimenti restituisce zero.

48.33 suspend

suspend [-f]

Sospende l'esecuzione della shell fino a che non riceve un segnale `SIGCONT'. L'opzione `-f' permette di sospenderne l'esecuzione anche se si tratta di una shell di login.

Restituisce zero se non si verificano errori.

48.34 test

test <espressione-condizionale>

[ <espressione-condizionale> ]

Risolve (valuta) l'espressione indicata (la seconda forma utilizza semplicemente un'espressione racchiusa tra parentesi quadre). Il valore restituito può essere Vero (corrispondente a zero) o Falso (corrispondente a uno) ed è pari al risultato della valutazione dell'espressione. Le espressioni possono essere unarie o binarie. Le espressioni unarie sono usate spesso per esaminare lo stato di un file. Vi sono operatori su stringa e anche operatori di comparazione numerica. Ogni operatore e operando deve essere un argomento separato.

Se si usa la forma tra parentesi quadra, è indispensabile che queste siano spaziate dall'espressione da valutare.

Nella tabella 48.3, e successive, vengono elencate le espressioni elementari che possono essere utilizzate in questo modo.

Espressione Descrizione
-e <file> Vero se il file esiste ed è di qualunque tipo.
-b <file> Vero se il file esiste ed è un dispositivo a blocchi.
-c <file> Vero se il file esiste ed è un dispositivo a caratteri.
-d <file> Vero se il file esiste ed è una directory.
-f <file> Vero se il file esiste ed è un file normale.
-L <file> Vero se il file esiste ed è un collegamento simbolico.
-p <file> Vero se il file esiste ed è una pipe con nome.
-S <file> Vero se il file esiste ed è un socket.
-t Vero se lo standard output è aperto su un terminale.

Tabella 48.3: Espressioni per la verifica del tipo di file.

Espressione Descrizione
-g <file> Vero se il file esiste ed è impostato il suo bit SGID.
-u <file> Vero se il file esiste ed è impostato il suo bit SUID.
-k <file> Vero se il file ha il bit Sticky attivo.
-r <file> Vero se il file esiste ed è leggibile.
-w <file> Vero se il file esiste ed è scrivibile.
-x <file> Vero se il file esiste ed è eseguibile.
-O <file> Vero se il file esiste e appartiene all'UID efficace dell'utente attuale.
-G <file> Vero se il file esiste e appartiene al GID efficace dell'utente attuale.

Tabella 48.4: Espressioni per la verifica dei permessi e delle modalità dei file.

Espressione Descrizione
-s <file> Vero se il file esiste e ha una dimensione maggiore di zero.
<file1> -nt <file2> Vero se il primo file ha la data di modifica più recente.
<file1> -ot <file2> Vero se il primo file ha la data di modifica più vecchia.
<file1> -et <file2> Vero se i due nomi corrispondono allo stesso inode.

Tabella 48.5: Espressioni per la verifica di altre caratteristiche dei file.

Espressione Descrizione
-z <stringa> Vero se la lunghezza della stringa è zero.
-n <stringa> Vero se la lunghezza della stringa è diversa da zero.
<stringa1> = <stringa2> Vero se le stringhe sono uguali.
<stringa1> != <stringa2> Vero se le stringhe sono diverse.
<stringa1> < <stringa2> Vero se la prima stringa è lessicograficamente precedente.
<stringa1> > <stringa2> Vero se la prima stringa è lessicograficamente successiva.

Tabella 48.6: Espressioni per la verifica e la comparazione delle stringhe.

Espressione Descrizione
<op1> -eq <op2> Vero se gli operandi sono uguali.
<op1> -ne <op2> Vero se gli operandi sono differenti.
<op1> -lt <op2> Vero se il primo operando è inferiore al secondo.
<op1> -le <op2> Vero se il primo operando è inferiore o uguale al secondo.
<op1> -gt <op2> Vero se il primo operando è maggiore del secondo.
<op1> -ge <op2> Vero se il primo operando è maggiore o uguale al secondo.

Tabella 48.7: Espressioni per il confronto numerico. Come operandi possono essere utilizzati numeri interi, positivo o negativi, oppure l'espressione speciale `-<stringa>' che restituisce la lunghezza della stringa indicata.

Espressione Descrizione
! <espressione> Inverte il risultato logico dell'espressione.
<espressione> -a <espressione> Vero se entrambe le espressioni danno un risultato Vero.
<espressione> -o <espressione> Vero se almeno un'espressione dà un risultato Vero.

Tabella 48.8: Operatori logici.

48.35 times

times

Emette i tempi di utilizzo accumulati.

48.36 trap

trap [-l] [<argomento>] [<segnale>]

Il comando espresso nell'argomento dovrà essere letto ed eseguito quando la shell riceverà il segnale, o i segnali indicati. Se non viene fornito l'argomento, o viene indicato un trattino (`-') al suo posto, tutti i segnali specificati sono riportati al loro valore originale (i valori che avevano al momento dell'ingresso nella shell). Se l'argomento fornito corrisponde a una stringa nulla, questo segnale viene ignorato dalla shell e dai comandi che questo avvia. Se il segnale è `EXIT', pari a zero, il comando contenuto nell'argomento viene eseguito all'uscita della shell.

Se viene utilizzato senza argomenti, `trap' emette la lista di comandi associati con ciascun numero di segnale. L'opzione `-l' fa sì che la shell emetta una lista di nomi di segnali e i loro numeri corrispondenti. I segnali ignorati al momento dell'ingresso della shell non possono essere intercettati o inizializzati. I segnali intercettati sono riportati al loro valore originale in un processo discendente quando questo viene creato.

Il valore restituito è Vero se non vengono riscontrati errori.

48.37 type

type [-all] [-type | -path] <nome> [<nome>...]

Determina le caratteristiche di uno o più comandi indicati come argomento.

Alcune opzioni

<nessuna opzione>

Se viene usato senza opzioni, indica come verrebbe interpretato ciascun nome indicato negli argomenti, se questo fosse usato come comando.

-type | -t

Viene emessa la definizione del tipo di nome indicato tra gli argomenti. Può trattarsi di:

  • `alias';

  • `keyword' (parola riservata della shell);

  • `function';

  • `builtin' (comando interno);

  • `file'.

Se il nome non viene trovato, allora non si ottiene alcun output e viene restituito il valore Falso.

-path | -p

Viene emesso il nome del file che verrebbe eseguito se il nome indicato negli argomenti fosse utilizzato come un nome di comando; se il file non esiste, non viene emesso alcun risultato.

-all | -a

Emette tutti gli elementi corrispondenti ai nomi indicati, inclusi alias e funzioni, purché non sia usata anche l'opzione `-path'.

Restituisce Vero se uno qualsiasi degli argomenti viene trovato, Falso se non ne viene trovato alcuno.

48.38 ulimit

ulimit [<opzioni>] [<limite>] 

Fornisce il controllo sulle risorse disponibili per la shell e per i processi avviati da questa, sui sistemi che permettono un tale controllo. Il valore del limite può essere un numero nell'unità specificata per la risorsa, o il valore `unlimited'.

Se l'indicazione dell'entità del limite viene omessa, si ottiene l'informazione del valore corrente. Quando viene specificata più di una risorsa, il nome del limite e l'unità vengono emessi prima del valore.

A meno di usare kernel Linux particolarmente recenti, è probabile che alcune delle funzionalità di questo comando non producano alcun risultato pratico, perché le funzioni di sistema che devono attuare questi compiti non sono ancora operative.

Alcune opzioni

-H

Viene impostato il limite fisico (hard) per la data risorsa. Un limite fisico non può essere aumentato una volta che è stato impostato. Se non viene specificata questa opzione, si intende l'opzione `-S' in modo predefinito.

-S

Viene impostato il limite logico (soft) per la data risorsa. Un limite logico può essere aumentato fino al valore del limite fisico. Se non viene specificata questa opzione, e nemmeno `-H', questa è l'opzione predefinita.

-a

Sono riportati tutti i limiti correnti.

-c

La grandezza massima dei file `core' creati.

-d

La grandezza massima del segmento dati di un processo.

-f

La grandezza massima dei file creati dalla shell.

-m

La grandezza massima della memoria occupata.

-s

La grandezza massima dello stack del processo.

-t

Il massimo quantitativo di tempo di CPU in secondi.

-p

La grandezza della pipe in blocchi da 512 byte (questo non può essere cambiato).

-n

Il numero massimo di descrittori di file aperti (la maggior parte dei sistemi non permette che questo valore sia impostato, ma solo mostrato).

-u

Il numero massimo di processi disponibili per un solo utente.

-v

Il massimo ammontare di memoria virtuale disponibile per la shell.

Se il limite viene espresso, questo diventa il nuovo valore per la risorsa specificata. Se non viene espressa alcuna opzione, si assume `-f'. I valori sono in multipli di 1024 byte, tranne che per `-t' che è in secondi, `-p' che è in unità di blocchi da 512 byte, e `-n' e `-u', che sono numeri senza unità.

Il valore restituito è zero se non vengono commessi errori.

48.39 umask

umask [-S] [<modalità>]

La maschera dei permessi per la creazione dei file dell'utente viene modificata in modo da farla coincidere con la modalità indicata. Se la modalità inizia con una cifra numerica, questo valore viene interpretato come un numero ottale; altrimenti viene interpretato in modo simbolico, così come avviene con `chmod'. Se la modalità viene omessa, oppure se è stata fornita l'opzione `-S', viene emesso il valore corrente della maschera. L'opzione `-S' fa sì che la maschera venga emessa in formato simbolico; l'uscita predefinita è un numero ottale.

Restituisce zero se non vengono riscontrati errori.

48.40 unalias

unalias [-a] [<nome-di-alias>...]

Rimuove l'alias indicato dalla lista degli alias definiti. Se viene fornita l'opzione `-a', sono rimosse tutte le definizioni di alias.

Restituisce Vero se non vengono riscontrati errori.

48.41 unset

unset [-v] <nome-variabile>...

unset -f <nome-funzione>...

Vengono rimosse le variabili indicate. Se viene utilizzata l'opzione `-f', si fa riferimento a funzioni.

Le variabili `PATH', `IFS', `PPID', `PS1', `PS2', `UID', e `EUID' non possono essere rimosse.

Se una qualsiasi fra `RANDOM', `SECONDS', `LINENO', o `HISTCMD' viene rimossa, perde la sua speciale proprietà, persino se viene ripristinata successivamente.

Restituisce Vero se non vengono riscontrati errori.

48.42 wait

wait [n]

Attende la conclusione del processo specificato e restituisce il suo valore di uscita. Il numero n può essere un PID o un job; se viene indicato un job, si attende la conclusione di tutti i processi nella pipeline di quel job. Se n non viene indicato, si aspetta la conclusione di tutti i processi discendenti correntemente attivi, e il valore restituito è zero. Se n specifica un processo o un job non esistente, viene restituito 127. Altrimenti, il valore restituito è lo stesso dell'ultimo processo o job per cui si era in attesa.

---------------------------

Appunti Linux 2000.04.12 --- Copyright © 1997-2000 Daniele Giacomini --  daniele @ pluto.linux.it


[inizio] [indice generale] [precedente] [successivo] [indice analitico] [contributi]