Provided by: manpages-it_2.80-3_all bug

NOME

       bash - GNU Bourne-Again SHell

SINTASSI

       bash [opzioni] [file]

COPYRIGHT

       Bash is Copyright (C) 1989-2005 by the Free Software Foundation, Inc.

DESCRIZIONE

       Bash è un interprete di linguaggio di comandi sh-compatibile che esegue
       i comandi letti dallo standard  input  o  da  un  file.   Bash  inoltre
       incorpora utili caratteristiche delle shell Korn e C (ksh e csh).

       Bash  è  progettata  per  essere un’implementazione conforme alla parte
       Shell and Utilities  della  IEEE  POSIX  specification  (IEEE  Standard
       1003.1).  Bash può essere configurata per essere conforme allo standard
       POSIX per default.

OPZIONI

       In aggiunta alle opzioni della shell di un solo  carattere  documentate
       nella  descrizione  del comando incorporato set, quando è invocata bash
       interpreta le seguenti opzioni:

       -c stringa
                 Se è presente l’opzione -c, allora i comandi  sono  letti  da
                 stringa.   Se  vi  sono  argomenti dopo la stringa, essi sono
                 assegnati ai parametri posizionali, partendo da $0.
       -i        Se è presente l’opzione -i, la shell è interattiva.
       -l        fa sì che bash funzioni come se fosse stata invocata come una
                 shell di login (si veda INVOCAZIONE più avanti).
       -r        Se  l’opzione  -r  è presente, la shell diventa ristretta (si
                 veda SHELL RISTRETTA più avanti)
       -s        Se è presente l’opzione -s, o se non rimane  alcun  argomento
                 dopo  che  sono  state  esaminate  le opzioni, i comandi sono
                 letti  dallo  standard  input.   Quest’opzione  permette   di
                 impostare  i parametri posizionali quando si invoca una shell
                 interattiva.
       -D        Una lista di tutte le stringhe fra virgolette preceduta da  $
                 è  stampata  sullo  standard output.  Queste sono le stringhe
                 che sono  soggette  a  traduzione  di  linguaggio  quando  la
                 localizzazione  corrente  non  è  C  o POSIX.  Questo implica
                 l’opzione -n; nessun comando verrà eseguito.
       [-+]O [shopt_option]
                 shopt_option è una  delle  opzioni  di  shell  accettate  dal
                 comando  incorporato shopt (si veda COMANDI INCORPORATI DELLA
                 SHELL più avanti).  Se shopt_option è presente, -O imposta il
                 valore di quella opzione; +O lo rimuove.  Se shopt_option non
                 è fornita, i nomi  e  i  valori  delle  opzioni  della  shell
                 accettati  da  shopt sono stampati sullo standard output.  Se
                 l’opzione di invocazione è +O,  l’output  è  mostrato  in  un
                 formato riutilizzabile come input.
       --        Un  --  segna  la fine delle opzioni e disabilita l’ulteriore
                 elaborazione di opzioni.   Gli  argomenti  dopo  il  --  sono
                 trattati  come nomi di file e argomenti.  Un argomento di - è
                 equivalente a --.

       Bash interpreta  anche  un  certo  numero  di  opzioni  multicarattere.
       Queste  opzioni  devono  apparire  nella  riga  di  comando prima delle
       opzioni a carattere singolo.

       --debugger
              Dispone l’esecuzione del debugger profile prima dell’avvio della
              shell.    Attiva  la  modalità  estesa  di  debug  (si  veda  la
              descrizione dell’opzione extdebug al comando  incorporato  shopt
              più  avanti)  e il tracciamento delle funzioni di shell (si veda
              la descrizione dell’opzione -o functrace al comando  incorporato
              set più avanti).
       --dump-po-strings
              Equivalente  a -D, ma l’output è nel formato file GNU gettext po
              (portable object).
       --dump-strings
              Equivalente a -D.
       --help Mostra sullo standard output un messaggio sull’uso ed  esce  con
              stato di uscita 0.
       --init-file file
       --rcfile file
              Esegue  comandi  letti  da file invece che dal file personale di
              inizializzazione standard ~/.bashrc se la  shell  è  interattiva
              (si veda INVOCAZIONE più avanti).

       --login
              Equivalente a -l

       --noediting
              Non  usa  la  libreria GNU readline per leggere righe di comando
              quando la shell è interattiva.

       --noprofile
              Non legge né il file di  inizializzazione  generico  di  sistema
              /etc/profile  né  alcuno  dei file personali di inizializzazione
              ~/.bash_profile, ~/.bash_login, o ~/.profile.  Per default  bash
              legge questi file quando è invocata come shell di login (si veda
              INVOCAZIONE più avanti).

       --norc Non legge  né  esegue  il  file  personale  di  inizializzazione
              ~/.bashrc  se  la  shell è interattiva.  Questa opzione è attiva
              per default se la shell è invocata come sh.

       --posix
              Cambia il comportamento di bash, dove le operazioni  di  default
              differiscono dallo standard POSIX, in modo da corrispondere alla
              (modalit posix) standard.

       --ristretta
              La   shell  diventa  ristretta  (si  veda  SHELL  RISTRETTA  più
              avanti).

       --verbose
              Equivalente a  -v.

       --version
              Mostra  informazioni  sulla  versione  di questa istanza di bash
              sullo standard output ed esce con stato d’uscita 0.

ARGOMENTI

       Se rimangono argomenti dopo che sono state elaborate le opzioni,  e  né
       l’opzione -c né l’opzione -s sono state specificate, il primo argomento
       si assume sia il nome di un file che contiene dei comandi di shell.  Se
       bash  è  invocata  in questo modo, $0 è impostato al nome del file, e i
       parametri posizionali sono impostati agli  argomenti  che  lo  seguono.
       Bash  legge  ed  esegue  comandi  da  questo  file, poi esce.  Lo stato
       d’uscita di Bash è lo stato d’uscita dell’ultimo comando eseguito nello
       script.   Se non è eseguito alcun comando lo stato d’uscita è 0.  Viene
       fatto un primo tentativo per aprire il file nella directory corrente, e
       se non viene trovato il file la shell cerca le directory in PATH per lo
       script.

INVOCAZIONE

       Una shell di login è una in cui il cui primo  carattere  dell’argomento
       zero è un -, o una che venga avviata con l’opzione --login.

       Una  shell  è  detta  interattiva  se  è  stata avviata senza argomenti
       diversi dalle opzioni e senza l’opzione  -c  i  cui  standard  input  e
       standard  error  sono entrambi inviati a terminali (come determinato da
       isatty(3)), o se viene avviata con l’opzione -i .  PS1 è impostato e $-
       include  i se bash è interattiva, permettendo a uno script di shell o a
       un file di inizializzazione di verificare questo stato.

       I seguenti paragrafi  descrivono  come  bash  esegue  i  suoi  file  di
       inizializzazione.   Se qualcuno dei file esiste ma non può essere letto
       bash riporta un errore.  Le tilde sono espanse nei nomi  di  file  come
       descritto  più  avanti  sotto  Espansione  della  tilde  nella  sezione
       ESPANSIONE .

       Quando bash è invocata come una shell di login interattiva, o come  una
       shell  non  interattiva  con  l’opzione  --login, prima legge ed esegue
       comandi dal file /etc/profile, se quel file esiste.   Dopo  aver  letto
       quel  file,  cerca  ~/.bash_profile,  ~/.bash_login,  e  ~/.profile, in
       quest’ordine, e legge ed esegue comandi dal primo file che trova e  che
       è leggibile.  L’opzione --noprofile può essere usata quando si avvia la
       shell per inibire questo comportamento.

       Quando una shell di login esce, bash legge ed esegue comandi  dal  file
       ~/.bash_logout, se esiste.

       Quando  una  shell  interattiva che non è una shell di login è avviata,
       bash legge ed esegue comandi da ~/.bashrc, se quel  file  esiste.   Ciò
       può  essere  inibito utilizzando l’opzione --norc .  L’opzione --rcfile
       file forza bash a leggere ed eseguire comandi da  file  invece  che  da
       ~/.bashrc.

       Quando  bash è avviata in modo non interattivo, per eseguire uno script
       di shell, per esempio,  cerca  la  variabile  di  ambiente  BASH_ENV  ,
       espande  il  suo  valore se questo esiste, e utilizza il valore espanso
       come il nome di un file da leggere ed eseguire.  Bash si comporta  come
       se fossero stati eseguiti i seguenti comandi:
              if [ -n "$BASH_ENV" ]; then . "$BASH_ENV"; fi
       ma  il  valore della variabile PATH non è usato per cercare il nome del
       file.

       Se bash è invocata col nome sh, tenta di imitare  il  comportamento  di
       inizializzazione  delle  vecchie  versioni  di  sh  il  più  fedelmente
       possibile, e allo stesso tempo si conforma allo standard POSIX.  Quando
       invocata  come  una shell di login interattiva, o una shell interattiva
       con l’opzione --login, per prima cosa tenta di leggere  ed  eseguire  i
       comandi  da  /etc/profile  e  ~/.profile,  in  quest’ordine.  L’opzione
       --noprofile può essere usata per inibire questo comportamento.   Quando
       invocata  come  una  shell  interattiva  col  nome  sh,  bash  cerca la
       variabile ENV, espande il suo valore se questo è  definito,  e  usa  il
       valore espanso come nome di un file da leggere ed eseguire.  Poiché una
       shell invocata come sh non tenta di  leggere  ed  eseguire  comandi  da
       qualsiasi  altro  file  di  inizializzazione, l’opzione --rcfile non ha
       alcun effetto.  Una shell non interattiva  invocata  col  nome  sh  non
       tenta  di  leggere  nessun  altro  file  di  inizializzazione.   Quando
       invocata come sh, bash lavora in modalità posix  dopo  che  i  file  di
       inizializzazione sono stati letti.

       Quando  bash  è  avviata  in  modalità posix come con l’opzione --posix
       della riga di comando, essa segue lo  standard  POSIX  per  i  file  di
       inizializzazione.   In  questa modalità la shell interattiva espande la
       variabile ENV e i comandi sono letti ed eseguiti dal file il cui nome è
       il  valore espanso.  Nessun altro file di inizializzazione viene letto.

       Bash cerca di determinare quando la si  sta  eseguendo  dal  demone  di
       shell remota, usualmente rshd.  Se bash determina che viene eseguito da
       rshd, legge ed esegue comandi da ~/.bashrc, se quel file  esiste  ed  è
       leggibile.   Non fa questo se è invocata come sh.  L’opzione --norc può
       essere usata per inibire questo comportamento, e l’opzione --rcfile può
       essere  usata  per  forzare  la  lettura  di  un  altro  file,  ma rshd
       solitamente non invoca la shell con queste opzioni o non  permette  che
       siano specificate.

       Se  la  shell  è  avviata  con  l’id effettivo dell’utente (gruppo) non
       uguale all’id reale dell’utente (gruppo), e non viene fornita l’opzione
       -p,  nessun  file di inizializzazione viene letto, le funzioni di shell
       non vengono ereditate dall’ambiente, la variabile SHELLOPTS , se esiste
       nell’ambiente, viene ignorata, e l’id effettivo dell’utente è impostata
       all’id reale dell’utente.  Se l’opzione -p è  fornita  all’invocazione,
       il comportamento all’avvio è il medesimo, ma l’id effettivo dell’utente
       non viene reimpostato.

DEFINIZIONI

       Le seguenti definizioni sono usate nel resto di questo documento.
       blank  Uno spazio o carattere di tabulazione (tab).
       parola Una sequenza di caratteri considerata  come  una  singola  unità
              dalla shell.  Nota anche come token.
       nome   Una  parola  che  consiste  solo  di  caratteri  alfanumerici  e
              trattini  di  sottolineatura,  e  comincia  con   un   carattere
              alfabetico  o  un trattino di sottolineatura.  Definita anche un
              identificatore.
       metacarattere
              Un carattere che, quando non quotato, separa le parole.  Uno dei
              seguenti:
              |  & ; ( ) < > spazio tab
       operatore di controllo
              Un  token  che  realizza  una  funzione di controllo.  È uno dei
              seguenti simboli:
              || & && ; ;; ( ) | <newline>

PAROLE RISERVATE

       Le parole riservate sono parole che hanno un significato  speciale  per
       la  shell.   Le seguenti parole sono riconosciute come riservate quando
       non quotate e sono o la prima parola di un comando  semplice  (si  veda
       GRAMMATICA DELLA SHELL più avanti) o la terza parola di un comando case
       o di un comando for :

       ! case  do done elif else esac fi for function if in select then  until
       while { } time [[ ]]

GRAMMATICA DELLA SHELL

   Comandi semplici
       Un  comando  semplice  è  una  sequenza  opzionale  di  assegnamenti di
       variabile seguita da  parole,  separate  da  blank,  e  ridirezioni,  e
       terminata  da  un operatore di controllo.  La prima parola specifica il
       comando che deve essere eseguito, ed è passata come argomento zero.  Le
       rimanenti parole sono passate come argomenti al comando invocato.

       Il valore di ritorno di un comando semplice è il suo stato di uscita, o
       128+n se il comando è fatto terminare da un segnale n.

   Pipeline
       Una pipeline è una sequenza di uno o più comandi separati dal carattere
       |.  Il formato per una pipeline è:

              [time [-p]] [ ! ] comando [ | comando2 ... ]

       Lo  standard  output  di  comando  è  connesso attraverso una pipe allo
       standard input di comando2.  Questa connessione è effettuata  prima  di
       qualsiasi  ridirezione specificata dal comando (si veda RIDIREZIONE più
       avanti).

       Lo stato di ritorno di una pipeline è  lo  stato  d’uscita  dell’ultimo
       comando,  a meno che l’opzione pipefail non sia abilitata.  Se pipefail
       è abilitata, lo stato di ritorno della pipeline è il valore dell’ultimo
       comando (il più a destra) che esce con uno stato diverso da zero o zero
       se tutti i comandi escono con  successo.   Se  la  parola  riservata  !
       precede  una  pipeline,  lo  stato  d’uscita  di  quella  pipeline è la
       negazione logica dello stato d’uscita come sopra descritto.   La  shell
       aspetta che tutti i comandi nella pipeline terminino prima di ritornare
       un valore.

       Se la parola riservata time precede una pipeline,  quando  la  pipeline
       termina  vengono notificati i tempi impiegati dall’utente e dal sistema
       per la sua esecuzione.  L’opzione -p cambia il formato  di  output  con
       quello  specificato  da  POSIX.   La  variabile  TIMEFORMAT  può essere
       impostata a una stringa di formato che specifica come  le  informazioni
       sui   tempi  dovranno  essere  mostrate;  si  veda  la  descrizione  di
       TIMEFORMAT sotto Variabili di shell più avanti.

       Ogni comando in una pipeline è eseguito come un processo separato (cioè
       in una subshell).

   Liste
       Una  lista  è  una sequenza di una o più pipeline separate da uno degli
       operatori ;, &, &&, o ││, e facoltativamente fatta terminare da uno fra
       ;, &, o <newline>.

       Di  questi operatori di lista, && e ││ hanno uguale precedenza, seguiti
       da ; e &, che hanno uguale precedenza.

       Per delimitare dei comandi può essere usata in una lista  una  sequenza
       di uno o più newline al posto di un punto e virgola.

       Se  un  comando  è  terminato  dall’operatore  di controllo &, la shell
       esegue il comando in background in una subshell.  La shell non  aspetta
       che  il comando finisca, e lo stato di ritorno è 0.  I comandi separati
       da un ; sono  eseguiti  sequenzialmente;  la  shell  aspetta  che  ogni
       comando, in sequenza, termini.  Lo stato di ritorno è lo stato d’uscita
       dell’ultimo comando eseguito.

       Gli operatori di controllo && e ││  denotano  liste  AND  e  liste  OR,
       rispettivamente.  Una lista AND ha la forma

              comando1 && comando2

       comando2  è eseguito se, e solo se, comando1 ritorna uno stato d’uscita
       di zero.

       Una lista OR ha la forma

              comando1 ││ comando2

       comando2 è eseguito se e solo se comando1 ritorna  uno  stato  d’uscita
       diverso  da  zero.   Lo  stato  di ritorno di liste AND e OR è lo stato
       d’uscita dell’ultimo comando eseguito nella lista.

   Comandi composti
       Un comando composto è uno dei seguenti:

       (lista)
              lista è eseguita in un ambiente di subshell (si veda AMBIENTE DI
              ESECUZIONE DEI COMANDI più avanti).  Assegnamenti di variabile e
              comandi incorporati che influenzano l’ambiente della  shell  non
              hanno  effetto  dopo  che  il comando è completato.  Lo stato di
              ritorno è lo stato d’uscita di lista.

       { lista; }
              lista è semplicemente eseguita nell’ambiente di shell  corrente.
              lista  deve  essere  fatta terminare con un newline o un punto e
              virgola.  Questo è conosciuto come group command.  Lo  stato  di
              ritorno   è   lo   stato  d’uscita  di  lista.   Da  notare  che
              diversamente dai  metacaratteri  (  e  ),  {  e  }  sono  parole
              riservate  e  devono  essere usati quando una parola riservata è
              ammissibile.   Poiché  esse  non  causano  una  divisione  delle
              parole, devono essere separate da lista con uno spazio.

       ((espressione))
              L’espressione  è valutata in accordo con le regole descritte più
              avanti   sotto   VALUTAZIONE   ARITMETICA.    Se    il    valore
              dell’espressione  è  diverso  da  zero, lo stato di ritorno è 0;
              altrimenti lo stato  di  ritorno  è  1.   Questo  è  esattamente
              equivalente a let "espressione".

       [[ espressione ]]
              Ritorna  uno  stato  di  0 o 1 a seconda della valutazione della
              espressione  condizionale  espressione.   Le  espressioni   sono
              composte  dalle primitive descritte più avanti sotto ESPRESSIONI
              CONDIZIONALI.  La suddivisione in parole e l’espansione del nome
              di  percorso  non  sono  effettuate sulle parole fra la [[ e ]];
              espansione della tilde, espansione di parametro e di  variabile,
              espansione  aritmetica, sostituzione di comando, sostituzione di
              processo, e  rimozione  degli  apici  vengono  effettuate.   Gli
              operatori  condizionali  come  -f  devono essere senza apici per
              essere riconosciuti come primitive.

              Quando vengono usati gli operatori ==  e  !=,  la  stringa  alla
              destra  dell’operatore è considerato un modello ed è confrontata
              in accordo con le regole descritte più avanti sotto  Modelli  di
              ricerca.   Se  l’opzione  di  shell  nocasematch è abilitata, il
              confronto  è  effettuato  senza  distinzione  fra  maiuscole   e
              minuscole nei caratteri alfabetici.  Il valore di ritorno è 0 se
              la stringa corrisponde (==) o non corrisponde (!=) al modello, e
              1  negli  altri casi.  Ogni parte del modello può essere quotato
              per forzarlo a essere individuato come una stringa.

              Un ulteriore operatore binario, =~, è disponibile con la  stessa
              precedenza  di  ==  e  !=.   Quando viene usato, la stringa alla
              destra  dell’operatore  è  considerata  un’espressione  regolare
              estesa e confrontata come tale (come in regex(3)).  Il valore di
              ritorno è 0 se la stringa corrisponde  al  modello,  e  1  negli
              altri   casi.    Se  l’espressione  regolare  è  sintatticamente
              scorretta, il valore di ritorno dell’espressione condizionale  è
              2.   Se l’opzione di shell nocasematch è abilitata, il confronto
              è effettuato senza distinguere le maiuscole dalle minuscole  nei
              caratteri    alfabetici.     Substringhe   individuate   tramite
              subespressioni  fra   parentesi   all’interno   dell’espressione
              regolare   sono  salvate  nella  variabile  array  BASH_REMATCH.
              L’elemento di BASH_REMATCH con indice  0  è  la  porzione  della
              stringa    corrispondente   all’intera   espressione   regolare.
              L’elemento di BASH_REMATCH con indice  n  è  la  porzione  della
              stringa corrispondente alla subespressione fra parentesi nth.

              Le  espressioni  possono  essere  combinate  usando  i  seguenti
              operatori, elencati in ordine inverso di precedenza:

              ( espressione )
                     Ritorna il valore  di  espressione.   Questo  può  essere
                     usato   per   modificare   la  normale  precedenza  degli
                     operatori.
              ! espressione
                     Vero se espressione è falsa.
              espressione1 && espressione2
                     Vero se entrambe espressione1 e espressione2 sono vere.
              espressione1 || espressione2
                     Vero se almeno una  fra  espressione1  o  espressione2  è
                     vera.

              Gli  operatori && e || non valutano espressione2 se il valore di
              espressione1 è sufficiente per determinare il valore di  ritorno
              dell’intera espressione condizionale.

       for nome [ in parola; ] do lista ; done
              La lista di parole che seguono in è espansa, generando una lista
              di elementi.  La variabile nome è impostata, di volta in  volta,
              a  ciascun  elemento  di  questa  lista  e lista è eseguita ogni
              volta.  Se la in parola è omessa, il comando  for  esegue  lista
              una  volta  per  ogni  parametro  posizionale esistente (si veda
              PARAMETRI più avanti).  Lo stato di ritorno è lo stato  d’uscita
              dell’ultimo  comando  eseguito.   Se l’espansione degli elementi
              che seguono in risultano in una  lista  vuota,  non  è  eseguito
              alcun comando, e lo stato di ritorno è 0.

       for (( expr1 ; expr2 ; expr3 )) ; do lista ; done
              Prima  viene  valutata l’espressione aritmetica expr1 in accordo
              con le regole descritte più avanti sotto VALUTAZIONE ARITMETICA.
              Viene  quindi  valutata  ripetutamente  l’espressione aritmetica
              expr2 finché non assume il valore zero.  Ogni volta che expr2  è
              diverso da zero, lista viene eseguita e l’espressione aritmetica
              expr3 viene valutata.   Se  qualche  espressione  è  omessa,  si
              suppone  che abbia il valore 1.  Il valore di ritorno è lo stato
              d’uscita dell’ultimo comando in lista che è eseguito, o falso se
              una qualsiasi delle espressioni non è valida.

       select nome [ in parola; ] do lista ; done
              La  lista  di parole che segue in è espansa, generando una lista
              di elementi.  L’insieme delle parole espanse  è  stampato  sullo
              standard  error, ognuna preceduta da un numero.  Se la in parola
              è  omessa,  sono  stampati  i  parametri  posizionali  (si  veda
              PARAMETRI  più  avanti). È poi mostrato il prompt PS3 ed è letta
              una riga dallo standard input.  Se la riga è  contrassegnata  da
              un  numero corrispondente a una delle parole mostrate, allora il
              valore di nome è impostato a quella parola.  Se la riga è vuota,
              le  parole e il prompt sono mostrati di nuovo.  Se viene immesso
              EOF [CTRL-D], il comando termina.  Qualsiasi altro valore  letto
              fa  sì  che nome sia impostato al valore nullo.  La riga letta è
              salvata  nella  variabile  REPLY.   La  lista  è  eseguita  dopo
              ciascuna  selezione fino a che non sia eseguito un comando break
              .  Lo stato d’uscita di select è lo stato  d’uscita  dell’ultimo
              comando  eseguito  in  lista,  o  zero se nessun comando è stato
              eseguito.

       case parola in [ [(] modello [ | modello ] ... ) lista ;; ] ... esac
              Un comando case prima espande parola, e prova a confrontarla, di
              volta  in volta, con ognuno dei modelli, usando le stesse regole
              di confronto dell’espansione di percorso (si veda Espansione  di
              percorso  più  avanti).   La  parola è espansa usando espansione
              della  tilde,  espansione   di   parametro   e   di   variabile,
              sostituzione  aritmetica,  sostituzione di comando, sostituzione
              di processo e rimozione dei simboli di quotatura.  Ogni  modello
              esaminato è espanso usando espansione della tilde, espansione di
              parametro e di variabile, sostituzione aritmetica,  sostituzione
              di  comando  e  sostituzione di processo.  Se l’opzione di shell
              nocasematch  è  abilitata,  il  confronto  è  effettuato   senza
              distinzione  fra maiuscole e minuscole nei caratteri alfabetici.
              Quando viene trovata una corrispondenza, viene eseguita la lista
              a essa abbinata.  Dopo il primo confronto riuscito, non ne viene
              tentato nessun altro.  Lo stato d’uscita è 0 se  nessun  modello
              corrisponde.   Altrimenti,  esso è lo stato d’uscita dell’ultimo
              comando eseguito in lista.

       if lista then lista [ elif lista then lista ] ... [ else lista ] fi
              La lista if è eseguita.   Se  il  suo  stato  d’uscita  è  0,  è
              eseguita  la  lista  dopo  then.  Altrimenti, è eseguita a turno
              ciascuna lista dopo elif, e se il suo  stato  d’uscita  è  0,  è
              eseguita la corrispondente lista dopo then e il comando termina.
              Altrimenti, se presente, è eseguita, la  lista  dopo  else.   Lo
              stato d’uscita è lo stato d’uscita dell’ultimo comando eseguito,
              o zero se  nessuna  delle  condizioni  considerate  è  risultata
              essere vera.

       while lista do lista done
       until lista do lista done
              Il  comando  while  esegue ripetutamente la lista dopo do finché
              l’ultimo comando in lista ritorna uno stato di uscita  di  zero.
              Il  comando  until  è  identico  al  comando  while, con la sola
              differenza che il risultato del test è negato;  la  lista  do  è
              eseguita  finché  l’ultimo  comando  in  lista ritorna uno stato
              d’uscita diverso da zero.  Lo stato d’uscita dei comandi while e
              until  è  lo  stato  d’uscita dell’ultimo comando eseguito nella
              lista do o zero se non ne è stato eseguito alcuno.

   Definizioni della funzione di shell
       Una funzione di shell è un oggetto che viene chiamato come  un  comando
       semplice ed esegue un comando composto con una nuova serie di parametri
       posizionali.  Le funzioni di shell sono dichiarate in questo modo:

       [ function ] nome () comando-composto [ridirezione]
              Qui sopra si definisce una funzione chiamata  nome.   La  parola
              riservata function è opzionale.  Se la parola riservata function
              è fornita, le parentesi sono opzionali.  Il corpo della funzione
              è il comando composto comando-composto (si veda Comandi composti
              sopra).  Questo comando è usualmente una lista di comandi fra  {
              e   },   ma   potrebbe  essere  qualsiasi  comando  elencato  in
              precedenza, sotto Comandi composti.  comando-composto è eseguito
              ogni  volta  che  nome  è  specificato  come  nome di un comando
              semplice.  Ogni ridirezione (si  veda  RIDIREZIONI  più  avanti)
              specificata  quando  una  funzione  è  definita viene effettuata
              quando quella funzione viene eseguita.  Lo stato d’uscita di una
              definizione  di funzione è 0 tranne quando si verifica un errore
              di sintassi o una funzione in sola lettura con lo stesso nome  è
              già  esistente.   Quando  eseguita,  lo  stato  d’uscita  di una
              funzione è lo stato d’uscita dell’ultimo  comando  eseguito  nel
              corpo. (si veda FUNZIONI più avanti).

COMMENTI

       In  una  shell  non  interattiva,  o  in  una  shell interattiva in cui
       l’opzione  interactive-comments  del  comando   incorporato   shopt   è
       abilitata (si veda COMANDI INCORPORATI DI SHELL più avanti), una parola
       che inizia con # fa sì che la parola e tutti i rimanenti  caratteri  di
       quella  riga  siano  ignorati.   Una  shell interattiva senza l’opzione
       interactive-comments abilitata  non  permette  i  commenti.   L’opzione
       interactive_comments è attiva per default nelle shell interattive.

QUOTATURA

       La  Quotatura  è  usata  per  togliere  il significato speciale, per la
       shell, di certi caratteri o parole.  La quotatura può essere usata  per
       disabilitare  il  trattamento  speciale  per  i caratteri speciali, per
       impedire che le parole riservate siano riconosciute come  tali,  e  per
       prevenire l’espansione di parametro.

       Ciascuno  dei  metacaratteri  elencati  prima  sotto  DEFINIZIONI ha un
       significato speciale per la shell e deve essere quotato  se  esso  deve
       rappresentare se stesso.

       Quando  vengono  usati  i servizi per l’espansione della cronologia dei
       comandi (si veda ESPANSIONE DELLA CRONOLOGIA più avanti), il  carattere
       di  espansione  della  cronologia,  in genere !, dev’essere quotato per
       prevenire l’espansione della cronologia.

       Vi sono tre meccanismi di quotatura: caratteri di protezione  (escape),
       apostrofi e virgolette.

       Un  backslash  (\)  non  quotato  è  il  carattere di protezione.  Esso
       attribuisce  il  valore  letterale   al   successivo   carattere,   con
       l’eccezione  di  <newline>.   Se  vi  è  una  coppia  \<newline> , e il
       backslash  non  è  quotato,  il  \<newline>   è   trattato   come   una
       continuazione  di  riga  (cioè,  è  rimosso dal flusso di input e viene
       realmente ignorato).

       Racchiudendo dei caratteri in apostrofi si conserva il valore letterale
       di  ogni  carattere  all’interno degli apostrofi.  Un apostrofo non può
       essere inserito tra apostrofi, nemmeno preceduto da un backslash.

       Racchiudere caratteri tra virgolette conserva il  valore  letterale  di
       tutti  i  caratteri all’interno, con le eccezioni di $, ‘, \, e, quando
       l’espansione della cronologia è  abilitata,  !.   I  caratteri  $  e  ‘
       conservano  il  loro  significato  speciale  anche  tra virgolette.  Il
       backslash mantiene il suo significato speciale solo quando  seguito  da
       uno  dei  seguenti  caratteri:  $,  ‘, ", \ o <newline>.  Le virgolette
       possono essere  contenute  in  una  stringa  fra  virgolette  facendole
       precedere da un backslash.  Se abilitata, l’espansione della cronologia
       viene effettuata a meno che un !  tra virgolette non venga protetto  da
       un backslash.  Il backslash che precede il !  non viene rimosso.

       I  parametri  speciali  * e @ hanno un significato speciale quando sono
       tra virgolette (si veda PARAMETRI più avanti).

       Parole della forma $'stringa'  sono  trattate  in  modo  speciale.   La
       parola  espande  in  stringa,  coi  caratteri  protetti da un backslash
       sostituiti come specificato dallo standard  ANSI  C.   Le  sequenze  di
       protezione  tramite  backslash,  se  presenti,  sono  decodificate come
       segue:
              \a     avviso (segnale acustico)
              \b     backspace
              \e     un carattere di escape
              \f     salto pagina
              \n     codice di fine riga (newline)
              \r     carriage return
              \t     tabulazione orizzontale
              \v     tabulazione verticale
              \\     backslash
              \'     apostrofo
              \nnn   il carattere a otto bit il cui valore è il valore  ottale
                     nnn (da una a tre cifre)
              \xHH   il  carattere  a  otto  bit  il  cui  valore  è il valore
                     esadecimale HH (una o due cifre esadecimali)
              \cx    un carattere control-x

       Il risultato espanso è racchiuso fra apostrofi come  se  il  segno  del
       dollaro non fosse presente.

       Una stringa fra virgolette preceduta dal segno del dollaro ($) causa la
       traduzione della stringa conformemente  alla  localizzazione  corrente.
       Se  la  localizzazione corrente è C o POSIX, il segno del dollaro viene
       ignorato.  Se la stringa è tradotta e sostituita, la sostituzione è fra
       virgolette.

PARAMETRI

       Un  parametro è una entità che contiene valori.  Può essere un nome, un
       numero o uno dei caratteri speciali elencati più avanti sotto Parametri
       speciali.   Una  variabile  è  un  parametro  indicato da un nome.  Una
       variabile ha un valore e zero o  più  attributi.   Gli  attributi  sono
       assegnati  utilizzando  il comando incorporato declare (si veda declare
       più avanti in COMANDI INCORPORATI DI SHELL).

       Un parametro è impostato se a esso è stato  assegnato  un  valore.   La
       stringa  nulla  è  un  valore  valido.   Una  volta che una variabile è
       impostata, essa può essere rimossa solo usando il  comando  incorporato
       unset (si veda COMANDI INCORPORATI DELLA SHELL più avanti).

       Una variabile può essere assegnata da una istruzione della forma

              nome=[valore]

       Se valore è omesso, alla variabile è assegnata la stringa nulla.  Tutti
       i valori sono  sottoposti  a  espansione  della  tilde,  espansione  di
       parametro e variabile, sostituzione di comando, espansione aritmetica e
       rimozione dei caratteri di quotatura (si veda ESPANSIONE  più  avanti).
       Se  la variabile ha il suo attributo integer impostato, allora valore è
       valutato come  un’espressione  aritmetica  anche  se  l’espansione  del
       $((...))  non  è utilizzata (si veda Espansione aritmetica più avanti).
       La suddivisione in parole non è effettuata,  con  l’eccezione  di  "$@"
       come  spiegato  più  avanti  sotto Parametri speciali.  L’espansione di
       percorso non è effettuata.  Le istruzioni di assegnamento possono anche
       apparire  come  argomenti  per  i  comandi  incorporati alias, declare,
       typeset, export, readonly e local .

       Nel contesto in cui un’istruzione di  assegnamento  sta  assegnando  un
       valore  a una variabile di shell o a un indice di array, l’operatore +=
       può essere usato per accodare o aggiungere al precedente  valore  della
       variabile.   Quando  +=  è  applicato  a  una  variabile  per  la quale
       l’attributo  integer  è  stato  impostato,  valore  è   valutato   come
       un’espressione   aritmetica   e   aggiunto  al  valore  corrente  della
       variabile, che è a sua volta valutata.  Quando +=  è  applicato  a  una
       variabile  array  usando  assegnamenti  composti  (si  veda  Array  più
       avanti), il valore della variabile non è rimosso (com’è quando  si  usa
       =),  e  nuovi  valori  sono aggiunti alla fine dell’array iniziando dal
       massimo indice di array aumentato  di  uno.   Quando  applicata  a  una
       variabile  valutata come stringa, valore è espanso e accodato al valore
       della variabile.

   Parametri posizionali
       Un parametro posizionale è un parametro il cui nome è indicato da una o
       più cifre, diverse dalla singola cifra 0.  I parametri posizionali sono
       assegnati dagli argomenti della  shell  quando  questa  è  invocata,  e
       possono  essere  riassegnati  usando  il  comando  incorporato set .  I
       parametri posizionali non possono essere assegnati  con  istruzioni  di
       assegnamento.   I parametri posizionali sono temporaneamente sostituiti
       quando è eseguita una funzione di shell (si veda FUNZIONI più  avanti).

       Quando  si espande un parametro posizionale composto da più di una sola
       cifra, esso  deve  essere  racchiuso  tra  parentesi  graffe  (si  veda
       ESPANSIONE più avanti).

   Parametri speciali
       La  shell  tratta  molti  parametri in modo speciale.  Questi parametri
       possono solo essere referenziati; la loro modifica non è permessa.
       *      Si espande nei  parametri  posizionali,  a  partire  dal  primo.
              Quando  l’espansione  avviene  tra virgolette, si espande in una
              singola  parola  contenente  il  valore  di  ciascun   parametro
              separato   dagli  altri  dal  primo  carattere  della  variabile
              speciale IFS.  Cioè, ‘‘$*’’ è equivalente a ‘‘$1c$2c...’’,  dove
              c  è  il primo carattere del valore della variabile IFS.  Se IFS
              viene annullato, i parametri sono separati da spazi.  Se  IFS  è
              nulla, i parametri sono uniti senza alcun separatore.
       @      Si  espande  nei  parametri  posizionali,  a  partire dal primo.
              Quando l’espansione avviene tra virgolette,  ogni  parametro  si
              espande in una parola separata.  Cioè, "$@" è equivalente a "$1"
              "$2" ...  Se l’espansione fra virgolette avviene all’interno  di
              una  parola,  l’espansione  del  primo  parametro è unita con la
              parte  iniziale   della   parola   originale,   e   l’espansione
              dell’ultimo  parametro  è unita con la parte finale della parola
              originale.  Quando non vi è alcun parametro posizionale, "$@"  e
              $@ si espandono come stringa nulla (cioè, sono rimossi).
       #      Si  espande  nel  numero  di parametri posizionali espresso come
              numero decimale.
       ?      Si espande nello stato della pipeline eseguita più  recentemente
              senza rilasciare il controllo del terminale.
       -      Si espande nei flag di opzione correnti come specificato in base
              alla  chiamata,  dal  comando  incorporato  set,  o  in   quelli
              impostati dalla shell stessa (come l’opzione -i ).
       $      Si espande nell’ID di processo della shell.  In una subshell (),
              si espande nell’ID di processo  della  shell  corrente,  non  in
              quello della subshell.
       !      Si  espande  nell’ID  di  processo  del  comando  in  background
              (asincrono) più recentemente eseguito.
       0      Si espande nel nome della shell o script  di  shell.   Questo  è
              impostato alla inizializzazione della shell.  Se bash è chiamata
              con un file di comandi, $0 è impostato al nome di quel file.  Se
              bash  è avviata con l’opzione -c, allora $0 è impostato al primo
              argomento dopo la stringa che deve essere eseguita, se presente.
              Altrimenti,  è  impostato  al  percorso usato per chiamare bash,
              come dato dall’argomento zero.
       _      All’avvio della shell, impostato al nome  di  percorso  assoluto
              usato  per invocare la shell o lo script di shell che è eseguito
              come  passato  nell’ambiente  o  nella   lista   di   argomenti.
              Successivamente, si espande nell’ultimo argomento del precedente
              comando, dopo l’espansione.  È anche impostato al nome  completo
              usato  per  invocare ogni comando eseguito e messo nell’ambiente
              esportato verso quel comando.  Mentre  si  controlla  la  posta,
              questo  parametro  contiene  il  nome  del  file  del  messaggio
              attualmente in esame.

   Variabili di shell
       Le seguenti variabili sono impostate dalla shell:

       BASH   Si espande al nome completo usato per chiamare questa istanza di
              bash.
       BASH_ARGC
              Una  variabile di array i cui valori sono il numero di parametri
              in ogni frame del corrente stack delle chiamate di esecuzione di
              bash.    Il   numero  di  parametri  della  subroutine  corrente
              (funzione di shell o script eseguito con . o source) è  in  cima
              allo  stack.  Quando viene eseguita una subroutine, il numero di
              parametri passati è messo in cima a BASH_ARGC.  La shell imposta
              BASH_ARGC solo quando è in modalità estesa di debugging (si veda
              la descrizione dell’opzione extdebug per il comando  incorporato
              shopt più avanti)
       BASH_ARGV
              Una variabile di array contenente tutti i parametri nel corrente
              stack delle chiamate di esecuzione di bash.  Il parametro finale
              dell’ultima  chiamata  di  subroutine  è  in cima allo stack; il
              primo parametro della chiamata iniziale è in fondo.  Quando  una
              subroutine  viene  eseguita,  i  parametri forniti sono messi in
              cima a BASH_ARGV.  La shell imposta BASH_ARGV solo quando  è  in
              modalità   estesa   di   debugging   (si   veda  la  descrizione
              dell’opzione extdebug al comando incorporato shopt più avanti)
       BASH_COMMAND
              Il comando attualmente in esecuzione o  in  procinto  di  essere
              eseguito, a meno che la shell non stia eseguendo un comando come
              risultato di un’intercettazione di segnale (trap), nel qual caso
              è il comando in esecuzione al momento dell’intercettazione.
       BASH_EXECUTION_STRING
              L’argomento per il comando all’invocazione dell’opzione -c.
       BASH_LINENO
              Una  variabile  array  i  cui elementi sono i numeri di riga nei
              file di origine corrispondenti a ciascun elemento  di  FUNCNAME.
              ${BASH_LINENO[$i]}  è il numero di riga nel file di origine dove
              ${FUNCNAME[$ifP]}  stato chiamato.  Il nome del file di origine
              corrispondente   ${BASH_SOURCE[$i]}.  Usare LINENO per ottenere
              il numero di riga corrente.
       BASH_REMATCH
              Una variabile array i cui elementi sono assegnati dall’operatore
              binario  =~ al comando condizionale [[.  L’elemento con indice 0
              è  la  porzione  della  stringa   che   corrisponde   all’intera
              espressione  regolare.   L’elemento  con  indice n è la porzione
              della stringa che corrisponde alla   n-sima  subespressione  fra
              parentesi.  La variabile è in sola lettura.
       BASH_SOURCE
              Una  variabile  array i cui elementi sono i nomi dei file da cui
              provengono gli elementi nella variabile array FUNCNAME.
       BASH_SUBSHELL
              Incrementato di uno ogni volta che una subshell o un ambiente di
              subshell  è  stato  creato  dalla  shell  originale.   Il valore
              iniziale è 0.
       BASH_VERSINFO
              Una variabile  array  in  sola  lettura  i  cui  elementi  danno
              informazioni  sulla versione di quest’istanza di bash.  I valori
              assegnati ai membri dell’array sono come segue:
              BASH_VERSINFO[0]        Il  numero  di  versione   principale(la
                                      release).
              BASH_VERSINFO[1]        Il  numero  di  versione  secondario (la
                                      versione).
              BASH_VERSINFO[2]        Il  livello  di  aggiornamento   tramite
                                      patch.
              BASH_VERSINFO[3]        La versione di compilazione.
              BASH_VERSINFO[4]        Lo  stato della release (ad es., beta1).
              BASH_VERSINFO[5]        Il valore di MACHTYPE.

       BASH_VERSION
              Si espande in una stringa che descrive  la  versione  di  questa
              istanza di bash.

       COMP_CWORD
              Un  indice in ${COMP_WORDS} della parola contenente la posizione
              corrente del cursore.  Questa variabile è disponibile solo nelle
              funzioni  di  shell  invocate  dalle  risorse  di  completamento
              programmabile (si veda Completamento programmabile più  avanti).

       COMP_LINE
              La  riga  di  comando  corrente.  Questa variabile è disponibile
              solo nelle funzioni di shell e nei comandi esterni invocati  dai
              servizi  di  completamento  programmabile (si veda Completamento
              programmabile più avanti).

       COMP_POINT
              L’indice  della  posizione   corrente   del   cursore   relativa
              all’inizio  del  comando corrente.  Se la posizione corrente del
              cursore è alla fine del comando corrente, il  valore  di  questa
              variabile   è   uguale  a  ${#COMP_LINE}.   Questa  variabile  è
              disponibile solo nelle  funzioni  di  shell  e  comandi  esterni
              invocati  dai  servizi  di  completamento programmabile (si veda
              Completamento programmabile più avanti).

       COMP_WORDBREAKS
              L’insieme dei caratteri che la  libreria  Readline  tratta  come
              separatori di parola nell’effettuare il completamento di parola.
              Se COMP_WORDBREAKS  viene  annullata,  perde  le  sue  proprietà
              speciali, anche se è poi reimpostata.

       COMP_WORDS
              Una  variabile  array  (si veda Array più avanti) che è composta
              dalle singole parole nella riga di comando corrente.  Le  parole
              sono   divise   anche   dai  metacaratteri  della  shell  poiché
              l’analizzatore della shell li considererebbe  a  parte.   Questa
              variabile  è  disponibile solo nelle funzioni di shell e comandi
              esterni invocati dai servizi di completamento programmabile  (si
              veda Programmable Completion più avanti).

       DIRSTACK
              Una  variabile  array (si veda Array più avanti) che contiene il
              contenuto corrente dello stack delle  directory.   Le  directory
              appaiono  nello  stack  nell’ordine  in  cui  sono  mostrate dal
              comando incorporato dirs  .   L’assegnamento  agli  elementi  di
              questa  variabile  array  può  essere  usato  per  modificare le
              directory già nello stack, ma i comandi incorporati pushd e popd
              devono  essere  usati  per  aggiungere  e  rimuovere  directory.
              L’assegnamento  a  questa  variabile  non  cambia  la  directory
              corrente.   Se  DIRSTACK viene annullata, perde le sue proprietà
              speciali, anche se è poi reimpostata.

       EUID   Espande   all’ID-utente    effettivo    dell’utente    corrente,
              inizializzata all’avvio della shell.  Questa variabile è in sola
              lettura.

       FUNCNAME
              Una variabile array contenente i nomi di tutte  le  funzioni  di
              shell  attualmente  nello  stack  delle  chiamate di esecuzione.
              L’elemento con indice 0  è  il  nome  della  funzione  di  shell
              attualmente  in  esecuzione.  L’elemento più in basso di tutti è
              "main".  Questa variabile esiste solo quando è in esecuzione una
              funzione  di  shell.   Assegnamenti  a  FUNCNAME non hanno alcun
              effetto e ritornano uno stato  di  errore.   Se  FUNCNAME  viene
              annullata,  perde  le  sue  proprietà  speciali,  anche se è poi
              reimpostata.

       GROUPS Una variabile array contenente l’elenco dei gruppi dei  quali  è
              membro l’utente corrente.  Assegnamenti a GROUPS non hanno alcun
              effetto e ritornano  uno  stato  di  errore.   Se  GROUPS  viene
              annullata,  perde  le  sue  proprietà  speciali,  anche se è poi
              reimpostata.

       HISTCMD
              Il numero di cronologia, o indice nella lista della  cronologia,
              del  comando corrente.  Se HISTCMD viene annullata, perde le sue
              proprietà speciali, anche se è poi reimpostata.

       HOSTNAME
              Automaticamente impostata al nome dell’host corrente.

       HOSTTYPE
              Automaticamente  impostata  a  una  stringa   che   univocamente
              descrive  il  tipo  di macchina su cui bash è in esecuzione.  Il
              valore di default è dipendente dal sistema.

       LINENO Ogni volta che questo parametro è  referenziato,  la  shell  gli
              assegna un numero decimale che rappresenta il numero di sequenza
              della riga corrente (partendo da 1) all’interno di uno script  o
              funzione.   Quando non in uno script o funzione, non è garantito
              che il valore restituito sia  significativo.   Se  LINENO  viene
              annullata,  perde  le  sue  proprietà  speciali,  anche se è poi
              reimpostata.

       MACHTYPE
              Automaticamente   impostata   a   una   stringa   che   descrive
              completamente il tipo di sistema sul quale bash è in esecuzione,
              nel formato  standard  GNU  cpu-company-system.   Il  valore  di
              default è dipendente dal sistema.

       OLDPWD La precedente directory di lavoro come impostata dal comando cd.

       OPTARG Il valore dell’ultimo argomento opzione  elaborato  dal  comando
              incorporato getopts (si veda COMANDI INCORPORATI DELLA SHELL più
              avanti).

       OPTIND L’indice del prossimo argomento  che  dev’essere  elaborato  dal
              comando  incorporato  getopts (si veda COMANDI INCORPORATI DELLA
              SHELL più avanti).

       OSTYPE Automaticamente impostata a una stringa che descrive il  sistema
              operativo  su  cui bash è in esecuzione.  Il valore di default è
              dipendente dal sistema.

       PIPESTATUS
              Una variabile array (si veda Array  più  avanti)  contenente  un
              elenco  di  valori di stato d’uscita dai processi nelle pipeline
              eseguite più recentemente in primo piano [cioè senza  rilasciare
              il  controllo  del  terminale]  (può  contenere  anche  un  solo
              comando).

       PPID   L’ID di processo del genitore della shell.  Questa  variabile  è
              in sola lettura.

       PWD    La directory di lavoro corrente come impostata dal comando cd.

       RANDOM Ogni  volta  che questo parametro è referenziato, viene generato
              un numero intero casuale fra 0 e 32767.  La sequenza  di  numeri
              casuali  può essere inizializzata assegnando un valore a RANDOM.
              Se RANDOM viene annullata,  perde  le  sue  proprietà  speciali,
              anche se è poi reimpostata.

       REPLY  Impostata  alla riga di input letta dal comando incorporato read
              quando nessun argomento è specificato.

       SECONDS
              Ogni volta che questo parametro è referenziato, viene restituito
              il  numero  di secondi trascorsi dalla chiamata della shell.  Se
              un valore è assegnato a SECONDS, il valore restituito in base ai
              riferimenti   successivi   è  il  numero  di  secondi  trascorsi
              dall’assegnamento più il valore  assegnato.   Se  SECONDS  viene
              annullata,  perde  le  sue  proprietà  speciali,  anche se è poi
              reimpostata.

       SHELLOPTS
              Una lista, separata da due punti, di opzioni di shell abilitate.
              Ogni  parola  nella lista è un argomento valido per l’opzione -o
              al comando incorporato set (si veda COMANDI INCORPORATI DI SHELL
              più  avanti).   Le opzioni che appaiono in SHELLOPTS sono quelle
              indicate come on da set -o.  Se questa variabile è nell’ambiente
              quando  bash  viene  avviata,  ogni opzione di shell nella lista
              viene abilitata prima di leggere un  qualsiasi  file  di  avvio.
              Questa variabile è in sola lettura.

       SHLVL  È  incrementato  di uno ogni volta che una istanza di bash viene
              avviata.

       UID    Si espande  all’ID-utente  dell’utente  corrente,  inizializzato
              all’avvio della shell.  Questa variabile è in sola lettura.

       Le  seguenti  variabili  sono  usate dalla shell.  In alcuni casi, bash
       assegna un valore di default a una variabile; questi casi sono elencati
       più avanti.

       BASH_ENV
              Se  questo  parametro  è impostato quando bash sta eseguendo uno
              script di shell, il suo valore è interpretato come  un  nome  di
              file  contenente  comandi  per  inizializzare  la shell, come in
              ~/.bashrc.  Il valore di BASH_ENV è  soggetto  a  espansione  di
              parametro,  sostituzione  di  comando  ed  espansione aritmetica
              prima di essere interpretato come un nome di file.  PATH  non  è
              usato per cercare il nome di file risultante.
       CDPATH Il percorso di ricerca per il comando cd.  Questo è un elenco di
              directory, separate da due punti, nelle quali la shell cerca  le
              directory di destinazione specificate dal comando cd.  Un valore
              di esempio è ".:~:/usr".
       COLUMNS
              Usato dal comando incorporato select per determinare  il  numero
              di  colonne del terminale nella stampa delle liste di selezione.
              Automaticamente  re-impostata  al  ricevimento  di  un   segnale
              SIGWINCH.
       COMPREPLY
              Una   variabile   array  dalla  quale  bash  legge  i  possibili
              completamenti generati da una funzione  di  shell  invocata  dal
              servizio  di  completamento programmabile (si veda Completamento
              programmabile più avanti).
       EMACS  Se bash trova questa variabile d’ambiente  alla  partenza  della
              shell  col valore "t", presume che la shell sia in esecuzione in
              un buffer di shell emacs e disabilita la modifica della riga.
       FCEDIT L’editor di default per il comando incorporato fc.
       FIGNORE
              Una lista di suffissi, separati da due punti, da ignorare quando
              si  effettua il completamento del nome di file (si veda READLINE
              più avanti).  Un nome di file il cui suffisso corrisponde a  una
              delle  voci  in  FIGNORE  è escluso dalla lista dei nomi di file
              individuati.  Un valore di esempio è ".o:~".
       GLOBIGNORE
              Una lista di modelli, separati da  due  punti,  che  definiscono
              l’insieme dei nomi di file che l’espansione del nome di percorso
              deve ignorare.  Se un nome di file individuato da un modello  di
              espansione  del  percorso corrisponde anche a uno dei modelli in
              GLOBIGNORE, viene rimosso dalla lista dei nomi da individuare.
       HISTCONTROL
              Una lista di valori, separati da due punti, che controllano come
              i  comandi  vengono salvati nell’elenco della cronologia.  Se la
              lista di valori include ignorespace, le righe che  iniziano  con
              un  carattere  di  spazio  non vengono salvate nell’elenco della
              cronologia.  Un valore di ignoredups fa sì che non venga salvata
              ogni  riga  uguale all’elemento precedente della cronologia.  Un
              valore  di  ignoreboth  è  la  combinazione  di  ignorespace   e
              ignoredups.   Un  valore  di  erasedups fa sì che tutte le righe
              uguali alla riga  corrente  vengano  rimosse  dall’elenco  della
              cronologia  prima  che  la riga venga salvata.  Qualsiasi valore
              che non è nella lista di cui sopra è ignorato.   Se  HISTCONTROL
              viene  annullato  o non include un valore valido, tutte le righe
              lette dall’analizzatore  sintattico  della  shell  sono  salvate
              nell’elenco   della   cronologia,  a  meno  che  non  sia  stato
              specificato HISTIGNORE.  La seconda riga e le successive  di  un
              comando  composto  multiriga  non  vengono  controllate,  e sono
              aggiunte  alla  cronologia  indipendentemente  dal   valore   di
              HISTCONTROL.
       HISTFILE
              Il  nome  del file nel quale è salvata la cronologia dei comandi
              (si veda CRONOLOGIA più avanti).   Il  valore  predeterminato  è
              ~/.bash_history.  Se è annullato la cronologia dei comandi non è
              salvata al termine di una shell interattiva.
       HISTFILESIZE
              Il numero massimo di righe contenute nel file della  cronologia.
              Quando  a  questa variabile è assegnato un valore, il file della
              cronologia è accorciato, se necessario, rimuovendo le  voci  più
              vecchie,  per  contenere  non  più  di quel numero di righe.  Il
              valore di default è 500.  Il file  della  cronologia  è  inoltre
              troncato a questa dimensione dopo la scrittura al termine di una
              shell interattiva.
       HISTIGNORE
              Una lista di modelli separati da due punti  usata  per  decidere
              quali  righe  di comando devono essere salvate nell’elenco della
              cronologia.  Ogni modello comincia all’inizio della riga e  deve
              corrispondere   alla  riga  completa  (nessun  ‘*’  implicito  è
              aggiunto).  Ogni modello è confrontato con la riga  dopo  che  i
              controlli  specificati  da HISTCONTROL sono stati applicati.  In
              aggiunta ai normali modelli di shell che confrontano  caratteri,
              ‘&’  designa  la  linea  precedente  della  cronologia.  ‘&’ può
              essere protetto usando un  backslash;  il  backslash  è  rimosso
              prima di eseguire un confronto.  La seconda riga e le successive
              di un comando composto multiriga non vengono controllate, e sono
              aggiunte   alla   cronologia  indipendentemente  dal  valore  di
              HISTIGNORE.
       HISTSIZE
              Il numero di comandi da memorizzare nella cronologia dei comandi
              (si veda CRONOLOGIA più avanti).  Il valore di default è 500.
       HISTTIMEFORMAT
              Se  questa  variabile  è  impostata e non nulla, il suo valore è
              usato come stringa  di  formato  per  strftime(3)  per  stampare
              l’informazione   "data  e  ora"  associata  a  ogni  voce  della
              cronologia mostrata dal comando incorporato history.  Se  questa
              variabile  è  impostata,  data  e  ora verranno scritte nel file
              della  cronologia  in  modo  da  essere  disponibili  anche   in
              successive sessioni della shell.
       HOME   La  home  directory dell’utente corrente; l’argomento di default
              per il comando incorporato cd.  Il valore di questa variabile  è
              anche usata quando si effettua l’espansione della tilde.
       HOSTFILE
              Contiene  il  nome di un file nello stesso formato di /etc/hosts
              che dovrà essere letto quando la shell ha bisogno di  completare
              un  nome  di host.  La lista dei possibili completamenti di nome
              di host può essere cambiata mentre la  shell  è  in  esecuzione;
              alla  prossima  occasione  in  cui si tenta il completamento del
              nome di host dopo che è cambiato il  valore,  bash  aggiunge  il
              contenuto  del  nuovo  file alla lista esistente.  Se HOSTFILE è
              impostato  ma  non  ha  alcun  valore,  bash  tenta  di  leggere
              /etc/hosts per ottenere la lista dei possibili completamenti del
              nome di host.  Quando HOSTFILE viene  annullato,  la  lista  dei
              nomi di host viene pure annullata.
       IFS    L’  Internal  Field  Separator  (separatore  di campo interno) è
              usato per la suddivisione in  parole  dopo  l’espansione  e  per
              dividere  le  righe  in  parole  quando  si  esegue  il  comando
              incorporato    read.      Il     valore     di     default     è
              ‘‘<space><tab><newline>’’.
       IGNOREEOF
              Controlla  l’azione  della  shell al ricevimento di un carattere
              EOF come unico contenuto di una riga di input.  Se impostato, il
              valore  è il numero di caratteri EOF consecutivi da battere come
              primo carattere su una riga di input prima che bash esca.  Se la
              variabile  esiste  ma  non ha un valore numerico, o non ha alcun
              valore, il valore di default è 10.  Se non esiste, EOF indica la
              fine dell’input per la shell.
       INPUTRC
              Il nome di file per il file di avvio di readline che prevale sul
              valore di  default  che  è  ~/.inputrc  (si  veda  READLINE  più
              avanti).
       LANG   Usata   per  determinare  la  categoria  di  localizzazione  per
              qualsiasi categoria  non  specificatamente  specificata  da  una
              delle variabili che iniziano con LC_.
       LC_ALL Questa variabile prevale sul valore di LANG e su qualsiasi altra
              variabile LC_ che specifichi una categoria di localizzazione.
       LC_COLLATE
              Questa variabile determina l’ordine di collazione  usato  quando
              vengono   ordinati   i  risultati  dell’espansione  di  nome  di
              percorso,  e  determina  il  comportamento  di  espressioni   di
              intervallo,  classi  di  equivalenza  e  sequenze di ordinamento
              all’interno  dell’espansione  di  nome  di  percorso   e   della
              corrispondenza tra stringhe.
       LC_CTYPE
              Questa  variabile  determina l’interpretazione di caratteri e il
              comportamento di classi di caratteri all’interno dell’espansione
              di nome di percorso e della corrispondenza tra stringhe.
       LC_MESSAGES
              Questa  variabile determina la localizzazione usata per tradurre
              stringhe tra virgolette precedute da un $.
       LC_NUMERIC
              Questa variabile determina la categoria di localizzazione  usata
              per la formattazione dei numeri.
       LINES  Usato  dal  comando incorporato select per determinare il numero
              di linee del terminale nella stampa delle  liste  di  selezione.
              Automaticamente   re-impostata  al  ricevimento  di  un  segnale
              SIGWINCH.
       MAIL   Se questo parametro è impostato a un nome di file e la variabile
              MAILPATH  non  è impostata, bash informa l’utente dell’arrivo di
              posta nel file specificato.
       MAILCHECK
              Specifica la frequenza (in secondi) con cui  bash  controlla  la
              posta.   Il valore di default è 60 secondi.  Quando è il momento
              di controllare la posta, la shell lo fa  prima  di  mostrare  il
              prompt  primario.   Se  questa  variabile  non  è impostata, o è
              impostata a un valore che non sia un numero maggiore o uguale  a
              zero, la shell disabilita il controllo della posta.
       MAILPATH
              Una lista di nomi di file separati da due punti, da usare per il
              controllo della posta.  Il messaggio che  deve  essere  stampato
              all’arrivo  dei  messaggi  in  un  particolare  file  può essere
              specificato separando il nome del file dal messaggio con un ‘?’.
              Quando  viene usato nel testo del messaggio $_ è espanso al nome
              del file di posta corrente.  Per esempio:
              MAILPATH='/var/mail/bfox?"You  have  mail":~/shell-mail?"$_  has
              mail!"'
              Bash  fornisce  un valore di default per questa variabile, ma il
              posizionamento dei file  di  posta  degli  utenti  utilizzato  è
              dipendente dal sistema (per esempio, /var/mail/$USER).
       OPTERR Se  impostato  al  valore  1,  bash  mostra i messaggi di errore
              generati  dal  comando  incorporato  getopts  (si  veda  COMANDI
              INCORPORATI  DELLA SHELL più avanti).  OPTERR è inizializzato ad
              1 ogni volta che viene invocata la shell o  viene  eseguito  uno
              script di shell.
       PATH   Il  percorso  di  ricerca  dei comandi. È un elenco di directory
              separate da due punti, nelle quali la shell cerca i comandi  (si
              veda  ESECUZIONE  DEI COMANDI più avanti).  Un nome di directory
              di lunghezza zero (nulla) nel valore di PATH indica la directory
              corrente.   Un  nome  di  directory  nullo può apparire come una
              serie di due punti adiacenti, o come due punti all’inizio o alla
              fine.   Il  percorso  di  default  è dipendente dal sistema ed è
              impostato dall’amministratore  che  installa  bash.   Un  valore
              frequente                                                      è
              ‘‘/usr/gnu/bin:/usr/local/bin:/usr/ucb:/bin:/usr/bin’’.
       POSIXLY_CORRECT
              Se  questa  variabile  è  presente  nell’ambiente  quando  viene
              avviata  bash, la shell entra in modalit posix prima di leggere
              i file di avvio, come se l’opzione di invocazione --posix  fosse
              stata  specificata.   Se  è  impostata  mentre  la  shell  è  in
              esecuzione, bash abilita la modalit posix, come se  il  comando
              set -o posix fosse stato eseguito.
       PROMPT_COMMAND
              Se  impostato,  il  valore è eseguito ogni volta come un comando
              prima di scrivere il prompt primario.
       PS1    Il valore di questo parametro è espanso  (si  veda  STRINGHE  DI
              PROMPT più avanti) e usato come stringa del prompt primario.  Il
              valore di default è‘‘\s-\v\$ ’’.
       PS2    Il valore di questo parametro è espanso allo stesso modo di  PS1
              ed  è  usato  come  stringa  di prompt secondario.  Il valore di
              default è ‘‘> ’’.
       PS3    Il valore di questo parametro è usato come prompt per il comando
              select (si veda GRAMMATICA DELLA SHELL sopra).
       PS4    Il  valore di questo parametro è espanso allo stesso modo di PS1
              ed il valore è stampato prima di ogni comando  che  bash  mostra
              durante  un  trace  di  esecuzione.  Il primo carattere di PS4 è
              replicato tante volte, quanto necessario, per  indicare  livelli
              multipli di indirezione.  Il valore di default è ‘‘+ ’’.
       SHELL  In  questa variabile d’ambiente è contenuto il percorso completo
              della shell.  Se non è impostata quando la shell viene  avviata,
              bash  le  assegna  il  percorso  completo  della  shell di login
              dell’utente corrente.
       TIMEFORMAT
              Il valore di questo parametro è usato come  stringa  di  formato
              per  specificare  come  dovrà  essere mostrata l’informazione su
              data e ora per pipeline aventi come prefisso la parola riservata
              time  Il carattere % introduce una sequenza di formattazione che
              è espansa a un valore di data e ora o ad altre informazioni.  Le
              sequenze di formattazione e il loro significato sono i seguenti;
              le parentesi quadre denotano parti opzionali.
              %%        Una % letterale.
              %[p][l]R  Il tempo trascorso in secondi.
              %[p][l]U  Il numero di secondi di utilizzo della CPU in modalità
                        utente.
              %[p][l]S  Il numero di secondi di utilizzo della CPU in modalità
                        sistema.
              %P        La percentuale di utilizzo della CPU,  calcolata  come
                        (%U + %S) / %R.

              La parte opzionale p è una cifra che specifica la precisione, il
              numero di cifre frazionali  dopo  il  separatore  decimale.   Un
              valore  pari a 0 fa sì che nessun separatore decimale o frazione
              venga  inserito  nell’output.   Possono  essere  specificate  al
              massimo  tre  posizioni dopo il separatore decimale; valori di p
              maggiori di 3 sono cambiati a 3.   Se  p  non  è  specificato  è
              utilizzato il valore 3.

              La  parte  opzionale l specifica un formato più lungo, inclusi i
              minuti, nella forma MMmSS.FFs.  Il valore di p determina  se  la
              frazione è inclusa o meno.

              Se  questa variabile non è impostata, bash agisce come se avesse
              il valore $'\nreal\t%3lR\nuser\t%3lU\nsys%3lS'.  Se il valore  è
              nullo,  non  viene  mostrata  alcuna informazione di tempo.  Una
              newline finale  è  aggiunta  quando  la  stringa  di  formato  è
              visualizzata.

       TMOUT  Se impostato a un valore maggiore di zero, TMOUT è trattato come
              il tempo limite (timeout) di default per il comando  incorporato
              read.   Il  comando   select viene terminato se non riceve input
              dopo TMOUT secondi quando l’input è chiesto a un terminale.   In
              una shell interattiva il valore è interpretato come il numero di
              secondi di  attesa  per  l’input  dopo  l’emissione  del  prompt
              primario.    Se  l’input  non  arriva  Bash  termina  dopo  aver
              aspettato per quel numero di secondi.

       TMPDIR Se impostato, Bash usa il suo valore come nome  della  directory
              nella quale Bash crea file temporanei a uso della shell.

       auto_resume
              Questa  variabile controlla il modo con cui la shell interagisce
              con l’utente e  con  il  job-control.   Se  questa  variabile  è
              impostata,  dei  comandi  semplici  composti  da una sola parola
              senza ridirezioni sono considerati come candidati per la ripresa
              di  un job in esecuzione che sia stato sospeso.  Non è possibile
              alcuna ambiguità; se vi è più di un  job  che  comincia  con  la
              stringa  digitata,  è  scelto  il  job  su  cui  si è effettuato
              l’accesso più recentemente.  Il  nome  di  un  job  sospeso,  in
              questo  contesto,  è  la riga di comando usata per avviarlo.  Se
              impostato al  valore  exact,  la  stringa  fornita  deve  essere
              esattamente  uguale  al  nome  di  un  job fermo; se impostato a
              substring, la stringa fornita deve combaciare con una substringa
              del  nome  di  un  job  sospeso.   Il  valore substring fornisce
              funzionalità analoghe all’identificatore del job  %?   (si  veda
              JOB CONTROL più avanti).  Se impostato a qualsiasi altro valore,
              la stringa fornita deve essere un prefisso del nome  di  un  job
              sospeso;      questo      consente     funzionalità     analoghe
              all’identificatore di job %string

       histchars
              Sono i due o tre caratteri che  controllano  l’espansione  della
              cronologia  e la suddivisione in token (si veda ESPANSIONE DELLA
              CRONOLOGIA più avanti).  Il primo carattere è  il  carattere  di
              espansione  della  cronologia, il carattere che segnala l’inizio
              di una espansione della cronologia, normalmente ‘!’.  Il secondo
              carattere  è  il  carattere  di sostituzione rapida, che è usato
              come  scorciatoia  per  rieseguire  il  comando  precedentemente
              inserito,  sostituendo una stringa con un’altra nel comando.  Il
              valore di default è ‘^’.  Il terzo carattere,  opzionale,  è  il
              carattere  che  indica  che  il  resto della riga è un commento,
              quando è trovato come primo carattere di una parola, normalmente
              ‘#’.   Il  carattere  di  commento della cronologia fa sì che la
              sostituzione della cronologia venga  saltata  per  le  rimanenti
              parole   sulla   riga.   Esso  non  fa  necessariamente  sì  che
              l’analizzatore della shell tratti il resto della  riga  come  un
              commento.

   Array
       Bash  fornisce  variabili  array  monodimensionali.  Ogni variabile può
       essere usata come un array; il  comando  incorporato  declare  dichiara
       esplicitamente  un  array.  Non c’è un limite massimo per la dimensione
       di un array, né alcuna richiesta che gli elementi siano  indicizzati  o
       assegnati  in  modo contiguo.  Gli array sono indicizzati usando numeri
       interi e cominciano con l’indice zero.

       Un array è creato  automaticamente  se  a  una  variabile  qualsiasi  è
       assegnato  un  valore  usando  la  sintassi nome[subscript]=valore.  Il
       subscript  viene  trattato  come  un’espressione  aritmetica  che  deve
       risultare   un  numero  maggiore  o  uguale  a  zero.   Per  dichiarare
       esplicitamente un  array,  usare  declare  -a  nome  (si  veda  COMANDI
       INCORPORATI  DI  SHELL  più  avanti).  È  anche  accettato  declare  -a
       nome[subscript] ; il subscript viene ignorato.  Per una variabile array
       possono  essere  specificati  degli  attributi  utilizzando  i  comandi
       incorporati declare e readonly .  Ogni attributo si applica a tutti gli
       elementi di un array.

       Agli  elementi  dell’array vengono assegnati valori usando assegnamenti
       composti della forma nome=(valore1 ... valoren),  dove  ogni  valore  è
       della  forma [subscript]=stringa. È richiesto solo stringa.  Se vengono
       fornite  le  parentesi  opzionali  e  il  subscript,  l’elemento  viene
       assegnato a quell’indice; altrimenti l’indice dell’elemento assegnato è
       l’ultimo indice già  utilizzato  aumentato  di  uno.   L’indicizzazione
       parte   da  zero.   Questa  sintassi  è  accettata  anche  dal  comando
       incorporato declare .  Elementi singoli  di  un  array  possono  essere
       assegnati  con la sintassi nome[subscript]=valore introdotta più sopra.

       Qualsiasi  elemento  di  un   array   può   essere   referenziato   con
       ${nome[subscript]}.   Le parentesi sono richieste per evitare conflitti
       con l’espansione di percorso.  Se subscript è @ o *, la parola  espande
       a  a  tutti  gli  elementi di nome.  Questi subscript differiscono solo
       quando la parola appare inclusa fra virgolette.  Se la parola è quotata
       con  virgolette,  ${nome[*]} espande a una singola parola col valore di
       ogni elemento dell’array separato dal primo carattere  della  variabile
       speciale  IFS  ,  e  ${nome[@]}  espande ogni elemento di nome come una
       parola separata.  Quando non c’è  l’elemento  di  array,  ${nome[@]}  è
       espanso  alla stringa nulla.  Se l’espansione quotata con virgolette si
       trova dentro una parola, l’espansione del primo parametro è legato  con
       la  parte  iniziale  della parola originale, e l’espansione dell’ultimo
       parametro è legato con l’ultima parte della parola originale.  Questo è
       analogo  all’espansione dei parametri speciali * e @ (si veda Parametri
       speciali  sopra).  ${#nome[subscript]}  espande   alla   lunghezza   di
       ${nome[subscript]}.   Se subscript è * o @, l’espansione è il numero di
       elementi  dell’array.    Referenziare   una   variabile   array   senza
       specificare  un subscript equivale a referenziare il suo elemento zero.

       Il comando incorporato unset è usato per  annullare  gli  array.  unset
       nome[subscript]   annulla  l’elemento  di  array  a  indice  subscript.
       Bisogna  stare  attenti  a  evitare  effetti  collaterali  indesiderati
       causati  dalla generazione di un nome di file.  unset nome, dove nome è
       un array, o unset nome[subscript], dove subscript  è  *  o  @,  rimuove
       l’intero array.

       Ciascuno  dei  comandi  incorporati  declare,  local e readonly accetta
       un’opzione -a per specificare un array.  Il  comando  incorporato  read
       accetta  un’opzione  -a  per  assegnare  a un array una lista di parole
       lette dallo standard  input.   I  comandi  incorporati  set  e  declare
       mostrano  i  valori  di array in modo che da essere riutilizzabili come
       assegnamenti.

ESPANSIONE

       L’espansione è effettuata sulla riga di comando dopo che essa  è  stata
       divisa  in  parole.   Vi  sono  sette  tipi  di  espansione effettuati:
       espansione delle parentesi graffe, espansione della  tilde,  espansione
       di   parametro   e   variabile,  sostituzione  di  comando,  espansione
       aritmetica, suddivisione in parole ed espansione di percorso.

       L’ordine di espansione è: espansione delle parentesi graffe, espansione
       della  tilde,  espansione  di  parametro,  di  variabile e aritmetica e
       sostituzione di comando (fatta da sinistra a destra),  suddivisione  in
       parole ed espansione di percorso.

       Sui  sistemi che la supportano, è disponibile un’espansione aggiuntiva:
       la sostituzione di processo.

       Solo l’espansione delle parentesi graffe, la suddivisione in  parole  e
       l’espansione   di   percorso  possono  cambiare  il  numero  di  parole
       dell’espansione; le altre espansioni espandono una  singola  parola  in
       una  singola  parola.   La  sola  eccezione  a questo è l’espansione di
       ‘‘$@’’ e "${nome[@]}" come spiegato sopra (si veda PARAMETRI).

   Espansione delle parentesi graffe
       Espansione delle parentesi graffe è un meccanismo con il quale  possono
       essere  generate  stringhe  arbitrarie.   Questo  meccanismo  è  simile
       all’espansione di percorso, ma non è necessario che i file il cui  nome
       è  generato  esistano.   I  modelli  cui  si applica l’espansione delle
       parentesi graffe hanno la forma di un preambolo opzionale,  seguito  da
       una serie di stringhe separate da virgola o una espressione di sequenza
       racchiusa fra parentesi graffe, seguite da un’ appendice opzionale.  Il
       preambolo  è  preposto  a  ogni  stringa  contenuta dentro le parentesi
       graffe e l’appendice è poi appesa a ogni stringa risultante, espandendo
       da sinistra a destra.

       Le  espansioni  delle  parentesi  graffe possono essere nidificate.  Il
       risultato di ogni stringa espansa  non  viene  ordinato;  è  conservato
       l’ordine  da  sinistra  a destra.  Per esempio, a{d,c,b}e si espande in
       ‘ade ace abe’.

       Un’espressione di sequenza prende la forma {x..y}, dove x e  y  sono  o
       numeri  interi  o  caratteri singoli.  Se si specificano numeri interi,
       l’espressione espande a  ogni  numero  fra  x  e  y,  incluso.   Se  si
       specificano   caratteri   l’espressione   espande   a   ogni  carattere
       lessicograficamente compreso  fra  x  e  y,  incluso.   Da  notare  che
       entrambi x e y devono essere dello stesso tipo.

       L’espansione  delle  parentesi  graffe  è effettuata prima di qualsiasi
       altra espansione, e qualunque carattere speciale  per uso  delle  altre
       espansioni  viene  lasciato com’era nel risultato.  Essa è strettamente
       testuale.   Bash  non  applica  alcuna  interpretazione  sintattica  al
       contesto dell’espansione o al testo tra parentesi graffe.

       Un’espansione   delle   parentesi  graffe  correttamente  formata  deve
       contenere una parentesi graffa di  apertura  e  una  di  chiusura,  non
       quotate,  e almeno una virgola non quotata.  Qualunque espansione delle
       parentesi graffe erroneamente formata è lasciata inalterata.  Una { o ,
       può  essere  quotata con un backslash per evitare che venga considerata
       parte di un’espressione fra parentesi graffe.   Per  evitare  conflitti
       con   l’espansione   di   parametro,   la   stringa  ${  non  dà  luogo
       all’espansione delle parentesi graffe.

       Questo costrutto è  tipicamente  usato  come  abbreviazione  quando  il
       prefisso comune delle stringhe da generare è più lungo che negli esempi
       sopra:

              mkdir /usr/local/src/bash/{old,new,dist,bugs}
       o
              chown root /usr/{ucb/{ex,edit},lib/{ex?.?*,how_ex}}

       L’espansione delle parentesi graffe introduce una lieve incompatibilità
       con  le versioni tradizionali di sh.  sh non tratta le parentesi graffe
       aperte e chiuse, specialmente quando esse appaiono come  parte  di  una
       parola,  e  le  conserva  in  uscita.  Bash rimuove le parentesi graffe
       dalle parole come consequenza dell’espansione delle  parentesi  graffe.
       Per  esempio,  una  parola  data  a  sh  come file{1,2} appare identica
       nell’output.  La stessa parola è data in output come file1  file2  dopo
       l’espansione operata da bash.

       Se  si  desidera  una  stretta  compatibilità  con sh si avvia bash con
       l’opzione +B o si disabilita l’espansione delle  parentesi  graffe  con
       l’opzione  +B  al  comando set (si veda COMANDI INCORPORATI DELLA SHELL
       più avanti).

   Espansione della tilde
       Se una parola comincia con un carattere tilde (‘~’) non quotato,  tutti
       i  caratteri  che  precedono  la prima barra [/] non quotata (o tutti i
       caratteri, se non vi è  alcuna  barra)  sono  considerati  un  prefisso
       tilde.   Se  nessuno  dei  caratteri  nel  prefisso  tilde è quotato, i
       caratteri nel prefisso tilde che segue la tilde sono trattati  come  un
       possibile  nome  di login.  Se questo nome di login è la stringa nulla,
       la tilde è sostituita con il valore del parametro HOME.  Se HOME  viene
       annullato,  è  invece  sostituita la home directory dell’utente che sta
       eseguendo la shell.  Altrimenti, il prefisso tilde è sostituito con  la
       home directory associata al nome di login specificato.

       Se  il  prefisso tilde è un ‘~+’ il valore della variabile di shell PWD
       sostituisce il prefisso tilde.  Se il prefisso  tilde  è  un  ‘~-’,  il
       valore della variabile di shell OLDPWD, se impostato, viene sostituito.
       Se il carattere che segue la tilde nel prefisso tilde è  un  numero  N,
       con  un  prefisso opzionale  ‘+’ o  ‘-’, il prefisso tilde è sostituito
       dal corrispondente elemento dallo stack  di  directory,  come  dovrebbe
       essere  mostrato  dal  comando  incorporato  dirs invocato col prefisso
       tilde come argomento.  Se il carattere che segue la tilde nel  prefisso
       tilde  è  un  numero non preceduto da un segno ‘+’ o ‘-’, viene assunto
       ‘+’

       Se il nome di login non è valido o  l’espansione  della  tilde  non  ha
       successo, la parola rimane invariata.

       Ogni  assegnamento  di  variabile  è controllato per prefissi tilde non
       quotati che seguono immediatamente un : o il primo =.  In  questi  casi
       viene  effettuata l’espansione della tilde.  Di conseguenza, si possono
       usare nomi di file con delle tilde negli assegnamenti a PATH, MAILPATH,
       e CDPATH, e la shell assegna il valore espanso.

   Espansione di parametro
       Il  carattere  ‘$’ introduce l’espansione di parametro, la sostituzione
       di comando, o l’espansione aritmetica.  Il nome o simbolo del parametro
       che  dev’essere  espanso può essere racchiuso tra parentesi graffe, che
       sono opzionali ma servono a proteggere la  variabile  che  deve  essere
       espansa  dai  caratteri  immediatamente seguenti, che potrebbero essere
       interpretati come parte del nome [della variabile stessa].

       Quando vengono usate le parentesi graffe, la  parentesi  graffa  finale
       corrispondente  è  la  prima  ‘}’  non  protetta  da  un backslash o da
       stringhe quotate, e non parte di un’espansione aritmetica  inclusa,  di
       una sostituzione di comando o di un’espansione di parametro.

       ${parametro}
              Il  valore  di parametro è sostituito.  Le parentesi graffe sono
              richieste quando parametro è un parametro posizionale con più di
              una cifra [ossia 10 e oltre], o quando parametro è seguito da un
              carattere che non deve essere interpretato come  parte  del  suo
              nome.

       Se il primo carattere di parametro è un punto esclamativo, è introdotto
       un livello di indirezione della variabile.  Bash usa  il  valore  della
       variabile  formata  dal  resto  del  parametro  come nome di variabile;
       questa variabile è poi espansa e quel valore è usato  nel  resto  della
       sostituzione,  piuttosto  che  il valore stesso di parametro.  Questa è
       conosciuta come espansione indiretta.   Le  eccezioni  a  ciò  sono  le
       espansioni  di  ${!prefisso*}  e  ${!nome[@]} descritte più avanti.  Il
       punto esclamativo  deve  seguire  immediatamente  la  parentesi  graffa
       iniziale per introdurre l’indirezione.

       In  ognuno  dei  casi  sotto  riportati, parola è soggetta a espansione
       della tilde,  espansione  di  parametro,  sostituzione  di  comando  ed
       espansione  aritmetica.   Quando non sta effettuando l’espansione della
       substringa, Bash controlla se un parametro non è impostato o  è  nullo;
       l’omissione dei due punti provoca il solo controllo di un parametro non
       impostato.

       ${parametro:-parola}
              Usa i valori di default.  Se  parametro  non  è  impostato  o  è
              nullo,  è  sostituita  l’espansione  di  parola.  Altrimenti, il
              valore di parametro è sostituito
       ${parametro:=parola}
              Assegna i valori di default.  Se parametro non è impostato  o  è
              nullo,  l’espansione  di  parola  è  assegnata  a parametro.  Il
              valore  di  parametro  è   quindi   sostituito.    I   parametri
              posizionali  e i parametri speciali non possono essere assegnati
              in questo modo.
       ${parametro:?parola}
               una segnalazione di errore se è nullo o  è  stato  annullato.
              Se parametro è nullo o è stato annullato, l’espansione di parola
              (o un messaggio di segnalazione, se parola non è presente) viene
              scritta  sullo  standard error e la shell, se non è interattiva,
              termina.  Altrimenti, è sostituito il valore di parametro.
       ${parametro:+parola}
              Usa un valore alternativo.  Se  parametro  è  nullo  o  è  stato
              annullato,  non  è  sostituito  niente,  altrimenti è sostituita
              l’espansione di parola .
       ${parametro:offset}
       ${parametro:offset:lunghezza}
              Espansione di substringa.  Espande i caratteri di parametro fino
              a  lunghezza  partendo  dal carattere specificato da offset.  Se
              lunghezza viene omesso, espande  alla  substringa  di  parametro
              partendo  dal  carattere  specificato  da  offset.   lunghezza e
              offset  sono  espressioni  aritmetiche  (si   veda   VALUTAZIONE
              ARITMETICA   più  avanti).   lunghezza  deve  essere  un  numero
              maggiore o uguale a zero.  Se offset è un numero minore di zero,
              il  valore  viene  usato come un offset dalla fine del valore di
              parametro.  Se parametro è  @,  il  risultato  è  un  numero  di
              parametri  posizionali pari a lunghezza a partire da offset.  Se
              parametro è un nome di array indicizzato da @ o *, il  risultato
              è un numero di elementi dell’array pari a lunghezza a partire da
              ${parametro[offset]}.  Un offset negativo è inteso come relativo
              al  massimo  indice  dell’array  specificato  aumentato  di uno.
              Notare che un offset negativo dev’essere separato dai due  punti
              da   almeno  uno  spazio  per  evitare  di  essere  confuso  con
              l’espansione di :- .  L’indicizzazione della substringa è a base
              zero  a  meno che non vengano usati i parametri posizionali, nel
              qual caso l’indicizzazione parte da 1.

       ${!prefisso*}
       ${!prefisso@}
              Espande  ai  nomi  delle  variabili  i  cui  nomi  iniziano  con
              prefisso,  separati dal primo carattere della variabile speciale
              IFS

       ${!nome[@]}
       ${!nome[*]}
              Se nome è una variabile  di  array,  espande  alla  lista  degli
              indici  di  array  (chiavi) assegnati in nome.  Se nome non è un
              array, espande a 0 se nome  è  impostato  ed  è  nullo  in  caso
              contrario.    Quando   @  è  usato  e  l’espansione  appare  fra
              virgolette, ogni chiave espande a una parola separata.

       ${#parametro}
              È sostituita la lunghezza in caratteri del valore di  parametro.
              Se  parametro  è  *  o  @,  il  valore sostituito è il numero di
              parametri  posizionali.   Se  parametro  è  un  nome  di   array
              contrassegnato  da  *  o  @, il valore sostituito è il numero di
              elementi nell’array.

       ${parametro#parola}
       ${parametro##parola}
              La parola  è  espansa  per  produrre  un  modello  proprio  come
              nell’espansione   di   percorso.    Se   il  modello  trova  una
              corrispondenza con l’inizio del valore di parametro,  allora  il
              risultato  dell’espansione  è il valore espanso di parametro con
              il più corto dei modelli che corrispondono cancellato (nel  caso
              di  ‘‘#’’  )  o  il  più  lungo  dei  modelli  che corrispondono
              cancellato (nel caso di  ‘‘##’’  ).   Se  parametro  è  @  o  *,
              l’operazione  di  rimozione  del modello è applicata di volta in
              volta a ogni parametro posizionale, e l’espansione  è  la  lista
              che  ne  risulta.   Se  parametro  è  una variabile di array con
              indice @ o *, l’operazione di rimozione del modello è  applicata
              a  ognuno  degli  elementi dell’array, e l’espansione è la lista
              risultante.

       ${parametro%parola}
       ${parametro%%parola}
              La parola  è  espansa  per  produrre  un  modello  proprio  come
              nell’espansione  di  percorso.   Se il modello corrisponde a una
              parte finale del  valore  espanso  di  parametro,  il  risultato
              dell’espansione  è  il  valore  espanso  di parametro con il più
              corto dei modelli corrispondenti cancellato (nel caso di ‘‘%’’ )
              o  il  più lungo dei modelli corrispondenti cancellato (nel caso
              di ‘‘%%’’).  Se parametro è @ o *, l’operazione di rimozione del
              modello  è  applicata  a  ognuno  dei  parametri  posizionali, e
              l’espansione  è  la  lista  risultante.   Se  parametro  è   una
              variabile  di  array con indice @ o *, l’operazione di rimozione
              del modello è applicata a ognuno degli  elementi  dell’array,  e
              l’espansione è la lista risultante.

       ${parametro/modello/stringa}
              Il  modello  è  espanso  per  produrre  un  modello proprio come
              nell’espansione di percorso.   Parametro  è  espanso  e  il  suo
              valore  più  lungo  che  corrisponde  a modello è sostituito con
              stringa.  Se modello comincia con /, tutte le corrispondenze  di
              modello   sono   sostituite   con  stringa.   Normalmente  viene
              sostituita solo la prima corrispondenza.   Se  modello  comincia
              con  #,  deve  corrispondere  all’inizio  del  valore espanso di
              parametro.  Se modello inizia con  %,  deve  corrispondere  alla
              fine  del  valore  espanso di parametro.  Se stringa è nulla, le
              corrispondenze di modello sono  cancellate  e  la  /  che  segue
              modello  può  essere omessa.  Se parametro è @ o *, l’operazione
              di sostituzione è applicata a ognuno dei parametri  posizionali,
              e  l’espansione  è  la  lista  risultante.   Se  parametro è una
              variabile  di  array  con  indice  @  o   *,   l’operazione   di
              sostituzione  è  applicata a ognuno degli elementi dell’array, e
              l’espansione è la lista risultante.

   Sostituzione di comando
       La  sostituzione  di  comando  permette  che  l’output  di  un  comando
       rimpiazzi il nome del comando.  Vi sono due forme:

              $(comando)
       o
              ‘comandoBash  effettua  l’espansione  eseguendo  il  comando  e rimpiazzando la
       sostituzione di comando con lo standard output del  comando,  con  ogni
       newline finale cancellato.  I newline intermedi non vengono cancellati,
       ma possono essere  rimossi  durante  la  suddivisione  in  parole.   La
       sostituzione   di   comando   $(cat   file)   può   essere   sostituita
       dall’equivalente ma più veloce $(< file).

       Quando è usata la forma di sostituzione in vecchio stile con gli  apici
       rovesciati,  il  backslash conserva il suo significato letterale tranne
       quando è seguito da $, ‘ o \.  Il primo apice rovesciato non  preceduto
       da un backslash fa terminare la sostituzione di comando.  Quando si usa
       la forma $(comando), tutti i caratteri  tra  le  parentesi  formano  il
       comando; nessuno è considerato speciale.

       La  sostituzione  di  comando  può  essere  nidificata.  Per nidificare
       quando si usa la forma con gli apici rovesciati, bisogna far  precedere
       gli  apici  rovesciati  più  interni  con  un  carattere  backslash  di
       protezione.

       Se la sostituzione appare tra virgolette, la suddivisione in  parole  e
       l’espansione di percorso non sono effettuate sui risultati.

   Espansione aritmetica
       L’espansione  aritmetica  permette  la  valutazione  di una espressione
       aritmetica  e  la  sostituzione  del   risultato.    Il   formato   per
       l’espansione aritmetica è:

              $((espressione))

       L’  espressione  è  trattata  come  se  fosse  tra  virgolette,  ma  le
       virgolette dentro le parentesi non  sono  trattate  in  modo  speciale.
       Tutti  i  token  dell’espressione  sono  assoggettati  a  espansione di
       parametro, espansione di stringa, sostituzione di comando  e  rimozione
       dei  caratteri  di quotatura.  Le espansioni aritmetiche possono essere
       nidificate.

       Il calcolo è effettuato in accordo con le regole  elencate  più  avanti
       sotto VALUTAZIONE ARITMETICA.  Se espressione non è valida, bash stampa
       un  messaggio  che  indica  l’errore  e  non  viene  effettuata  alcuna
       sostituzione.

   Sostituzione di processo
       La  sostituzione  di processo è supportata su sistemi che supportano le
       named pipe (FIFO) o il metodo /dev/fd per  denominare  i  file  aperti.
       Essa  prende  la  forma di <(lista) o >(lista).  La lista di processi è
       eseguita con il suo input o output connesso a un FIFO o ad alcuni  file
       in /dev/fd.  Il nome di questo file è passato come argomento al comando
       corrente come risultato dell’espansione.  Se è usata la forma >(lista),
       la scrittura sul file fornisce input per la lista.  Se è usata la forma
       <(lista), il file passato come  argomento  dovrebbe  essere  letto  per
       ottenere l’output di lista.

       Su  sistemi che la supportano, la sostituzione di processo è effettuata
       allo stesso momento dell’espansione di parametro e di variabile,  della
       sostituzione di comando e dell’espansione aritmetica.

   Suddivisione in parole
       La   shell   scandisce   il  risultato  dell’espansione  di  parametro,
       sostituzione di comando ed espansione aritmetica che non si trovano tra
       virgolette, per effettuare la suddivisione in parole.

       La shell tratta ogni carattere di IFS come un delimitatore, e suddivide
       in parole, in corrispondenza con uno di questi caratteri,  i  risultati
       delle  altre  espansioni.  Se il valore di IFS non è impostato o il suo
       valore è  esattamente  <space><tab><newline>,  il  valore  di  default,
       qualsiasi sequenza di caratteri IFS serve per delimitare le parole.  Se
       IFS ha un valore diverso da  quello  di  default,  allora  sequenze  di
       caratteri  di  spaziatura  space  e tab sono ignorate all’inizio e alla
       fine della parola, se il carattere di spaziatura è presente nel  valore
       di  IFS  (un carattere di spaziatura IFS ).  Qualunque carattere in IFS
       che non è  un  carattere  di  spaziatura  IFS,  insieme  con  qualsiasi
       carattere di spaziatura IFS adiacente, delimita un campo.  Una sequenza
       di caratteri di spaziatura IFS è anche trattata come  un  delimitatore.
       Se il valore di IFS è nullo, non avviene alcuna suddivisione in parole.

       Argomenti esplicitamente nulli("" or '')  sono  conservati.   Argomenti
       non   quotati   implicitamente  nulli,  risultanti  dall’espansione  di
       parametri con valore nullo, sono rimossi.  Se un parametro  con  valore
       nullo  è  espanso  fra  virgolette,  è considerato un argomento nullo e
       viene rimosso.

       È da notare che se non avviene alcuna espansione non  viene  effettuata
       alcuna suddivisione.

   Espansione di percorso
       Dopo  la  suddivisione  in  parole,  a meno che non sia stata impostata
       l’opzione -f, bash scandisce ogni parola alla ricerca di caratteri *, ?
       e  [.   Se  uno  di  questi  caratteri  è  presente, allora la parola è
       considerata come un modello, e sostituita  con  una  lista,  in  ordine
       alfabetico,  di  nomi  di file che corrispondono al modello.  Se nessun
       nome di  file  corrispondente  viene  trovato,  e  l’opzione  di  shell
       nullglob è disabilitata, la parola è lasciata inalterata.  Se l’opzione
       nullglob è impostata, e nessuna corrispondenza è trovata, la  parola  è
       rimossa.   Se  l’opzione  di  shell  failglob  è impostata, e non viene
       trovata alcuna corrispondenza, viene stampato un messaggio di errore  e
       il  comando  non  viene  eseguito.   Se l’opzione di shell nocaseglob è
       abilitata, il confronto è effettuato senza distinzione fra maiuscole  e
       minuscole  nei  caratteri  alfabetici.   Quando  un modello è usato per
       l’espansione di percorso, il carattere ‘‘.’’  all’inizio di un  nome  o
       immediatamente   dopo   una   barra   [/]   deve   essere   confrontato
       esplicitamente,  a  meno  che  l’opzione  di  shell  globdot  non   sia
       impostata.   Quando  si  confronta  un percorso, il carattere barra [/]
       deve sempre essere confrontato esplicitamente.  Negli  altri  casi,  il
       carattere   ‘‘.’’    non  è  trattato  in  modo  speciale.   Vedere  la
       descrizione di shopt più avanti sotto COMANDI INCORPORATI  DELLA  SHELL
       per  una  descrizione  delle  opzioni  di  shell  nocaseglob, nullglob,
       failglob e dotglob .

       La variabile di shell GLOBIGNORE può essere usata  per  restringere  la
       serie  di nomi di file che corrispondono a un modello.  Se GLOBIGNORE è
       impostato, ogni nome di file da confrontare che corrisponde anche a uno
       dei   modelli  in  GLOBIGNORE  è  rimosso  dalla  lista  dei  nomi  che
       corrispondono al modello.  I nomi di file ‘‘.’’  e ‘‘..’’  sono  sempre
       ignorati   quando  GLOBIGNORE  è  impostato  e  non  nullo.   Comunque,
       impostare GLOBIGNORE a un valore non nullo ha  l’effetto  di  abilitare
       l’opzione  di  shell  dotglob  , così da cercare una corrispondenza con
       tutti gli altri nomi di file che iniziano con un ‘‘.’’  Per ottenere il
       comportamento (usato in precedenti versioni) di ignorare i nomi di file
       che iniziano con ‘‘.’’, si deve fare un modello ‘‘.*’’  in  GLOBIGNORE.
       L’opzione dotglob è disabilitata quando GLOBIGNORE viene annullato.

       Modelli di ricerca / espressioni regolari

       Ogni  carattere che appare in un modello (espressione regolare), tranne
       quelli speciali descritti qui  sotto,  corrisponde  a  se  stesso.   Il
       carattere  NULL  non  può  far  parte  di  un’espressione regolare.  Un
       backslash segnala come speciale il carattere che segue; il backslash  è
       ignorato durante il confronto.  I caratteri speciali del modello devono
       essere racchiusi tra apici se si vuole che siano considerati così  come
       sono scritti.

       I  caratteri  speciali  nelle  espressioni  regolari  hanno  i seguenti
       significati:

       *      Corrisponde a qualsiasi stringa, inclusa la stringa nulla.
       ?      Corrisponde a qualsiasi carattere singolo.
       [...]  Corrisponde  a  uno  qualsiasi  dei  caratteri   racchiusi   fra
              parentesi  quadre.  Una coppia di caratteri separati da un segno
              meno denota un’ espressione di intervallo,  che  individua  ogni
              carattere  che  si  trova  tra  quei  due caratteri, essi stessi
              inclusi, usando la sequenza di ordinamento della  localizzazione
              corrente.   Se  il primo carattere che segue il [ è un !  o un ^
              allora  qualsiasi   carattere   non   specificato   è   ritenuto
              corrispondente.    L’ordine   di   ordinamento   dei   caratteri
              nell’espressione   di    intervallo    è    determinato    dalla
              localizzazione  corrente  e  dal valore della variabile di shell
              LC_COLLATE,  se  impostata.   Un  -   può   essere   specificato
              includendolo  come  primo o ultimo carattere nella lista.  Una ]
              può essere specificata includendola come primo  carattere  nella
              lista.

              All’interno  di  [  e  ],  possono  essere specificate classi di
              caratteri usando la sintassi [:classe:], dove classe è una delle
              seguenti classi definite nello standard POSIX:
              alnum  alpha  ascii  blank  cntrl  digit graph lower print punct
              space upper word xdigit
              Una classe di caratteri trova una corrispondenza  con  qualsiasi
              carattere  appartenente a quella classe.  La classe di caratteri
              word individua lettere, cifre e il carattere _ .

              All’interno di [ e  ]  può  essere  specificata  una  classe  di
              equivalenza  con  la  sintassi  [=c=],  che  individua  tutti  i
              caratteri con lo stesso  grado  di  ordinamento  (come  definito
              dalla localizzazione corrente) del carattere c.

              All’interno di [ e ] la sintassi [.symbol.] individua il simbolo
              di ordinamento symbol.

       Se l’opzione di shell  extglob  è  abilitata  col  comando  incorporato
       shopt,  vengono  riconosciuti  diversi  operatori estesi che descrivono
       modelli.  Nella descrizione seguente, una pattern-list è una  lista  di
       uno  o  più  modelli separati da una |.  Possono essere formati modelli
       composti usando uno o più dei seguenti submodelli:

              ?(pattern-list)
                     Individua zero o una occorrenza dei modelli specificati
              *(pattern-list)
                     Individua zero o più occorrenze dei modelli specificati
              +(pattern-list)
                     Individua una o più occorrenze dei modelli specificati
              @(pattern-list)
                     Individua uno dei modelli specificati
              !(pattern-list)
                     Individua  qualsiasi  cosa  eccetto   uno   dei   modelli
                     specificati

   Rimozione dei caratteri di quotatura
       Dopo  le  precedenti  espansioni,  tutte  le occorrenze non quotate dei
       caratteri \, ' e " non originate da una delle espansioni di  cui  sopra
       sono rimosse.

RIDIREZIONE

       Prima che un comando sia eseguito, i suoi input e output possono essere
       ridiretti usando una speciale notazione interpretata dalla  shell.   La
       ridirezione  può  anche  essere  usata  per  aprire e chiudere file per
       l’ambiente di esecuzione della shell corrente.  I seguenti operatori di
       ridirezione   possono  precedere  o  apparire  in  qualsiasi  posizione
       all’interno di un comando semplice o possono venire  dopo  un  comando.
       Le ridirezioni sono elaborate nell’ordine in cui compaiono, da sinistra
       a destra.

       Nelle seguenti descrizioni, se il  numero  di  descrittore  di  file  è
       omesso,  e  il  primo  carattere  dell’operatore di ridirezione è <, la
       ridirezione si riferisce allo standard input (descrittore di  file  0).
       Se il primo carattere dell’operatore di ridirezione è >, la ridirezione
       si riferisce allo standard output (descrittore di file 1).

       La  parola  che  segue  l’operatore  di  ridirezione   nelle   seguenti
       descrizioni, se non diversamente specificato, è sottoposta a espansione
       delle  parentesi  graffe,  espansione  della   tilde,   espansione   di
       parametro,  sostituzione  di  comando, espansione aritmetica, rimozione
       dei caratteri di quotatura, espansione dei percorsi e  suddivisione  in
       parole.   Se si espande a più di una parola bash dà una segnalazione di
       errore.

       È da notare  che  l’ordine  delle  ridirezioni  è  significativo.   Per
       esempio, il comando

              ls > dirlist 2>&1

       dirige  sia  lo standard output che lo standard error sul file dirlist,
       mentre il comando

              ls 2>&1 > dirlist

       dirige solo lo standard output sul file  dirlist,  poiché  lo  standard
       error  è  stato  duplicato  come  standard output prima che lo standard
       output fosse ridiretto su dirlist.

       Bash manipola parecchi nomi di file specialmente quando sono  usati  in
       ridirezioni, come descritto nella tavola seguente:

              /dev/fd/fd
                     Se  fd  è  un  intero valido, il descrittore di file fd è
                     duplicato.
              /dev/stdin
                     Il descrittore di file 0 è duplicato.
              /dev/stdout
                     Il descrittore di file 1 è duplicato.
              /dev/stderr
                     Il descrittore di file 2 è duplicato.
              /dev/tcp/host/porta
                     Se host è un nome di host valido o un indirizzo Internet,
                     e  porta  è  un  numero  intero  di porta o il nome di un
                     servizio, bash tenta di aprire  una  connessione  TCP  al
                     socket corrispondente.
              /dev/udp/host/porta
                     Se host è un nome di host valido o un indirizzo Internet,
                     e porta è un numero intero di  porta  o  il  nome  di  un
                     servizio,  bash  tenta  di  aprire una connessione UDP al
                     socket corrispondente.

       L’insuccesso nell’aprire o creare un file determina l’insuccesso  della
       ridirezione.

       Ridirezioni  con  descrittori  di  file maggiori di 9 dovrebbero essere
       usate  con  attenzione,  poiché  possono  entrare  in   conflitto   coi
       descrittori di file usati internamente dalla shell.

   Ridirezione dellinput
       La  ridirezione  dell’input  fa  sì  che  il  file  il cui nome risulta
       dall’espansione di parola venga aperto in lettura  sul  descrittore  di
       file  n,  o  come  standard  input  (descrittore  di file 0) se n non è
       specificato.

       Il formato generico per ridirigere l’input è:

              [n]<parola

   Ridirezione delloutput
       La ridirezione dell’output fa sì  che  il  file  il  cui  nome  risulta
       dall’espansione  di parola venga aperto in scrittura sul descrittore di
       file n, o come standard output (descrittore di  file  1)  se  n  non  è
       specificato.   Se  il  file  non  esiste  viene creato; se esiste viene
       sovrascritto, come se fosse di dimensione zero.

       Il formato generico per ridirigere l’output è:

              [n]>parola

       Se l’operatore di ridirezione è >, e l’opzione  noclobber  del  comando
       incorporato set è stata abilitata, la ridirezione non ha successo se il
       file il cui nome risulta dall’espansione di parola esiste ed è un  file
       regolare.   Se  l’operatore  di  ridirezione  è  >|,  o  l’operatore di
       ridirezione è > e l’opzione noclobber del comando incorporato set non è
       abilitata,  la  ridirezione  è  tentata  anche se il file denominato da
       parola esiste.

   Accodare loutput ridiretto
       La ridirezione dell’output in questo modalità fa sì che il file il  cui
       nome  risulta  dall’espansione  di parola venga aperto per accodare sul
       descrittore di file n, o sullo standard output (descrittore di file  1)
       se n non è specificato.  Se il file non esiste viene creato.

       Il formato generico per accodare l’output è:

              [n]>>parola

   Ridirezione di standard output e standard error
       Bash  permette,  con  questo  costrutto,  che  l’output sia lo standard
       output  (descrittore  di  file  1)  che  quello  dello  standard  error
       (descrittore  di  file  2) siano ridiretti sul file il cui nome risulta
       dall’espansione di parola.

       Vi sono due formati per ridirigere lo standard  output  e  lo  standard
       error:

              &>parola
       e
              >&parola

       Delle  due forme, la prima è quella preferita.  Questo è semanticamente
       equivalente a

              >parola 2>&1

   Here Document
       Questo tipo  di  ridirezione  istruisce  la  shell  a  leggere  l’input
       dall’input  corrente,  finché  non venga incontrata una riga contenente
       solo parola (senza alcun carattere blank dopo la parola stessa).  Tutte
       le  righe lette fino a quel punto sono quindi usate come standard input
       per un comando.

       Il formato degli here-document è il seguente:

              <<[-]parola
                      here-document
              delimitatore

       Nessuna espansione di parametro, sostituzione  di  comando,  espansione
       aritmetica  o  espansione  di  percorso  è effettuata su parola.  Se un
       carattere qualsiasi in parola è quotato, il delimitatore è il risultato
       della  rimozione  dei  caratteri di quotatura da parola, e le righe nel
       here-document non vengono espanse.  Se parola non è quotata,  tutte  le
       righe  del  here-document  sono  soggette  a  espansione  di parametro,
       sostituzione di comando  ed  espansione  aritmetica.   In  quest’ultimo
       caso,  la  coppia  \<newline>  è  ignorata,  e  \ deve essere usata per
       quotare i caratteri \, $, e ‘.

       Se l’operatore di ridirezione è <<-, tutti i  caratteri  tab  a  inizio
       riga  sono  eliminati  dalle  righe  in input e dalla riga che contiene
       delimitatore.  Questo permette che un here-document dentro  uno  script
       di shell possa essere indentato in maniera naturale.

   Here String
       Una variante degli here document, il formato è:

              <<<parola

       La parola è espansa ed è passata al comando come suo standard input.

   Duplicazione dei descrittori di file
       L’operatore di ridirezione

              [n]<&parola

       è  usato  per  duplicare  descrittori  di  file di input.  Se parola si
       espande in una o più cifre, il descrittore di  file  indicato  da  n  è
       fatto  diventare una copia di quel descrittore di file.  Se le cifre in
       parola non specificano un descrittore di file aperto  per  l’input,  si
       verifica  un  errore  di  ridirezione.   Se parola risulta essere, dopo
       l’espansione, -, il descrittore di file n viene chiuso.   Se  n  non  è
       specificato, è usato lo standard input (descrittore di file 0).

       L’operatore

              [n]>&parola

       è  usato in modo analogo per duplicare i descrittori di file di output.
       Se n non è specificato, è usato lo standard output (descrittore di file
       1).   Se  le  cifre  in  parola  non specificano un descrittore di file
       aperto in output, si verifica un  errore  di  ridirezione.   Come  caso
       speciale,  se n è omesso, e parola non si espande a una o più cifre, lo
       standard output e lo standard error sono ridiretti  come  descritto  in
       precedenza.

   Muovere i descrittori di file
       L’operatore di ridirezione

              [n]<&cifra-

       muove  il  descrittore  di  file cifra al descrittore di file n, o allo
       standard input (descrittore di file 0) se n non è specificato.  cifra è
       chiuso dopo essere stato duplicato in n.

       Analogamente l’operatore di ridirezione

              [n]>&cifra-

       muove  il  descrittore  di  file cifra al descrittore di file n, o allo
       standard output (descrittore di file 1) se n non è specificato.

   Apertura di descrittori di file per lettura e scrittura
       L’operatore di ridirezione

              [n]<>parola

       fa sì che il file il cui nome è l’espansione di parola venga aperto sia
       in  lettura  che  in  scrittura  sul  descrittore  di  file  n,  o  sul
       descrittore di file 0 se n non è specificato.  Se il file  non  esiste,
       viene creato.

ALIAS

       Gli  alias consentono di sostituire una stringa con una parola se usata
       come prima parola di un comando semplice.  La shell mantiene una  lista
       di  alias  che  possono  essere  impostati  e  rimossi  con  i  comandi
       incorporati alias e unalias (si veda COMANDI  INCORPORATI  DELLA  SHELL
       più  avanti).   La  prima parola di ogni comando, se non quotata, viene
       controllata per vedere se a essa è associato un alias.  Se è questo  il
       caso,  la parola è sostituita dal valore dell’alias.  I caratteri /, $,
       ‘ e =, e  ognuno  dei  metacaratteri  della  shell  o  i  caratteri  di
       quotatura  elencati sopra non possono apparire in un nome di alias.  Il
       testo da sostituire può contenere qualunque input valido per la  shell,
       inclusi  i  metacaratteri  della shell.  La prima parola del testo così
       sostituito è controllata per vedere se contiene alias,  ma  una  parola
       che  coincide  con  l’alias che si sta espandendo non viene espansa una
       seconda volta.  Questo significa che si può far interpretare ls come ls
       -F,  per  esempio, e bash non tenta di espandere ulteriormente il testo
       così sostituito.  Se l’ultimo carattere del valore di  un  alias  è  un
       blank,  allora la successiva parola di comando che segue l’alias è pure
       controllata per l’espansione di alias.

       Gli alias sono creati ed elencati con il comando alias e rimossi con il
       comando unalias.

       Non  vi è alcun meccanismo per usare argomenti nel testo da sostituire.
       Se servono degli argomenti, si dovrà usare una funzione  di  shell  (si
       veda.  FUNZIONI più avanti).

       Gli  alias  non  sono espansi quando la shell non è interattiva, a meno
       che l’opzione di shell expand_aliases non sia impostata mediante  shopt
       (si veda la descrizione di shopt sotto COMANDI INCORPORATI DI SHELL più
       avanti).

       Le regole che riguardano la definizione e  l’uso  degli  alias  possono
       facilmente  generare  confusione.   Bash  legge  sempre almeno una riga
       completa di input prima di eseguire qualsiasi comando di  quella  riga.
       Gli  alias  sono  espansi  quando  un  comando  è  letto,  non quando è
       eseguito.  Perciò, una definizione di alias che appaia sulla  una  riga
       che contiene già un altro comando non ha effetto fino a che non è stata
       letta  la  successiva  riga  di  input.   I  comandi  che  seguono   la
       definizione  di  un  alias  su una data riga non sono influenzati da un
       nuovo alias.  Questo comportamento è  un  problema  anche  quando  sono
       eseguite delle funzioni.  Gli alias sono espansi quando viene letta una
       definizione di funzione, non quando la funzione è eseguita, poiché  una
       definizione  di  funzione  è  essa  stessa  un  comando composto.  Come
       conseguenza, gli alias definiti in una funzione sono  disponibili  solo
       dopo  che  quella funzione è eseguita.  Per maggior sicurezza, conviene
       porre sempre le definizioni di alias su una riga separata e  non  usare
       alias in comandi composti.

       Quasi  a  tutti  gli  effetti, le finalità per cui sono usati gli alias
       possono essere raggiunte usando invece funzioni di shell.

FUNZIONI

       Una funzione di shell, definita come descritto prima  sotto  GRAMMATICA
       DELLA   SHELL,   immagazzina  una  serie  di  comandi  per  una  futura
       esecuzione.  Quando il nome di una funzione di shell è  usato  come  un
       nome  di  comando semplice, la lista di comandi associati con quel nome
       di funzione viene eseguita.  Le funzioni  sono  eseguite  nel  contesto
       della  shell corrente; nessun nuovo processo è creato per interpretarle
       (a differenza di quanto avviene eseguendo uno script di shell).  Quando
       una   funzione   è   eseguita,  gli  argomenti  passati  alla  funzione
       costituiscono  i  parametri  posizionali  della  funzione  stessa.   Il
       parametro  speciale  #  viene aggiornato per riflettere il cambiamento.
       Il parametro speciale 0 rimane inalterato.   Il  primo  elemento  della
       variabile   FUNCNAME   è  impostato  al  nome  della  funzione  durante
       l’esecuzione della funzione.  Tutti gli altri aspetti dell’ambiente  di
       esecuzione  della  shell  sono  identici  tra  una  funzione  e  il suo
       chiamante ad eccezione della gestione dei segnali DEBUG  e  RETURN  (si
       veda   la  descrizione  del  comando  incorporato  trap  sotto  COMANDI
       INCORPORATI DI SHELL più avanti), i quali non sono ereditati a meno che
       alla  funzione sia stato dato l’attributo trace (si veda la descrizione
       del comando incorporato declare più avanti) o  l’opzione  di  shell  -o
       functrace  sia  stata  abilitata  per mezzo del comando incorporato set
       (nel qual caso tutte le funzioni  ereditano  la  gestione  dei  segnali
       DEBUG e RETURN).

       Variabili locali alla funzione possono essere dichiarate con il comando
       incorporato local.  Di solito,  le  variabili  e  i  loro  valori  sono
       condivisi tra la funzione e il suo chiamante.

       Se  il  comando  incorporato  return  è  eseguito  in  una funzione, la
       funzione termina e l’esecuzione  riprende  con  il  comando  che  viene
       subito  dopo  la chiamata di funzione.  Qualsiasi comando associato con
       la gestione del segnale  RETURN  viene  eseguito  prima  di  riprendere
       l’esecuzione.   Quando  una  funzione  termina  i  valori dei parametri
       posizionali e il parametro speciale # sono ripristinati ai  valori  che
       avevano prima dell’esecuzione della funzione.

       I  nomi  delle  funzioni  e  le definizioni possono essere elencati con
       l’opzione -f dei comandi incorporati declare o typeset.   L’opzione  -F
       di declare o typeset elenca solo i nomi di funzione (e opzionalmente il
       file d’origine e il numero di riga, se l’opzione di  shell  extdebug  è
       abilitata).   Le  funzioni  possono  essere  esportate,  in modo che le
       subshell automaticamente le trovino già definite con l’opzione  -f  del
       comando  incorporato  export.   Una  definizione di funzione può essere
       cancellata usando l’opzione -f del  comando  incorporato  unset  .   Da
       notare  che funzioni e variabili di shell aventi lo stesso nome possono
       risultare in più elementi con lo stesso nome nell’ambiente passato alle
       shell  figlie.   Bisogna  fare  attenzione  ai  casi  in cui questo può
       causare un problema.

       Le funzioni possono essere ricorsive.  Nessun limite è posto sul numero
       di chiamate ricorsive.

VALUTAZIONE ARITMETICA

       La  shell  permette  di  calcolare espressioni aritmetiche, sotto certe
       circostanze (si veda i comandi incorporati let e declare  e  Espansione
       aritmetica).   Il  calcolo viene fatta usando interi a larghezza fissa,
       senza controllo di supero della capacità, sebbene la  divisione  per  0
       sia  intercettata  e  segnalata  come  errore.  Gli operatori e la loro
       precedenza, associatività e valori, sono gli stessi del  linguaggio  C.
       La  seguente  lista  di operatori è raggruppata per operatori di uguale
       livello di precedenza.  I livelli sono elencati in ordine di precedenza
       decrescente.

       id++ id--
              post-incremento e post-decremento di una variabile
       ++id --id
              pre-incremento e pre-decremento di una variabile
       - +    meno e più unari
       ! ~    negazione logica e "bit a bit"
       **     elevamento a potenza
       * / %  moltiplicazione, divisione, modulo
       + -    addizione, sottrazione
       << >>  scorrimento "bit a bit" a sinistra e a destra
       <= >= < >
              confronto
       == !=  uguaglianza e differenza
       &      AND "bit a bit"
       ^      OR esclusivo "bit a bit"
       |      OR "bit a bit"
       &&     AND logico
       ||     OR logico
       expr?expr:expr
              operatore condizionale
       = *= /= %= += -= <<= >>= &= ^= |=
              assegnamento
       expr1 , expr2
              virgola

       Le  variabili di shell possono essere usate come operandi; l’espansione
       di parametro è effettuata  prima  della  valutazione  dell’espressione.
       All’interno  di  un’espressione,  le  variabili di shell possono essere
       referenziate anche per nome senza  bisogno  di  usare  la  sintassi  di
       espansione  di  parametro.   Una  variabile di shell nulla o rimossa ha
       valore 0 se  referenziata  per  nome  senza  l’uso  della  sintassi  di
       espansione  di  parametro.   Il valore di una variabile è valutato come
       un’espressione  aritmetica  quando  è  referenziata,  o  quando  a  una
       variabile a cui è stato dato l’attributo integer con declare -i è stato
       assegnato un valore.  Un valore nullo viene considerato  come  0.   Una
       variabile  di  shell  non ha bisogno essere stata dichiarata intera per
       poter essere usata in un’espressione.

       Le costanti che iniziano per 0 sono interpretate  come  numeri  ottali.
       Uno   0x  o  0X  iniziale  si  usa  per  indicare  numeri  esadecimali.
       Altrimenti, i numeri prendono la forma [base#]n, dove base è un  numero
       decimale  tra  2 e 64 che definisce la base aritmetica, e n è un numero
       espresso in quella base.  Se base# è omessa, allora è usata la base 10.
       Le  cifre  maggiori  di  9  sono rappresentate dalle lettere minuscole,
       dalle lettere maiuscole, e da @ e _, in quest’ordine.   Se  la  base  è
       minore  o  uguale a 36, le lettere minuscole e maiuscole possono essere
       usate indifferentemente per rappresentare numeri compresi tra 10 e  35.

       Gli operatori sono valutati in ordine di precedenza.  Le subespressioni
       tra parentesi sono valutate prima e possono prevalere sulle  regole  di
       precedenza di cui sopra.

ESPRESSIONI CONDIZIONALI

       Le  espressioni  condizionali  sono usate dal comando composto [[ e dai
       comandi incorporati test e  [  per  verificare  attributi  di  file  ed
       effettuare  comparazioni  aritmetiche  e  fra stringhe.  Le espressioni
       sono formate dalle seguenti primitive unarie o binarie.   Se  qualsiasi
       argomento  di  file  di una delle primitive è della forma /dev/fd/n, il
       descrittore di file n viene controllato.  Se l’argomento di file di una
       delle  primitive  è  uno  tra /dev/stdin, /dev/stdout o /dev/stderr, il
       descrittore di file 0, 1 o 2, rispettivamente, viene controllato.

       Se non diversamente specificato,  le  primitive  che  operano  su  file
       utilizzano  eventuali collegamenti simbolici e operano sul file puntato
       dal collegamento  simbolico,  invece  che  sul  collegamento  simbolico
       stesso.

       -a file
              Vero se file esiste.
       -b file
              Vero se file esiste ed è un file speciale a blocchi.
       -c file
              Vero se file esiste ed è un file speciale a caratteri.
       -d file
              Vero se file esiste ed è una directory.
       -e file
              Vero se file esiste.
       -f file
              Vero  se  file  esiste ed è un file normale [non una directory o
              altro].
       -g file
              Vero se file esiste ed è impostato il suo bit set-group-id.
       -h file
              Vero se file esiste ed è  un  collegamento  simbolico  [symbolic
              link].
       -k file
              Vero se file ha il suo ‘‘sticky’’ bit impostato.
       -p file
              Vero se file esiste ed è una named pipe (FIFO).
       -r file
              Vero se file esiste ed è leggibile.
       -s file
              Vero se file esiste ed è di dimensione maggiore di zero byte.
       -t fd  Vero  se  il  descrittore  di file fd è aperto e si tratta di un
              terminale.
       -u file
              Vero se file esiste ed è impostato il suo bit set-user-id.
       -w file
              Vero se file esiste ed è scrivibile.
       -x file
              Vero se file esiste ed è eseguibile.
       -O file
              Vero  se  file  esiste  ed   è   posseduto   dall’id   effettivo
              dell’utente.
       -G file
              Vero  se  file  esiste  ed  è  posseduto  dal  gruppo  effettivo
              dell’utente.
       -L file
              Vero se file esiste ed è un collegamento simbolico.
       -S file
              Vero se file esiste ed è un socket.
       -N file
              Vero se file esiste ed è stato modificato dopo l’ultima volta in
              cui è stato letto.
       file1 -nt file2
              Vero  se  file1 è più recente (come data di modifica) di file2 o
              se file1 esiste e file2 no.
       file1 -ot file2
              Vero se file1 è più vecchio di file2, o se file2 esiste e  file1
              no.
       file1 -ef file
              Vero  se  file1 e file2 si riferiscono allo stesso dispositivo e
              hanno lo stesso numero di inode.
       -o optname
              Vero se  l’opzione  di  shell  optname  è  abilitata.   Si  veda
              l’elenco  delle  opzioni sotto la descrizione dell’opzione -o al
              comando incorporato set più avanti.
       -z stringa
              Vero se la lunghezza di stringa è 0.
       stringa
       -n stringa
              Vero se la lunghezza di stringa è diversa da zero.

       stringa1 == stringa2
              Vero se le stringhe sono uguali. = può essere usato  invece  che
              == per aderire rigorosamente allo standard POSIX.

       stringa1 != stringa2
              Vero se le stringhe non sono uguali.

       stringa1 < stringa2
              Vero     se    stringa1    precede    come    ordine    stringa2
              lessicograficamente nella localizzazione corrente.

       stringa1 > stringa2
              Vero se stringa1 segue come ordine stringa2  lessicograficamente
              nella localizzazione corrente.

       arg1 OP arg2
              OP  è  uno tra -eq, -ne, -lt, -le, -gt, o -ge.  Questi operatori
              aritmetici binari risultano veri  se  arg1  è,  rispettivamente,
              uguale,  non  uguale,  minore,  minore  o  uguale,  maggiore,  o
              maggiore o uguale ad arg2.  Arg1 e arg2  possono  essere  numeri
              interi positivi o negativi.

ESPANSIONE DI COMANDO SEMPLICE

       Quando viene eseguito un comando semplice la shell effettua le seguenti
       espansioni, assegnamenti e ridirezioni, da sinistra a destra.

       1.     Le parole che l’analizzatore ha individuato essere  assegnamenti
              di  variabile  (quelle  che precedono il nome di comando) oppure
              ridirezioni  vengono  messe   da   parte   per   un’elaborazione
              successiva.

       2.     Le  parole  che non sono assegnamenti di variabile o ridirezioni
              sono espanse.  Se è presente qualche parola  dopo  l’espansione,
              la  prima  parola  è considerata essere il nome del comando e le
              rimanenti parole come argomenti dello stesso.

       3.     Le  ridirezioni  sono  effettuate  come  descritte  prima  sotto
              RIDIREZIONE.

       4.     Il testo dopo = in ogni assegnamento di variabile è sottoposto a
              espansione della  tilde,  sostituzione  di  comando,  espansione
              aritmetica e rimozione dei caratteri di quotatura prima di venir
              assegnato alla variabile.

       Se non risulta nessun nome di comando, gli  assegnamenti  di  variabile
       influenzano  l’ambiente  di  shell  corrente.  Altrimenti, le variabili
       sono aggiunte  all’ambiente  del  comando  eseguito  senza  influenzare
       l’ambiente  di  shell  corrente.   Se  uno qualsiasi degli assegnamenti
       tenta di assegnare un valore  a  una  variabile  in  sola  lettura,  si
       verifica  un  errore  e il comando è terminato con uno stato diverso da
       zero.

       Se non risulta nessun nome di comando le ridirezioni sono effettuate ma
       senza  influenzare  l’ambiente  di  shell  corrente.  Se si verifica un
       errore di ridirezione il comando è terminato con uno stato  diverso  da
       zero.

       Se è rimasto un nome di comando dopo l’espansione, l’esecuzione procede
       come descritto sotto.  Altrimenti,  il  comando  esce.   Se  una  delle
       espansioni conteneva una sostituzione di comando lo stato di uscita del
       comando  è  lo  stato  d’uscita  dell’ultima  sostituzione  di  comando
       eseguita.  Se non ci sono state sostituzioni di comando il comando esce
       con uno stato d’uscita di zero.

ESECUZIONE DI UN COMANDO

       Dopo che un comando è stato suddiviso in parole, se esso risulta essere
       un  comando  semplice  e  di  una  lista  opzionale  di argomenti, sono
       eseguite le seguenti azioni.

       Se il nome del comando non  contiene  barra  [/],  la  shell  tenta  di
       localizzarla.   Se  esiste  una  funzione di shell con quel nome, viene
       invocata quella funzione, come descritto prima in FUNZIONI.  Se il nome
       non  corrisponde  a  una  funzione,  la  shell lo cerca nella lista dei
       comandi  incorporati  della   shell.    Se   ne   viene   trovato   uno
       corrispondente, viene invocato quel comando incorporato.

       Se  il nome non è né una funzione di shell né un comando incorporato, e
       non contiene alcuna barra  [/],  bash  cerca  tra  gli  elementi  della
       variabile  PATH  una directory che contenga un file eseguibile con quel
       nome.  Bash usa una tabella hash [indicizzata] per ricordare i percorsi
       completi  dei  file  eseguibili (si veda hash sotto COMANDI INCORPORATI
       DELLA SHELL più avanti).  Una ricerca completa nelle directory in  PATH
       è  effettuata  solo se il comando non viene trovato nella tabella hash.
       Se la ricerca non ha successo, la shell stampa un messaggio di errore e
       ritorna uno stato d’uscita di 127.

       Se  la ricerca ha successo, o se il nome del comando contiene uno o più
       barre [/], la shell esegue il programma  indicato  in  un  ambiente  di
       esecuzione  separato.  L’argomento 0 è impostato al nome specificato, e
       i  rimanenti  argomenti  del  comando  sono  impostati  agli  argomenti
       specificati, se presenti.

       Se  quest’esecuzione  non  ha  successo perché il file non è in formato
       eseguibile e il file non è una directory, si suppone che sia uno script
       di shell, cioè un file che contiene comandi di shell, ed è generata una
       subshell per eseguirlo.  Questa subshell reinizializza se stessa,  così
       che  l’effetto  è  come  se  fosse  stata  invocata una nuova shell per
       gestire lo script, con la differenza che la lista dei nomi completi  di
       comando  ricordati dalla shell genitrice (si veda hash più avanti sotto
       COMANDI INCORPORATI DELLA SHELL)  sono  disponibili  anche  alla  shell
       figlia.

       Se  il programma è un file che inizia con #!, il resto della prima riga
       del file stesso specifica un interprete da invocare.  La  shell  esegue
       l’interprete specificato su sistemi operativi che non gestiscono questo
       formato  eseguibile  essi  stessi.   Gli  argomenti  per   l’interprete
       consistono  di  un  singolo  argomento  opzionale  che  segue  il  nome
       dell’interprete sulla prima riga del programma, seguito  dal  nome  del
       programma, seguito dagli argomenti forniti al comando, se ve ne sono.

AMBIENTE DI ESECUZIONE DEL COMANDO

       La shell ha un ambiente di esecuzione, costituito da:

       ·      file   aperti   ereditati   dalla  shell  all’invocazione,  come
              modificati dalle ridirezioni fornite al comando incorporato exec

       ·      la  corrente  directory  di lavoro come impostata da cd, pushd o
              popd, o ereditata dalla shell all’invocazione

       ·      la maschera del modo di creazione dei  file  come  impostata  da
              umask o ereditata dalla shell genitrice

       ·      i segnali da intercettare impostati da trap

       ·      parametri  di  shell che sono stati impostati da un assegnamento
              di variabile o  con  set,  o  ereditati  dalla  shell  genitrice
              nell’ambiente

       ·      funzioni  di  shell  definite  durante  l’esecuzione o ereditate
              dalla shell genitrice nell’ambiente

       ·      opzioni abilitate  all’invocazione  (sia  per  default  che  con
              argomenti da riga di comando) o da set

       ·      opzioni abilitate da shopt

       ·      alias di shell definiti da alias

       ·      vari  ID  di  processo, inclusi quelli dei job in background, il
              valore di $$ e il valore di $PPID

       Quando un comando semplice, diverso da una funzione  incorporata  o  da
       una  funzione  di  shell,  dev’essere  eseguito,  viene  invocato in un
       ambiente di esecuzione separato che comprende tutto  quello  che  viene
       illustrato  qui  di  seguito.   Se non altrimenti notato, i valori sono
       ereditati dalla shell.

       ·      i  file  aperti  della  shell,  più  qualsiasi  modificazione  e
              aggiunta specificata dalle ridirezioni al comando

       ·      la directory di lavoro corrente

       ·      la maschera del modo di creazione dei file

       ·      variabili  di  shell  e funzioni dichiarate esportabili, insieme
              alle variabili esportate per il comando, passate nell’ambiente

       ·      i segnali da intercettare come da comando trap dalla shell  sono
              riportati ai valori ereditati dalla shell genitrice, e i segnali
              ignorati dalla shell vengono ignorati

       Un comando invocato in  quest’ambiente  separato  non  può  influenzare
       l’ambiente di esecuzione della shell [genitrice].

       Sostituzione  di  comando,  comandi raggruppati fra parentesi e comandi
       asincroni sono invocati in un ambiente di subshell che è  un  duplicato
       dell’ambiente  di  shell,  con  l’eccezione  che i segnali intercettati
       dalla shell sono riportati ai valori che la shell eredita  dalla  shell
       genitrice  all’invocazione.   I  comandi  incorporati che sono invocati
       come parte di una pipeline sono anch’essi eseguiti in  un  ambiente  di
       subshell.    Modifiche  fatte  all’ambiente  di  subshell  non  possono
       influenzare l’ambiente di esecuzione della shell [genitrice].

       Se un comando è invocato da un & e il  job-control  non  è  attivo,  lo
       standard  input  di  default  per il comando è il file vuoto /dev/null.
       Altrimenti il comando invocato eredita  i  descrittori  di  file  della
       shell chiamante come modificati dalle ridirezioni.

AMBIENTE

       Quando  viene invocato un programma gli viene dato un array di stringhe
       chiamato [insieme delle variabili di] ambiente.  Questa è una lista  di
       coppie nome-valore, della forma nome=valore.

       La   shell   consente   di   manipolare   l’ambiente   in  molti  modi.
       All’invocazione, la shell esamina il suo ambiente e crea  un  parametro
       per  ogni nome trovato, marcandolo automaticamente per essere esportato
       ai processi figli.  I comandi eseguiti ereditano l’ambiente.  I comandi
       export  e  declare -x permettono di aggiungere o togliere dall’ambiente
       parametri e funzioni.  Se il valore di un  parametro  d’ambiente  viene
       modificato, il nuovo valore diventa parte dell’ambiente, sostituendo il
       valore precedente.  L’ambiente ereditato da qualsiasi comando  eseguito
       è  costituito  dall’ambiente iniziale della shell, i cui valori possono
       essere modificati nella shell, diminuiti di  ogni  coppia  rimossa  dal
       comando unset, e aumentati da ogni aggiunta attraverso i comandi export
       e declare -x .

       L’ambiente  per  qualsiasi  comando  semplice  o  funzione  può  essere
       ampliato temporaneamente premettendo degli assegnamenti di parametro al
       comando stesso, come descritto prima in PARAMETRI.   Queste  istruzioni
       di assegnamento influenzano solo l’ambiente utilizzato da quel comando.

       Se è impostata l’opzione -k (si veda il  comando  incorporato  set  più
       avanti),  tutti  gli  assegnamenti  di  parametro sono resi disponibili
       nell’ambiente del comando, non solo quelli che precedono  il  nome  del
       comando.

       Quando  bash  invoca un comando esterno, la variabile _ viene impostata
       al nome completo del percorso del comando, e passato a quel comando nel
       suo ambiente.

STATO DUSCITA
       Ai fini della shell, un comando che termina con uno stato d’uscita zero
       ha avuto successo.  Uno stato d’uscita pari  a  zero  indica  successo.
       Uno  stato  d’uscita  diverso da zero indica errore.  Quando un comando
       termina su un segnale fatale N, bash usa il valore di 128+N come  stato
       d’uscita.

       Se  un  comando  non  viene  trovato,  il  processo  figlio  creato per
       eseguirlo ritorna uno stato pari a 127.  Se un comando viene trovato ma
       non è eseguibile lo stato di ritorno è 126.

       Se un comando non ha successo a causa di un errore durante l’espansione
       o la ridirezione, lo stato d’uscita è maggiore di zero.

       I comandi incorporati della shell restituiscono uno stato di  0  (vero)
       in  caso  di  successo,  e  diverso  da  zero (falso) in caso di errore
       durante l’esecuzione.  Tutti i comandi  incorporati  restituiscono  uno
       stato d’uscita di 2 per indicare l’uso scorretto.

       Bash  stessa  ritorna lo stato d’uscita dell’ultimo comando eseguito, a
       meno che non avvenga un errore di sintassi, nel qual caso essa esce con
       un  valore  diverso da zero.  Si veda anche il comando incorporato exit
       più avanti.

SEGNALI

       Quando bash è interattiva, in assenza di ogni segnale  da  intercettare
       col  comando trap, ignora SIGTERM (così che kill 0 non uccide una shell
       interattiva), e SIGINT  viene  intercettato  e  gestito  (così  che  il
       comando  incorporato  wait  è  interrompibile).   In tutti i casi, bash
       ignora SIGQUIT.   Se  si  usa  il  job-control,  bash  ignora  SIGTTIN,
       SIGTTOU, e SIGTSTP.

       I  comandi  non incorporati invocati da bash hanno i gestori di segnali
       impostati sui valori ereditati dalla shell dalla sua genitrice.  Quando
       non  si  usa  il  job-control,  i  comandi  asincroni ignorano SIGINT e
       SIGQUIT.  in aggiunta a questi gestori ereditati.  I  comandi  eseguiti
       come  risultato  di  una  sostituzione di comando ignorano i segnali di
       job-control generati da tastiera SIGTTIN, SIGTTOU, e SIGTSTP.

       La shell esce per default  al  ricevimento  di  un  SIGHUP.   Prima  di
       uscire,  una shell interattiva ri-invia un segnale SIGHUP a tutti i job
       [richiesti tramite job-control],  in  esecuzione  o  sospesi.   Ai  job
       sospesi viene inviato un segnale SIGCONT per essere sicuri che ricevano
       il segnale SIGHUP.  Per prevenire l’invio del segnale  da  parte  della
       shell  a un particolare job, quest’ultimo dovrebbe essere rimosso dalla
       tabella dei  job  col  comando  incorporato  disown  (si  veda  COMANDI
       INCORPORATI  DELLA  SHELL più avanti) o contrassegnato per non ricevere
       SIGHUP usando disown -h.

       Se l’opzione di shell huponexit è stata impostata con shopt, bash invia
       un  segnale  SIGHUP a tutti i job quando una shell di login interattiva
       esce.

       Se bash è in attesa che un comando finisca e riceve un segnale  per  il
       quale  è  stato  impostata  un’intercettazione  di  segnale, il comando
       relativo alla gestione del segnale viene eseguito solo al  termine  del
       comando.   Quando  bash  è in attesa della fine di un comando asincrono
       attraverso il comando incorporato wait, la ricezione di un segnale  per
       il  quale  un’intercettazione di segnale è stata impostata fa sì che il
       comando incorporato wait termini immediatamente con uno stato  d’uscita
       maggiore  di 128, e immediatamente dopo viene innescata la gestione del
       segnale intercettato.

JOB-CONTROL

       Il  termine  job-control  si  riferisce  alla   capacità   di   fermare
       (sospendere)  selettivamente  l’esecuzione  di  processi  e  continuare
       (riprendere) la loro esecuzione in  seguito.   Tipicamente,  un  utente
       utilizza   questa  possibilità  attraverso  un’interfaccia  interattiva
       costituita congiuntamente dal driver del  terminale  di  sistema  e  da
       bash.

       La shell associa un job a ogni pipeline.  Essa mantiene una tabella dei
       job correntemente in esecuzione, che può  essere  visualizzata  con  il
       comando  jobs.   Quando  bash  avvia  un  job  in  modo  asincrono  (in
       background), stampa una riga tipo:

              [1] 25647

       che indica che questo job è il job numero 1  e  che  l’ID  di  processo
       dell’ultimo  processo  nella  pipeline  associata a questo job è 25647.
       Tutti i processi in una singola pipeline fanno parte dello stesso  job.
       Bash usa l’astrazione job come base per il job-control.

       Per  facilitare  l’implementazione  dell’interfaccia utente per il job-
       control, il sistema mantiene la nozione di ID del  gruppo  di  processi
       del  terminale  corrente.   I  membri  di  questo  gruppo  di  processo
       (processi il cui ID del gruppo di processo è uguale all’ID  del  gruppo
       di  processo  del  terminale  corrente)  ricevono  segnali  generati da
       tastiera, come SIGINT.  Si dice che questi processi sono in primo piano
       (foreground - oppure sincroni).  I processi in background (sullo sfondo
       - oppure asincroni) sono quelli  il  cui  ID  del  gruppo  di  processo
       differisce  da  quello  del  terminale;  tali  processi sono immuni dai
       segnali generati  da  tastiera.   Solo  ai  processi  in  foreground  è
       permesso   di  leggere  o  scrivere  sul  terminale.   Ai  processi  in
       background che tentano di leggere (scrivere) sul terminale è inviato un
       segnale  SIGTTIN  (SIGTTOU)  dal  driver  del  terminale,  che,  se non
       intercettato, sospende il processo.

       Se il sistema operativo sul quale bash è in esecuzione supporta il job-
       control  bash  è  in  grado  di  utilizzarlo.   Battere il carattere di
       sospensione  (tipicamente  ^Z,  Control-Z)  mentre  un  processo  è  in
       esecuzione,  provoca  la  sospensione di quel processo e restituisce il
       controllo a bash .   Battere  il  carattere  di  sospensione  ritardata
       (tipicamente  ^Y, Control-Y) provoca la sospensione del processo quando
       questo tenta di leggere input dal  terminale,  e  la  restituzione  del
       controllo  a  bash.  Si può poi cambiare lo stato di questo job, usando
       il comando  bg  per  continuarlo  in  background,  il  comando  fg  per
       riportarlo in foreground, o il comando kill per farlo terminare.  Un ^Z
       ha effetto immediatamente, e ha l’effetto  collaterale  di  causare  la
       perdita  dell’output in sospeso e del "type ahead" [caratteri immessi a
       terminale ma non ancora passati al programma].

       Vi sono diversi modi per riferirsi a un job nella shell.  Il  carattere
       % designa un nome di job.  Un job con numero n può essere indicato come
       %n.  Un job può anche essere indicato usando un prefisso del nome usato
       per  avviarlo,  o  usando  una  substringa che appare nella sua riga di
       comando.  Per esempio, %ce si riferisce a un job  ce  sospeso.   Se  un
       prefisso  corrisponde a più di un job, bash restituisce un messaggio di
       errore.  L’uso  di  %?ce,  d’altra  parte,  indica  qualsiasi  job  che
       contiene  la  stringa  ce  nella sua riga di comando.  Se la substringa
       corrisponde a più di un job, bash restituisce un messaggio  di  errore.
       I  simboli  %%  e  %+  si  riferiscono alla nozione della shell del job
       corrente, ossia l’ultimo job sospeso mentre era in foreground o avviato
       in  background.   Il  job precedente può essere referenziato usando %-.
       Nell’output che riguarda i  job  (per  esempio,  l’output  del  comando
       jobs),  il  job  corrente  è  sempre  segnalato  con  un  +,  ed il job
       precedente con  un  -.   Un  singolo  %  (senza  alcuna  specificazione
       associata) è pure un modo per designare il job corrente.

       La  semplice  menzione  di  un  job  può essere usata per riportarlo in
       foreground: %1 è un sinonimo per ‘‘fg %1’’, che  porta  il  job  1  dal
       background  al  foreground.   Nello  stesso  modo,  ‘‘%1  &’’  riprende
       l’esecuzione del job 1 in background, ossia equivale a ‘‘bg %1’’.

       La shell viene notificata immediatamente ogni volta che un  job  cambia
       stato.   Normalmente,  bash  aspetta finché non deve stampare un prompt
       prima di informare dei cambiamenti nello stato di un job,  in  modo  da
       non  interrompere  alcun  altro  output.   Se  l’opzione -b del comando
       incorporato  set   è   impostata,   bash   riporta   tali   cambiamenti
       immediatamente.   Delle  eventuali  istruzioni  di  intercettazione del
       segnale SIGCHLD viene eseguita per ogni processo figlio che esce.

       Se si tenta di uscire da bash mentre vi sono dei job sospesi, la  shell
       stampa  un  messaggio  di avvertimento.  Si può quindi usare il comando
       jobs per controllare il loro stato.  Se si fa un secondo tentativo  per
       uscire  senza  immettere  alcun  altro  comando,  non  si riceve più il
       messaggio di avvertimento e i job sospesi vengono terminati.

STRINGHE DI PROMPT

       Quando eseguita interattivamente, bash mostra il  prompt  primario  PS1
       quando  è  pronta  per  leggere  un comando, e il prompt secondario PS2
       quando è in attesa di altro input  per  completare  un  comando.   Bash
       permette di personalizzare queste stringhe di prompt inserendo un certo
       numero  di  caratteri  speciali  preceduti  da   backslash   che   sono
       decodificati come segue:
              \a     un carattere ASCII di allarme (07) [campanello o bip]
              \d     la  data nel formato "Giorno-della-settimana Mese Giorno"
                     (ad es., "Tue May 26")
              \D{formato}
                     il formato viene passato a strftime(3) e il  risultato  è
                     inserito nella stringa di prompt; un formato vuoto genera
                     una  rappresentazione   di   data/ora   specifica   della
                     localizzazione.  Le parentesi graffe sono obbligatorie
              \e     un carattere ASCII di escape (033)
              \h     il nome dell’host fino al primo ‘.’
              \H     il nome dell’host
              \j     il numero di job attualmente gestiti dalla shell
              \l     il   basename  [nome  all’interno  della  directory]  del
                     terminale in cui è eseguita la shell
              \n     newline [su una nuova linea, ossia il prompt  può  essere
                     su più linee]
              \r     carriage  return  [a  inizio  linea,  ma non su una nuova
                     linea]
              \s     il nome della shell, il basename [nome all’interno  della
                     directory] di $0 (la parte che segue l’ultima barra [/])
              \t     l’ora corrente nel formato HH:MM:SS 24 ore
              \T     l’ora corrente nel formato HH:MM:SS 12 ore
              \@     l’ora corrente nel formato am/pm 12 ore
              \A     l’ora corrente nel formato HH:MM 24 ore
              \u     il nome-utente dell’utente corrente
              \v     la versione di bash (ad es., 2.00)
              \V     la  release di bash, versione + livello di patch (ad es.,
                     2.00.0)
              \w     la directory di lavoro corrente con HOME  abbreviato  con
                     una tilde
              \W     il  basename della directory di lavoro corrente, con HOME
                     abbreviato con una tilde
              \!     il numero nella cronologia del comando attuale
              \#     il numero di comando del comando attuale
              \$     se l’UID effettivo è 0, un #, altrimenti un $
              \nnn   il carattere [ASCII] che corrisponde al numero ottale nnn
              \\     un backslash
              \[     marca   l’inizio   di   una  sequenza  di  caratteri  non
                     stampabili, che può essere usata per includere nel prompt
                     una sequenza di controllo del terminale
              \]     marca la fine di una sequenza di caratteri non stampabili

       Il numero del comando e il numero nella  cronologia  sono  generalmente
       differenti: il numero della cronologia di un comando è la sua posizione
       nella  lista  della  cronologia,  la  quale   può   includere   comandi
       preesistenti  nel  file  di cronologia (si veda CRONOLOGIA più avanti),
       mentre il numero del comando è la posizione nella sequenza dei  comandi
       eseguiti  durante la corrente sessione di shell.  Dopo che la stringa è
       decodificata, essa è espansa attraverso l’espansione di  parametro,  la
       sostituzione  di  comando,  l’espansione  aritmetica e la rimozione dei
       caratteri  di  quotatura,  secondo  quanto   specificato   dal   valore
       dell’opzione di shell promptvars (si veda più avanti la descrizione del
       comando shopt sotto COMANDI INCORPORATI DELLA SHELL ).

READLINE

       Questa è la libreria che gestisce la lettura dell’input quando  si  usa
       una   shell  interattiva,  a  meno  che  non  si  specifichi  l’opzione
       --noediting all’invocazione della shell.  Per default,  i  comandi  per
       l’editor  della  riga  comandi  sono simili a quelli di emacs.  È anche
       disponibile un’interfaccia  per  editor  di  riga  in  stile  vi.   Per
       chiudere  l’interfaccia  per  l’editor  di riga dopo l’esecuzione della
       shell utilizzare l’opzione -B +o emacs o +o vi del comando  incorporato
       set (si veda COMANDI INCORPORATI DELLA SHELL più avanti).

   Notazione readline
       In  questa  sezione,  si usa la notazione in stile emacs per indicare i
       tasti da battere.  I tasti di controllo sono indicati da  C-tasto,  per
       esempio,  C-n  significa  Control-N.  In modo simile, i meta tasti sono
       indicati da M-tasto, cioè M-x significa Meta-X.  (Sulle tastiere  senza
       un  tasto  meta , M-x significa ESC x, cioè, si preme il tasto Escape e
       poi il tasto x .  Questo rende ESC il meta prefisso.   La  combinazione
       M-C-x  significa  ESC-Control-x,  ossia si preme il tasto Escape poi si
       tiene il tasto Control mentre si preme il tasto x ).

       Ai comandi readline possono essere specificati argomenti  numerici  che
       normalmente sono dei contatori di ripetizione.  A volte, tuttavia, è il
       segno dell’argomento a essere  significativo.   Passando  un  argomento
       negativo  a  un  comando  che  agisce in avanti (ad es., kill-line), il
       comando agisce nella direzione opposta.  I comandi il cui comportamento
       con gli argomenti è diverso da questo sono indicati più avanti.

       Quando  un  comando  è  descritto  come eliminazione di testo, il testo
       cancellato viene salvato per un possibile riutilizzo futuro  (yanking).
       Il  testo  eliminato  viene  salvato  in  un  kill-ring.   Eliminazioni
       consecutive provocano l’accumulazione del testo in una unità,  che  può
       essere  recuperata tutta in una volta.  Comandi che non eliminano testo
       separano parti di testo nel kill-ring.

   Inizializzazione di Readline
       Readline  è  personalizzata   inserendo   comandi   in   un   file   di
       inizializzazione  (il  file  inputrc ).  Il nome di questo file è preso
       dal valore della  variabile  INPUTRC  .   Se  questa  variabile  non  è
       definita  il  valore  di default è ~/.inputrc.  Quando un programma che
       usa la  libreria  readline  viene  avviato,  viene  letto  il  file  di
       inizializzazione,  e  vengono  impostate  le  associazioni  di  tasti e
       assegnate le variabili.  Ci sono solo alcuni costrutti base  consentiti
       nel file d’inizializzazione di readline.  Le righe vuote sono ignorate.
       Le righe che iniziano con un # sono commenti.  Le  righe  che  iniziano
       con  un  $  indicano  costrutti  condizionali.  Le altre righe indicano
       associazioni di tasti e impostazioni di variabili.

       Le associazioni di tasti di default possono essere cambiate con un file
       inputrc .  Altri programmi che usano questa libreria possono aggiungere
       i loro propri comandi e associazioni.

       Per esempio, porre

              M-Control-u: universal-argument
       o
              C-Meta-u: universal-argument
       nel file inputrc farebbe eseguire a M-C-u  il  comando  della  readline
       universal-argument .

       Sono  riconosciuti i seguenti nomi simbolici di carattere: RUBOUT, DEL,
       ESC, LFD, NEWLINE, RET, RETURN, SPC, SPACE e TAB.

       In aggiunta al nome del comando,  readline  consente  che  a  un  tasto
       corrisponda una stringa che è inserita quando quel tasto è premuto (una
       macro).

   Associazioni di tasti readline
       La sintassi per il controllo delle  associazioni  dei  tasti  nel  file
       inputrc è semplice.  Tutto quel che è richiesto è il nome del comando o
       il testo di una macro e una sequenza di tasti alla quale  dovrà  essere
       associato.   Il  nome  può  essere specificato in uno di due modi: come
       nome simbolico di un  tasto,  eventualmente  con  i  prefissi  Meta-  o
       Control-, o come una sequenza di tasti.

       Quando  si  usa la forma nome-tasto:nome-funzione o macro, nome-tasto è
       il nome di un tasto in inglese.  Per esempio:

              Control-u: universal-argument
              Meta-Rubout: backward-kill-word
              Control-o: "> output"

       Negli  esempi   precedenti,   C-u   viene   collegato   alla   funzione
       universal-argument,     M-DEL    viene    collegato    alla    funzione
       backward-kill-word, e C-o viene collegato  all’esecuzione  della  macro
       indicata  sul  lato  destro (cioè, inserire il testo ‘‘> output’’ nella
       riga).

       Nella   seconda   forma,   "sequenza-tasti":nome-funzione   o    macro,
       sequenza-tasti  differisce  da nome-tasto visto sopra, per il fatto che
       la  stringa  che  denota  un’intera  sequenza  di  tasti   può   essere
       specificata  ponendo  la  sequenza  fra  virgolette.   Alcuni  tasti di
       protezione (escape) nello stile GNU Emacs possono  essere  usati,  come
       nei  seguenti  esempi, ma i nomi simbolici dei caratteri non si possono
       utilizzare.

              "\C-u": universal-argument
              "\C-x\C-r": re-read-init-file
              "\e[11~": "Function Key 1"

       In  questo  esempio,  C-u  viene   ancora   collegato   alla   funzione
       universal-argument.     C-x   C-r   viene   collegato   alla   funzione
       re-read-init-file, e ESC [ 1 1 ~ viene  collegato  all’inserimento  del
       testo ‘‘Function Key 1’’.

       L’insieme  completo  delle sequenze di protezione (escape) in stile GNU
       Emacs è
              \C-    prefisso control
              \M-    prefisso meta
              \e     un carattere di escape
              \\     backslash
              \"     il carattere "
              \'     il carattere '

       In aggiunta alle sequenze di protezione che iniziano col  tasto  escape
       in  stile  GNU  Emacs,  è disponibile un secondo insieme di sequenze di
       protezione che iniziano con il backslash:
              \a     avviso (segnale acustico)
              \b     backspace
              \d     cancella [delete - tasto Del o Canc]
              \f     form feed [salto pagina]
              \n     newline [nuova linea]
              \r     carriage return [a inizio linea]
              \t     tabulazione orizzontale
              \v     tabulazione verticale
              \nnn   il carattere a otto bit il cui valore è rappresentato dal
                     valore ottale nnn (da una a tre cifre ottali)
              \xHH   il carattere a otto bit il cui valore è rappresentato dal
                     valore esadecimale HH (una o due cifre esadecimali)

       Quando si inserisce il testo  di  una  macro,  apostrofi  o  virgolette
       devono  essere  usati  per indicare una definizione di macro.  Un testo
       non quotato si suppone essere [che sia] un nome di funzione.  Nel corpo
       della  macro,  i  segni di protezione backslash descritti prima vengono
       espansi.  Il backslash quota qualsiasi altro carattere nel testo  della
       macro, inclusi " e '.

       Bash  permette  di  mostrare  o modificare le associazioni correnti dei
       tasti di readline con il comando incorporato bind .  Il modo di editing
       può  essere  cambiato durante l’uso interattivo usando l’opzione -o del
       comando incorporato set (si veda COMANDI INCORPORATI  DELLA  SHELL  più
       avanti).

   Variabili readline
       Readline ha delle variabili che possono essere usate per personalizzare
       ulteriormente il suo comportamento.  Una variabile può essere impostata
       nel file inputrc con un’istruzione della forma

              set nome-di-variabile valore

       Tranne  dove  diversamente  indicato,  le variabili di readline possono
       avere i valori On o Off (senza distinzione fra maiuscole e  minuscole).
       I  nomi  di  variabile non riconosciuti vengono ignorati.  Quando viene
       letto un valore di variabile, i  valori  vuoti  o  nulli,  "on"  (senza
       distinzione  fra  maiuscole  e  minuscole) o "1" sono equivalenti a On.
       Tutti gli altri valori sono equivalenti a Off.  Le variabili e  i  loro
       valori di default sono:

       bell-style (audible)
              Controlla  cosa  succede  se readline vuole usare il segnalatore
              acustico del terminale.   Se  impostato  a  none,  readline  non
              emette  alcun  segnale.  Se impostato a visible, readline usa un
              segnalatore visivo se  disponibile.   Se  impostato  a  audible,
              readline   tenta   di   attivare  il  segnalatore  acustico  del
              terminale.
       bind-tty-special-chars (On)
              Se impostato a On, readline tenta di associare  i  caratteri  di
              controllo trattati in modo speciale dal driver del terminale nel
              kernel agli equivalenti degli stessi come descritti da readline.
       comment-begin (‘‘#’’)
              La   stringa  che  è  inserita  quando  è  eseguito  il  comando
              insert-comment .  Questo comando è associato a M-#  in  modalità
              comandi Emacs e a # in modalità comandi di vi.
       completion-ignore-case (Off)
              Se  impostato  a On, readline effettua l’individuazione dei nomi
              di file e il completamento seza distinguere le lettera maiuscole
              dalle lettere minuscole.
       completion-query-items (100)
              Questo   determina   a   che  punto  interpellare  l’utente  per
              visualizzare i  possibili  completamenti  generati  dal  comando
              possible-completions.   Può  essere impostato a un numero intero
              maggiore  o  uguale  a  zero.   Se  il   numero   di   possibili
              completamenti è maggiore o uguale al valore di questa variabile,
              all’utente viene chiesto se desidera o meno vederli;  altrimenti
              essi sono semplicemente elencati sul terminale.
       convert-meta (On)
              Se  impostato  a  On, readline converte i caratteri con l’ottavo
              bit uguale a 1 a una  sequenza  di  caratteri  ASCII  eliminando
              l’ottavo  bit  e  aggiungendo  come  prefisso  un  carattere  di
              protezione (in pratica, usando l’escape come prefisso meta).
       disable-completion (Off)
              Se impostato a On,  readline  inibisce  il  completamento  della
              parola.   I  caratteri  di  completamento saranno inseriti nella
              riga come se fossero stati mappati come self-insert.
       editing-mode (emacs)
              Controlla se readline parte con un insieme  di  associazioni  di
              tasti  simile a emacs o vi.  editing-mode può essere impostato a
              emacs o a vi.
       enable-keypad (Off)
              Quando impostato a On, readline tenta di abilitare il tastierino
              numerico  se viene utilizzato.  Alcuni sistemi richiedono questo
              per abilitare i tasti-freccia.
       expand-tilde (Off)
              Se impostato a on, l’espansione della tilde è effettuata  quando
              readline tenta il completamento della parola.
       history-preserve-point (Off)
              Se  impostato a on, il codice che implementa la cronologia tenta
              di piazzare il cursore nel punto in cui si trovava su ogni  riga
              della  cronologia  visualizzata  con  previous-history  o  next-
              history.
       horizontal-scroll-mode (Off)
              Quando impostato a On, richiede a readline  di  usare  una  sola
              riga per la visualizzazione, effettuando lo scroll dell’input in
              orizzontale su una sola riga dello schermo quando  essa  risulti
              più  lunga  della  larghezza dello schermo, invece che andando a
              capo su una nuova riga.
       input-meta (Off)
              Se impostato a On, readline abilita l’input a  otto  bit  (cioè,
              non   toglie   il   bit  più  alto  dai  caratteri  che  legge),
              indipendentemente  da  quello  che  il  terminale  dichiara   di
              supportare.    Il  nome  meta-flag  è  un  sinonimo  per  questa
              variabile.
       isearch-terminators (‘‘C-[C-J’’)
              Una  stringa  di  caratteri  che  fa   terminare   una   ricerca
              incrementale senza eseguire successivamente il carattere come se
              fosse un comando.  Se a questa variabile non  è  stato  dato  un
              valore,  i  caratteri  ESC  and  C-J fanno terminare una ricerca
              incrementale.
       keymap (emacs)
              Imposta la mappa corrente dei tasti di  readline.   Il  set  dei
              nomi  validi  per  le  mappe  dei tasti è emacs, emacs-standard,
              emacs-meta,  emacs-ctlx,  vi,  vi-command  e  vi-insert.   vi  è
              equivalente  a vi-command; emacs è equivalente a emacs-standard.
              Il  valore  di  default  è  emacs;  il  valore  di  editing-mode
              determina anche la mappa dei tasti di default.
       mark-directories (On)
              Se impostata a On, ai nomi delle directory completate è aggiunta
              una barra [/] alla fine.
       mark-modified-lines (Off)
              Se impostato a On, le righe  della  cronologia  che  sono  state
              modificate sono mostrate precedute da un asterisco (*).
       mark-symlinked-directories (Off)
              Se  impostato  a  On,  i  nomi  completati che sono collegamenti
              simbolici  a  directory  hanno  una  barra  [/]  alla  fine  (se
              richiesto tramite mark-directories).
       match-hidden-files (On)
              Questa  variabile,  se impostata a On, fa sì che readline mostri
              anche i file i cui nomi iniziano  con  un  ‘.’  (file  nascosti)
              quando effettua il completamento del nome di file, a meno che il
              ‘.’ iniziale non sia fornito dall’utente come parte del nome  di
              file da completare.
       output-meta (Off)
              Se  impostato a On, readline mostra i caratteri con l’ottavo bit
              impostato  direttamente,  piuttosto  che  con  una  sequenza  di
              protezione avente come prefisso meta.
       page-completions (On)
              Se  impostato  a On, readline usa un paginatore interno simile a
              more per mostrare i possibili completamenti una  schermata  alla
              volta.
       print-completions-horizontally (Off)
              Se  impostato  a On, readline mostra i completamenti ordinati in
              ordine alfabetico orizzontalmente, piuttosto  che  dall’alto  in
              basso.
       show-all-if-ambiguous (Off)
              Questo  cambia  il  comportamento  di  default delle funzioni di
              completamento.  Se impostato a on, le parole che hanno più di un
              possibile  completamento  provocano la visualizzazione immediata
              delle  coincidenze  invece  che  l’attivazione  del  segnalatore
              acustico.
       show-all-if-unmodified (Off)
              Questo  cambia  il  comportamento  di  default delle funzioni di
              completamento in maniera  simile  a  show-all-if-ambiguous.   Se
              impostato  a  on,  le  parole  che  hanno  più  di  un possibile
              completamento  senza  alcun  possibile  completamento   parziale
              (ovvero  i  possibili  completamenti non hanno alcun prefisso in
              comune)  sono  elencate  immediatamente  invece  che   provocare
              l’attivazione del segnalatore acustico.
       visible-stats (Off)
              Se  impostato a On, un carattere che denota un tipo di file come
              riportato  da  stat(2)  è  accodato  al  nome  di  file  durante
              l’elencazione dei possibili completamenti.

   Costrutto condizionale di readline
       Readline  implementa  un servizio simile, nello spirito, a quello della
       compilazione condizionale  nel  preprocessore  C,  e  che  permette  di
       effettuare associazioni di tasti e impostazioni di variabili in base al
       risultato di test.  Vi sono tre direttive di controllo usate.

       $if    Il costrutto $if permette che le  associazioni  siano  fatte  in
              base  al modo di editing, al terminale in uso o all’applicazione
              che fa uso di readline.  Il testo da verificare arriva fino alla
              fine della riga; nessun carattere che lo delimiti è richiesto.

              mode   La forma mode= della direttiva $if è usata per verificare
                     se readline è in modo emacs  o  vi.   Questo  può  essere
                     usato  in  congiunzione  con  il  comando set keymap, per
                     esempio, per impostare le associazioni  delle  mappe  dei
                     tasti  di  emacs-standard e emacs-ctlx solo se readline è
                     avviata in modo emacs.

              term   La  forma  term=   può   essere   usata   per   includere
                     associazioni di tasti specifiche per un terminale, magari
                     per associare le  sequenze  di  tasti  emesse  dai  tasti
                     funzione dei terminali.  La parola a destra dell’ = viene
                     confrontata con il nome completo del terminale e la parte
                     del  nome  del  terminale che precede il primo -.  Questo
                     permette a sun di essere trovare corrispondenza  sia  con
                     sun che con sun-cmd, ad esempio.

              application
                     Il   costrutto   application   è   usato   per  includere
                     impostazioni  specifiche   per   un’applicazione.    Ogni
                     programma  che  usa  la libreria readline imposta il nome
                     applicazione, e un file di inizializzazione può poi  fare
                     un  test  per  un  particolare valore.  Questo può essere
                     usato per associare sequenze di tasti  a  funzioni  utili
                     per  uno  specifico  programma.   Per esempio, il comando
                     seguente aggiunge una sequenza  di  tasti  che  quota  la
                     parola corrente o la parola precedente in Bash:

                     $if Bash
                     # Quota la parola corrente o precedente
                     "\C-xq": "\eb\"\ef\""
                     $endif

       $endif Questo  comando,  come  si  è  visto nell’esempio precedente, fa
              terminare un comando $if.

       $else  I comandi in questa parte della direttiva $if sono  eseguiti  se
              il test non risulta verificato.

       $include
              Questa  direttiva  prende un unico nome di file come argomento e
              legge comandi e associazioni da  quel  file.   Per  esempio,  la
              seguente direttiva legge /etc/inputrc:

              $include  /etc/inputrc

   Ricerca
       Readline  è  dotato di comandi per cercare nella cronologia dei comandi
       (si veda CRONOLOGIA più avanti) righe contenenti una stringa specifica.
       Ci sono due modalità di ricerca: incrementale e non-incrementale.

       La  ricerca  incrementale  inizia  prima  che  l’utente abbia finito di
       immettere la stringa di ricerca.  Mentre ogni carattere  della  stringa
       di  ricerca  viene  battuto,  readline  mostra  la  prima  linea  dalla
       cronologia che corrisponde alla stringa battuta  finora.   Una  ricerca
       incrementale richiede solamente il numero minimo di caratteri necessari
       per  trovare  l’elemento  della  cronologia  desiderato.   I  caratteri
       presenti  nel valore della variabile isearch-terminators sono usati per
       delimitare una ricerca incrementale.  Se a quella variabile non è stata
       assegnato  un  valore i caratteri di Escape e Control-J fanno arrestare
       una   ricerca   incrementale.    Control-G   interrompe   una   ricerca
       incrementale  e  ripristina  la  riga originale.  Quando è terminata la
       ricerca, l’elemento della cronologia contenente la stringa  di  ricerca
       diventa la riga corrente.

       Per  trovare  altri  elementi  nell’elenco  della  cronologia,  battere
       Control-S o Control-R secondo il caso.  Viene eseguita così una ricerca
       all’indietro  o  in avanti nella cronologia del successivo elemento che
       corrisponde alla stringa di ricerca che è stata  immessa.   Ogni  altra
       sequenza  di  tasti  associata  a un comando readline pone termine alla
       ricerca ed esegue il comando presente nella  linea.   Per  esempio,  un
       newline  provoca  l’interruzione  della  ricerca  e  accetta  la  riga,
       eseguendo così il comando proveniente dall’elenco della cronologia.

       Readline ricorda l’ultima stringa  di  ricerca  incrementale.   Se  due
       Control-R  vengono  battuti  senza  che siano intervenuti caratteri che
       definiscono una nuova stringa di ricerca, viene utilizzata  la  stringa
       di ricerca memorizzata al momento.

       Le  ricerche non incrementali leggono l’intera stringa di ricerca prima
       di avviare la ricerca  per  individuare  righe  nella  cronologia.   La
       stringa  di  ricerca  può essere battuta dall’utente o essere parte del
       contenuto della riga corrente.

   Nomi di comando readline
       La seguente è una lista di nomi dei comandi e delle sequenze  di  tasti
       di  default  a  cui  essi  sono  collegati.   Nomi di comando senza una
       sequenza di tasti collegata a essi sono scollegati per default.   Nelle
       descrizioni  seguenti,  punto  si riferisce alla posizione corrente del
       cursore  e  marca  alla  posizione  del  cursore  salvata  col  comando
       set-mark.  Il testo fra il punto e la marca è indicato come regione.

   Comandi di movimento
       beginning-of-line (C-a)
              Si sposta all’inizio della riga corrente.
       end-of-line (C-e)
              Si sposta alla fine della riga.
       forward-char (C-f)
              Si sposta avanti di un carattere.
       backward-char (C-b)
              Si sposta indietro di un carattere.
       forward-word (M-f)
              Si  sposta in avanti fino alla fine della parola successiva.  Le
              parole  sono  composte  di  caratteri  alfanumerici  (lettere  e
              cifre).
       backward-word (M-b)
              Si   sposta   indietro   all’inizio   della  parola  corrente  o
              precedente.  Le parole sono composte di  caratteri  alfanumerici
              (lettere e cifre).
       clear-screen (C-l)
              Pulisce  lo  schermo  lasciando  la  riga  corrente in cima allo
              schermo.  Con un argomento, rinfresca  la  riga  corrente  senza
              ripulire lo schermo.
       redraw-current-line
              Rinfresca la riga corrente.

   Comandi per manipolare la cronologia
       accept-line (Newline, Return)
              Accetta la riga senza curarsi di dove sia il cursore.  Se questa
              riga non è vuota, è aggiunta  alla  lista  della  cronologia  in
              accordo  con lo stato della variabile HISTCONTROL.  Se la riga è
              una riga di cronologia modificata, allora ripristina la riga  di
              cronologia al suo stato originale.
       previous-history (C-p)
              Prende  il  precedente  comando  dalla  lista  della cronologia,
              spostandosi indietro nella lista.
       next-history (C-n)
              Prende il  successivo  comando  dalla  lista  della  cronologia,
              spostandosi avanti nella lista.
       beginning-of-history (M-<)
              Si sposta alla prima riga nella cronologia.
       end-of-history (M->)
              Si sposta alla fine della cronologia dell’input, cioè, alla riga
              che si sta inserendo.
       reverse-search-history (C-r)
              Cerca all’indietro partendo dalla riga corrente  spostandosi  in
              ‘su’  attraverso  la  cronologia  come necessario.  Questa è una
              ricerca incrementale.
       forward-search-history (C-s)
              Cerca in avanti partendo dalla riga corrente  e  spostandosi  in
              ‘giù’  attraverso  la  cronologia come necessario.  Questa è una
              ricerca incrementale.
       non-incremental-reverse-search-history (M-p)
              Cerca all’indietro attraverso la cronologia, partendo dalla riga
              corrente,  una  stringa  fornita dall’utente, usando una ricerca
              non incrementale.
       non-incremental-forward-search-history (M-n)
              Cerca in avanti attraverso la  cronologia  una  stringa  fornita
              dall’utente, usando una ricerca non incrementale.
       history-search-forward
              Cerca   in  avanti  attraverso  la  cronologia  una  stringa  di
              caratteri tra l’inizio  della  riga  corrente  e  il  punto  del
              cursore.  Questa è una ricerca non incrementale.
       history-search-backward
              Cerca  all’indietro  attraverso  la  cronologia  una  stringa di
              caratteri tra l’inizio  della  riga  corrente  e  il  punto  del
              cursore.  Questa è una ricerca non incrementale.
       yank-nth-arg (M-C-y)
              Inserisce    il   primo   argomento   del   comando   precedente
              (generalmente la seconda  parola  sulla  riga  precedente)  alla
              posizione  del cursore.  Con un argomento n, inserisce la n-sima
              parola del comando precedente (le parole nel comando  precedente
              iniziano  con  la parola 0).  Un argomento negativo inserisce la
              n-sima parola dalla fine del comando precedente.  Una volta  che
              l’argomento  n  è  calcolato,  l’argomento  è  estratto  come se
              l’espansione della cronologia "!n" sia stata specificata.
       yank-last-arg (M-., M-_)
              Inserisce l’ultimo argomento del  comando  precedente  (l’ultima
              parola  della precedente riga di cronologia).  Con un argomento,
              si comporta esattamente come yank-nth-arg.  Chiamate consecutive
              a    yank-last-arg    percorrono   l’elenco   della   cronologia
              all’indietro, inserendo ogni volta l’ultimo  argomento  di  ogni
              riga.  I servizi dell’espansione della cronologia sono usati per
              estrarre l’ultimo argomento, come  se  fosse  stata  specificata
              l’espansione della cronologia "!$".
       shell-expand-line (M-C-e)
              Espande la riga nello stesso modo in cui lo fa la shell.  Questo
              effettua l’espansione degli alias e della cronologia  così  come
              tutte  le  espansioni di parola della shell.  Si veda ESPANSIONE
              DELLA CRONOLOGIA più avanti per una descrizione  dell’espansione
              della cronologia.
       history-expand-line (M-^)
              Effettua  l’espansione della cronologia sulla riga corrente.  Si
              veda ESPANSIONE DELLA CRONOLOGIA più avanti per una  descrizione
              dell’espansione della cronologia.
       magic-space
              Effettua  l’espansione  della  cronologia  sulla riga corrente e
              inserisce uno spazio.  Si veda ESPANSIONE DELLA  CRONOLOGIA  più
              avanti per una descrizione dell’espansione della cronologia.
       alias-expand-line
              Effettua  l’espansione degli alias sulla riga corrente.  Si veda
              ALIAS sopra per una descrizione dell’espansione degli alias.
       history-and-alias-expand-line
              Effettua l’espansione della cronologia e degli alias sulla  riga
              corrente.
       insert-last-argument (M-., M-_)
              Un sinonimo di yank-last-arg.
       operate-and-get-next (C-o)
              Accetta  la  riga  corrente  per  l’esecuzione  e  prende  dalla
              cronologia la riga successiva a quella corrente, per  l’editing.
              Qualsiasi argomento viene ignorato.
       edit-and-execute-command (C-xC-e)
              Invoca  un  editor  sulla  riga di comando corrente ed esegue il
              risultato  come  comandi  di  shell.   Bash  tenta  di  invocare
              $FCEDIT, $EDITOR e emacs come editor, in quest’ordine.

   Comandi per cambiare il testo
       delete-char (C-d)
              Cancella  il  carattere  nel  punto  del cursore.  Se il punto è
              all’inizio della riga, non vi è alcun carattere  nella  riga,  e
              l’ultimo  carattere  battuto  non  era  associato a delete-char,
              allora ritorna EOF.
       backward-delete-char (Rubout)
              Cancella il  carattere  dopo  il  cursore.   Quando  è  dato  un
              argomento numerico, salva il testo cancellato sul kill-ring.
       forward-backward-delete-char
              Cancella  il  carattere  sotto il cursore, a meno che il cursore
              non sia alla fine della riga, nel qual caso il carattere  dietro
              al cursore viene cancellato.
       quoted-insert (C-q, C-v)
              Aggiunge  il  successivo  carattere  battuto  sulla riga in modo
              letterale.  Questo è il modo per inserire  caratteri  come  C-q,
              per esempio.
       tab-insert (C-v TAB)
              Inserisce un carattere tab.
       self-insert (a, b, A, 1, !, ...)
              Inserisce il carattere battuto.
       transpose-chars (C-t)
              Trascina  il  carattere  prima  del  punto del cursore in avanti
              sopra il carattere  nel  punto,  spostando  anche  il  punto  in
              avanti.   Se  il  punto  è  alla fine della riga, traspone i due
              caratteri  prima  del  punto.   Argomenti  negativi  non   hanno
              effetto.
       transpose-words (M-t)
              Trascina  la  parola  prima del punto del cursore dopo la parola
              oltre il punto, spostando inoltre il punto sopra quella  parola.
              Se  il  punto  è alla fine della riga, allora traspone le ultime
              due parole sulla riga.
       upcase-word (M-u)
              Rende  maiuscola  la  parola  corrente  (o  seguente).   Con  un
              argomento negativo, opera sulla parola precedente, ma non sposta
              il punto del cursore.
       downcase-word (M-l)
              Rende  minuscola  la  parola  corrente  (o  seguente).   Con  un
              argomento negativo, opera sulla parola precedente, ma non sposta
              il punto del cursore.
       capitalize-word (M-c)
              Rende maiuscola  la  prima  lettera  della  parola  corrente  (o
              seguente).   Con  un  argomento  negativo,  opera  sulla  parola
              precedente, ma non sposta il punto del cursore.
       overwrite-mode
              Alterna fra modalità inserimento e modalità  di  sovrascrittura.
              Con un argomento numerico esplicito positivo passa alla modalità
              sovrascrittura.   Con  un  argomento  numerico   esplicito   non
              positivo   passa  alla  modalità  inserimento.   Questo  comando
              riguarda solo la modalità emacs; la modalità vi  sovrascrive  in
              modo  diverso.   Ogni  chiamata  a  readline()  viene avviata in
              modalità inserimento.  In modalità  sovrascrittura  i  caratteri
              associati  a  self-insert  sostituiscono  il testo nel punto del
              cursore piuttosto che  sospingere  il  testo  verso  destra.   I
              caratteri  associati  a  backward-delete-char  sostituiscono  il
              carattere prima del punto con uno spazio.  Questo comando è  non
              associato per default.

   Eliminazione e recupero
       kill-line (C-k)
              Elimina  il  testo  dal  punto  del cursore fino alla fine della
              riga.
       backward-kill-line (C-x C-Rubout)
              Elimina all’indietro fino all’inizio della riga.
       unix-line-discard (C-u)
              Elimina all’indietro dal punto del cursore fino all’inizio della
              riga.  Il testo eliminato  viene salvato nel kill-ring
       kill-whole-line
              Elimina  tutti i caratteri sulla riga corrente, non importa dove
              sia il punto del cursore.
       kill-word (M-d)
              Elimina dal punto  del  cursore  fino  alla  fine  della  parola
              corrente,  o  se  tra  parole,  fino  alla fine della successiva
              parola.  I delimitatori di  parola  sono  gli  stessi  usati  da
              forward-word.
       backward-kill-word (M-Rubout)
              Elimina  la  parola dietro il punto del cursore.  I delimitatori
              di parole sono gli stessi usati da forward-word.
       unix-word-rubout (C-w)
              Elimina la parola dietro il punto del cursore, usando gli  spazi
              bianchi  come  delimitatori  di  parola.   Il  testo eliminato è
              salvato nel kill-ring.
       unix-filename-rubout
              Elimina la parola prima del punto del cursore, usando uno spazio
              bianco e il carattere barra [/] come delimitatori di parola.  Il
              testo eliminato è salvato nel kill-ring.
       delete-horizontal-space
              Cancella tutti gli spazi e i tab attorno al punto del cursore.
       kill-region
              Elimina il testo nella regione corrente.
       copy-region-as-kill
              Copia il testo nella regione sul kill buffer.
       copy-backward-word
              Copia la parola prima del punto del cursore sul kill buffer.   I
              delimitatori di parola sono gli stessi di backward-word.
       copy-forward-word
              Copia  la  parola  dopo il punto del cursore sul kill buffer.  I
              delimitatori di parola sono gli stessi di forward-word.
       yank (C-y)
              Copia il contenuto in cima al kill-ring e lo pone nel buffer nel
              punto del cursore.
       yank-pop (M-y)
              Ruota  il  kill-ring, e copia la nuova cima.  Funziona solo dopo
              yank o yank-pop.

   Argomenti numerici
       digit-argument (M-0, M-1, ..., M--)
              Aggiunge questa cifra all’argomento che sta già  accumulando,  o
              inizia un nuovo argomento.  M-- avvia un argomento negativo.
       universal-argument
              Questo  è  un  altro  modo  per specificare un argomento.  Se il
              comando è seguito da una o più cifre, opzionalmente con un segno
              meno  iniziale,  queste  cifre  definiscono  l’argomento.  Se il
              comando è seguito  da  cifre,  eseguendo  universal-argument  di
              nuovo  termina  l’argomento  numerico,  ma  a parte questo viene
              ignorato.  Come caso  speciale,  se  questo  comando  è  seguito
              immediatamente  da un carattere che che non è né una cifra né un
              segno  meno,  il  contatore  degli  argomenti  per  il   comando
              successivo   è   moltiplicato   per  quattro.   Il  contatore  è
              inizialmente uno, così eseguendo questa funzione la prima  volta
              il  contatore  diventa  quattro,  la  seconda volta il contatore
              diventa sedici, e così via.

   Completamento
       complete (TAB)
              Tenta di effettuare il completamento del testo  che  precede  il
              punto  del  cursore.   Bash  tenta il completamento trattando il
              testo, rispettivamente, come una variabile (se il  testo  inizia
              con  $),  nome  di  utente (se il testo comincia con ~), nome di
              host (se il testo comincia con @) o  comando  (inclusi  alias  e
              funzioni).   Se  nessuna  di questi produce una risultato, viene
              tentato il completamento del nome di file.
       possible-completions (M-?)
              Elenca i possibili completamenti del testo che precede il  punto
              del cursore.
       insert-completions (M-*)
              Inserisce  tutti  i completamenti del testo che precede il punto
              del    cursore    che    sarebbero     stati     generati     da
              possible-completions.
       menu-complete
              Simile  a  complete,  ma sostituisce la parola da completare con
              una   corrispondenza   singola   dalla   lista   dei   possibili
              completamenti.   Un’esecuzione  ripetuta di menu-complete scorre
              la   lista   dei   possibili   completamenti,   inserendo    una
              corrispondenza   alla   volta.    Alla   fine  della  lista  dei
              completamenti  viene  emesso  un  segnale  acustico  (dipendente
              dall’impostazione   di   bell-style)  e  il  testo  originale  è
              ripristinato.  Con un argomento n si sposta di  n  posizioni  in
              avanti  nella  lista  dei  completamenti individuati; può essere
              usato un argomento negativo per spostarsi all’indietro nella  la
              lista.   Questo comando è da associare normalmente al tasto TAB,
              però non è associato per default.
       delete-char-or-list
              Cancella  il  carattere  sotto  il  cursore  se  non  si   trova
              all’inizio  o alla fine della riga (simile a delete-char).  Se è
              alla  fine  della  riga,  si  comporta  in   modo   identico   a
              possible-completions.    Questo  comando  non  è  associato  per
              default.
       complete-filename (M-/)
              Tenta il completamento del nome del file sul testo  che  precede
              il punto del cursore.
       possible-filename-completions (C-x /)
              Elenca  i possibili completamenti del testo che precede il punto
              del cursore, trattandolo come un nome di file.
       complete-username (M-~)
              Tenta il completamento  del  testo  che  precede  il  punto  del
              cursore, trattandolo come un nome di utente.
       possible-username-completions (C-x ~)
              Elenca  i possibili completamenti del testo che precede il punto
              del cursore, trattandolo come un nome di utente.
       complete-variable (M-$)
              Tenta il completamento  del  testo  che  precede  il  punto  del
              cursore, trattandolo come una variabile di shell.
       possible-variable-completions (C-x $)
              Elenca  i possibili completamenti del testo che precede il punto
              del cursore, trattandolo come una variabile di shell.
       complete-hostname (M-@)
              Tenta il completamento  del  testo  che  precede  il  punto  del
              cursore, trattandolo come un nome di host.
       possible-hostname-completions (C-x @)
              Elenca  i possibili completamenti del testo che precede il punto
              del cursore, trattandolo come un nome di host.
       complete-command (M-!)
              Tenta il completamento del testo che precede punto del  cursore,
              trattandolo  come  nome di comando.  Il completamento di comando
              tenta di far  combaciare  il  testo  confrontandolo  con  alias,
              parole  riservate,  funzioni  di  shell,  comandi incorporati di
              shell e, da ultimo, nomi di file eseguibili, in quest’ordine.
       possible-command-completions (C-x !)
              Elenca i possibili completamenti del testo che precede il  punto
              del cursore, trattandolo come un nome di comando.
       dynamic-complete-history (M-TAB)
              Tenta  il  completamento  del  testo  che  precede  il punto del
              cursore, confrontando il testo con le righe  della  lista  della
              cronologia    cercando    le    possibili    corrispondenze   di
              completamento.
       complete-into-braces (M-{)
              Effettua il completamento del nome di file e insericse la  lista
              dei  possibili  completamenti  racchiusi  tra  parentesi graffe,
              rendendo la lista disponibile per la shell (si  veda  Espansione
              delle parentesi graffe sopra).

   Macro di tastiera
       start-kbd-macro (C-x ()
              Inizia  a  salvare  i  caratteri battuti nella corrente macro di
              tastiera.
       end-kbd-macro (C-x ))
              Smette di salvare i caratteri battuti nella  corrente  macro  di
              tastiera e memorizza la definizione.
       call-last-kbd-macro (C-x e)
              Riesegue  l’ultima  macro di tastiera definita, facendo sì che i
              caratteri nella macro appaiano come  se  fossero  stati  battuti
              sulla tastiera.

   Varie
       re-read-init-file (C-x C-r)
              Legge   il   contenuto   del  file  inputrc,  e  incorpora  ogni
              associazione o assegnamento di variabile che trova.
       abort (C-g)
              Annulla il corrente comando di  editing  ed  emette  il  segnale
              acustico   del   terminale   (dipendente   dall’impostazione  di
              bell-style).
       do-uppercase-version (M-a, M-b, M-x, ...)
              Se il carattere x battuto assieme al  tasto  Meta  è  minuscolo,
              esegue   il   comando   collegato  al  corrispondente  carattere
              maiuscolo.
       prefix-meta (ESC)
              Definisce come tasto Meta il successivo carattere battuto.   ESC
              f è equivalente a Meta-f.
       undo (C-_, C-x C-u)
              Undo incrementale, memorizzato separatamente per ogni riga.
       revert-line (M-r)
              Annulla tutti i cambiamenti fatti su questa riga.  Questo è come
              eseguire il comando  undo  un  numero  di  volte  sufficiente  a
              riportare la riga al suo stato iniziale.
       tilde-expand (M-&)
              Effettua l’espansione della tilde sulla parola corrente.
       set-mark (C-@, M-<space>)
              Imposta  la  marca  in corrispondenza del punto del cursore.  Se
              viene fornito un argomento numerico la marca viene  impostato  a
              quella posizione.
       exchange-point-and-mark (C-x C-x)
              Scambia  il  punto  del  cursore  con  la  marca.   La posizione
              corrente del cursore è impostata alla posizione  salvata,  e  la
              vecchia posizione del cursore è salvata come marca.
       character-search (C-])
              Viene  letto  un  carattere  e  il  punto del cursore è spostato
              all’occorrenza  successiva  di  quel  carattere.   Un  contatore
              negativo cerca occorrenze precedenti.
       character-search-backward (M-C-])
              Viene  letto  un  carattere  e  il  punto del cursore è spostato
              all’occorrenza  precedente  di  quel  carattere.   Un  contatore
              negativo cerca occorrenze successive.
       insert-comment (M-#)
              Senza  un  argomento numerico il valore della variabile readline
              comment-begin è inserito all’inizio della riga corrente.   Se  è
              fornito  un  argomento  numerico  questo  comando agisce come un
              interruttore:  se  i  caratteri  all’inizio   della   riga   non
              corrispondono  al  valore  di  comment-begin,  il  valore  viene
              inserito,  altrimenti  i  caratteri  in  comment-begin   vengono
              cancellati  dall’inizio  della riga.  In entrambi i casi la riga
              viene accettata come se fosse stato battuto un  codice  di  fine
              riga (newline).  Il valore di default di comment-begin fa sì che
              questo comando trasformi la riga  corrente  in  un  commento  di
              shell.   Se  un  argomento  numerico  provoca  la  rimozione del
              carattere di commento, la riga verrà eseguita dalla shell.
       glob-complete-word (M-g)
              La parola prima del punto del cursore è trattata come un modello
              per  l’espansione  del  percorso, con un asterisco aggiunto alla
              fine implicitamente.  Questo modello viene  usato  per  generare
              una   lista   di   nomi   di  file  corrispondenti  a  possibili
              completamenti.
       glob-expand-word (C-x *)
              La parola prima del punto del cursore è trattata come un modello
              per  l’espansione  del  percorso,  e  la  lista dei nomi di file
              individuati viene inserita, sostituendo  la  parola.   Se  viene
              fornito  un  argomento  numerico  viene  aggiunto  alla  fine un
              asterisco prima dell’espansione del percorso.
       glob-list-expansions (C-x g)
              Viene mostrata la lista delle  espansioni  che  sarebbero  state
              generate  da glob-expand-word e la riga è ridisegnata.  Se viene
              fornito un argomento numerico, un  asterisco  è  aggiunto  prima
              dell’espansione del percorso.
       dump-functions
              Stampa  tutte  le  funzioni  e le loro associazioni di tasti sul
              file di output di readline.  Se è fornito un argomento numerico,
              l’output  è  formattato in modo tale da poter essere inserito in
              un file inputrc.
       dump-variables
              Stampa tutte le variabili readline impostabili e i  loro  valori
              sul  file  di output di readline.  Se viene fornito un argomento
              numerico l’output è formattato in  modo  tale  da  poter  essere
              inserito in un file inputrc.
       dump-macros
              Stampa  tutte  le sequenze di tasti readline associate a macro e
              le stringhe da loro prodotte.  Se  viene  fornito  un  argomento
              numerico  l’uscita  è  formattata  in  modo tale da poter essere
              inserito in un file inputrc.
       display-shell-version (C-x C-v)
              Mostra l’informazione sulla versione della corrente  istanza  di
              bash.

   Completamento programmabile
       Quando  viene tentato il completamento della parola per un argomento di
       un comando per il quale una specifica di completamento  (una  compspec)
       è  stata  definita  col  comando  incorporato complete (si veda COMANDI
       INCORPORATI DELLA SHELL più avanti),  vengono  invocati  i  servizi  di
       completamento programmabile.

       Per prima cosa viene identificato il nome del comando.  Se un comspec è
       stato definito per quel comando, il comspec è  usato  per  generare  la
       lista  dei  possibili  completamenti  per  la  parola.   Se il nome del
       comando è un percorso completo di file, viene ricercato  per  primo  un
       comspec  per il percorso completo.  Se non viene trovato nessun comspec
       per il percorso completo  viene  fatto  un  tentativo  per  trovare  un
       comspec per la porzione che segue la barra [/] finale.

       Un volta trovato un comspec, questo è usato per generare la lista delle
       parole  corrispondenti.   Se  non  viene  trovato  un  comspec,   viene
       effettuato  il  completamento  di  bash  di  default  come descritto in
       precedenza, sotto Completamento.

       Per prima cosa, sono usate le azioni  specificate  dal  comspec.   Sono
       restituite  solo  le  corrispondenze  che  iniziano  con  la parola che
       dev’essere completata.  Quando viene usata l’opzione -f  o  -d  per  il
       completamento del nome di file o della directory, la variabile di shell
       FIGNORE è usata per filtrare le corrispondenze.

       In seguito, viene generato qualsiasi completamento  specificato  da  un
       modello  di  espansione  del  nome  di  file all’opzione -G.  Le parole
       generate dal modello  non  devono  necessariamente  corrispondere  alla
       parola che dev’essere completata.  La variabile di shell GLOBIGNORE non
       è usata per filtrare le corrispondenze, ma  viene  usata  la  variabile
       FIGNORE .

       In  seguito,  viene  considerata  la stringa specificata come argomento
       all’opzione -W.  La stringa è prima suddivisa usando i caratteri  nella
       variabile  speciale  IFS  come delimitatori.  È rispettata la quotatura
       della shell.  Ogni parola viene poi  espansa  usando  espansione  delle
       parentesi  graffe, espansione della tilde, espansione di parametro e di
       variabile, sostituzione  di  comando  ed  espansione  aritmetica,  come
       descritto  in precedenza, sotto ESPANSIONE.  I risultati sono suddivisi
       usando le regole sopra  descritte  sotto  Suddivisione  in  parole.   I
       risultati  dell’espansione sono confrontati con la parte iniziale della
       parola che dev’essere completata, e quelli che corrispondono  diventano
       i possibili completamenti.

       Dopo  che  queste  corrispondenze  sono  state generate, viene invocata
       qualsiasi funzione di shell o comando specificato con le opzioni  -F  e
       -C.   Quando  il  comando  o  funzione  viene  invocata, alle variabili
       COMP_LINE  e  COMP_POINT  sono  assegnati  valori  come  descritto   in
       precedenza, sotto Variabili di shell.  Quando una funzione di shell sta
       per essere invocata, le variabili COMP_WORDS  e  COMP_CWORD  sono  pure
       impostate.   Quando  viene  invocata  una  funzione o comando, il primo
       argomento è il nome del comando i cui argomenti sono stati  completati,
       il  secondo  argomento è la parola da completare e il terzo argomento è
       la parola che precede  la parola da completare sulla  riga  di  comando
       corrente.    Non   viene   effettuata  nessuna  azione  di  filtro  sui
       completamenti generati confrontandoli con la parola da  completare;  la
       funzione  o comando ha libertà completa nel generare le corrispondenze.

       Qualsiasi funzione specificata con -F viene  invocata  per  prima.   La
       funzione  può  usare  uno  qualsiasi  dei  servizi di shell, incluso il
       comando incorporato compgen  descritto  più  avanti,  per  generare  le
       corrispondenze.   la  funzione  deve  mettere i possibili completamenti
       della variabile di array COMPREPLY .

       In seguito,  qualsiasi  comando  specificato  con  l’opzione  -C  viene
       invocato  in  un  ambiente  equivalente  alla  sostituzione di comando.
       Questo dovrebbe stampare una lista  di  completamenti,  uno  per  riga,
       sullo standard output.  Un backslash può essere usato per proteggere un
       newline, se necessario.

       Una  volta  generati  tutti  i  possibili  completamenti,  ogni  filtro
       specificato  con  l’opzione -X viene applicato alla lista.  Il filtro è
       un modello come quello usato per l’espansione di percorso;  una  &  nel
       modello  è  sostituita  col  testo  della  parola da completare.  Una &
       letterale si può indicare con un backslash di protezione; il  backslash
       viene   rimosso  prima  della  ricerca  di  una  corrispondenza.   Ogni
       completamento che corrisponde al modello viene rimosso dalla lista.  Un
       !  iniziale  nega  il  modello;  in  questo caso ogni completamento non
       corrispondente al modello viene rimosso.

       Infine, qualsiasi prefisso e suffisso specificato dalle opzioni -  P  e
       -S è aggiunto a ogni membro della lista di completamento e il risultato
       è  restituito  al  codice  di  completamento  readline  come  lista  di
       completamenti possibili.

       Se le azioni precedentemente applicate non generano corrispondenze, e a
       complete era stata fornita  l’opzione  -o  dirnames  quando  era  stato
       definito   comspec,   viene  tentato  il  completamento  come  nome  di
       directory.

       Se a complete era stata fornita l’opzione -o plusdirs quando era  stato
       definito comspec, viene tentato il completamento come nomi di directory
       e qualunque corrispondenza è aggiunta ai risultati delle altre  azioni.

       Per  default,  se viene trovato un comspec, qualsiasi cosa generi viene
       restituito  al  codice  di  completamento  come  insieme  completo   di
       completamenti  possibili.   I  completamenti  di  bash  di  default non
       vengono tentati, e la readline di default del completamento del nome di
       file  è  disabilitata.  Se l’opzione -o bashdefault era stata fornita a
       complete al momento della definizione di comspec,  i  completamenti  di
       default   di   bash   vengono   tentati   se   il  comspec  non  genera
       corrispondenze.  Se l’opzione -o default era stata fornita  a  complete
       al  momento della definizione di comspec, i completamenti di default di
       readline  vengono  effettuati  se  il  comspec  (e,  se   tentato,   il
       completamento di default di bash) non genera corrispondenze.

       Quando un comspec indica che è desiderato il completamento come nome di
       directory, le funzioni di completamento programmabile forzano  readline
       ad  aggiungere  una  barra [/] ai nomi completati che sono collegamenti
       simbolici  a  directory,  dipendente  dal  valore  della  variabile  di
       readline  mark-directories,  indipendentemente  dall’impostazione della
       variabile di readline mark-symlinked-directories.

CRONOLOGIA

       Quando l’opzione - history del comando incorporato set è abilitata,  la
       shell  fornisce  l’accesso  alla  cronologia  dei comandi, la lista dei
       comandi precedentemente battuti.  Il valore della variabile HISTSIZE  è
       usata  come  numero di comandi da salvare nell’elenco della cronologia.
       Il testo degli ultimi HISTSIZE comandi (per default 500) viene salvato.
       La  shell  immagazzina  ogni comando nella lista della cronologia prima
       dell’espansione di parametro e di variabile (si veda ESPANSIONE  sopra)
       ma   dopo   che  è  stata  effettuata  l’espansione  della  cronologia,
       dipendente  dai  valori  delle  variabili   di   shell   HISTIGNORE   e
       HISTCONTROL.

       All’avvio,  la  cronologia  è  inizializzata  dal  file  indicato dalla
       variabile HISTFILE (per default ~/.bash_history).  Il file indicato dal
       valore di HISTFILE viene troncato, se necessario, per contenere non più
       del numero di righe specificate dal valore di  HISTFILESIZE  .   Quando
       una  shell  interattiva esce, le ultime $HISTSIZE righe vengono copiate
       dalla lista della cronologia  su  $HISTFILE.   Se  l’opzione  di  shell
       histappend  è  abilitata (si veda la descrizione di shopt sotto COMANDI
       INCORPORATI DELLA SHELL più avanti), le righe vengono accodate al  file
       della  cronologia,  in  caso  contrario  il file della cronologia viene
       sovrascritto.  Se HISTFILE non è impostato o il file della cronologia è
       non  scrivibile,  la cronologia non viene salvata.  Dopo il salvataggio
       della cronologia il file della cronologia è troncato per contenere  non
       più  di  HISTFILESIZE  righe.   Se HISTFILESIZE non è impostato, nessun
       troncamento viene effettuato.

       Il comando incorporato fc (si veda COMANDI INCORPORATI DELLA SHELL  più
       avanti)  può essere usato per elencare o editare e rieseguire una parte
       della lista della  cronologia.   Il  comando  incorporato  history  può
       essere  usato  per  mostrare  o  modificare la lista della cronologia e
       manipolare il file di cronologia.  Quando si usa l’editing  della  riga
       di  comando,  sono  disponibili  comandi  di ricerca in ciascun modo di
       editing che fornisce accesso alla lista della cronologia.

       La shell permette il controllo su quali  comandi  salvare  nella  lista
       della cronologia.  Le variabili HISTCONTROL e HISTIGNORE possono essere
       definite in modo tale che la  shell  salvi  solo  un  sottoinsieme  dei
       comandi  immessi.  L’opzione di shell cmdhist , se abilitata, fa sì che
       la shell tenti di salvare ogni  riga  di  un  comando  multiriga  nello
       stesso  elemento della cronologia, aggiungendo dei punti e virgola dove
       necessario per preservare  le  correttezza  sintattica.   L’opzione  di
       shell  lithist  chiede  alla shell di salvare i comandi con i codici di
       fine riga (newline) inclusi invece che separare i comandi con dei punti
       e  virgola.   Si  veda la descrizione del comando incorporato shopt più
       avanti, sotto COMANDI INCORPORATI DELLA SHELL per informazioni su  come
       definire e annullare le opzioni di shell.

ESPANSIONE DELLA CRONOLOGIA

       La  shell  ha  la capacità di espandere la cronologia in maniera simile
       all’espansione della cronologia in csh.   Questa  sezione  descrive  le
       possibilità  di  sintassi  disponibili.  Questa possibilità è abilitata
       per default per le shell interattive, e può essere disabilitata  usando
       l’opzione  +H  del comando incorporato set (si veda COMANDI INCORPORATI
       DELLA SHELL più avanti).   Le  shell  non  interattive  non  effettuano
       l’espansione della cronologia per default.

       Le  espansioni  della  cronologia  inseriscono parole dall’elenco della
       cronologia nel flusso di input, agevolando la ripetizione  di  comandi,
       l’inserimento  di  argomenti  di comandi precedenti nella riga di input
       corrente, o la correzione rapida di errori in comandi già immessi.

       L’espansione della cronologia è effettuata immediatamente dopo che  una
       riga  completa  è  stata letta, prima che la shell la divida in parole.
       Essa ha luogo in due parti.  La prima  è  per  determinare  quale  riga
       dall’elenco della cronologia usare durante la sostituzione.  La seconda
       è per  selezionare  parti  di  quella  riga  da  includere  nella  riga
       corrente.   La riga selezionata dalla cronologia è l’evento, e la parte
       di quella riga su cui si agisce sono le parole.   Diversi  modificatori
       sono  disponibili  per  manipolare  le  parole  selezionate.  La riga è
       spezzata in parole allo stesso modo che quando è letta in  input,  così
       che  più  parole  separate  da  metacarattericircondate da caratteri di
       quotatura sono considerate come una sola parola.  Le  espansioni  della
       cronologia iniziano con la comparsa di un carattere di espansione della
       cronologia, che è ! per default.  Solo il backslash (\) e gli apostrofi
       possono quotare il carattere di espansione della cronologia.

       Diversi  caratteri  inibiscono  l’espansione  della  cronologia  quando
       trovati  immediatamente  dopo  il   carattere   di   espansione   della
       cronologia,  anche  se  non  quotato: spazio, carattere di tabulazione,
       newline, carriage  return  e  =.   Se  l’opzione  di  shell  estglob  è
       abilitata, anche ( inibisce l’espansione.

       Diverse  opzioni  di  shell  impostabili  col comando incorporato shopt
       possono essere usate per influenzare il  comportamento  dell’espansione
       della  cronologia.   Se  l’opzione  di shell histverify è abilitata (si
       veda la descrizione del comando incorporato shopt ), e  si  sta  usando
       readline  ,  le  sostituzioni  della  cronologia  non  vengono  passate
       immediatamente all’analizzatore della shell.  Invece, la riga espansa è
       ricaricata  nel  buffer di editing di readline per ulteriori modifiche.
       Se si sta usando readline ed è abilitata l’opzione di shell  histreedit
       ,  una  sostituzione  di  cronologia  non completata con successo viene
       ricaricata nel buffer di  editing  di  readline  per  essere  corretta.
       L’opzione -p al comando incorporato history può essere usata per vedere
       cosa farebbe un’espansione della cronologia prima  di  usarla  davvero.
       L’opzione  -s  del  comando  incorporato  history  può essere usata per
       aggiungere  comandi  alla  fine  della  lista  della  cronologia  senza
       eseguirli   veramente,   in  modo  che  siano  disponibili  per  essere
       richiamati in un secondo tempo.  La shell  permette  il  controllo  dei
       vari  caratteri usati dal meccanismo di espansione della cronologia (si
       veda la precedente descrizione di histchars sotto Variabili di  shell).

   Designatore di evento
       Un  designatore  di  evento  è  un riferimento a un elemento di riga di
       comando nella lista della cronologia.

       !      Inizia una sostituzione di cronologia, tranne quando seguita  da
              un  blank,  newline, carriage return, = o ( (quando l’opzione di
              shell extglob è abilitata usando il comando incorporato  shopt).
       !n     Designa la riga di comando n.
       !-n    Designa la riga di comando corrente meno n.
       !!     Designa  il comando precedente.  Questo è un sinonimo per ‘!-1’.
       !stringa
              Designa il comando più recente che inizia con stringa.
       !?stringa[?]
              Designa il comando più  recente  che  contiene  stringa.   Il  ?
              finale  può essere omesso se stringa è seguita immediatamente da
              un codice di fine riga (newline).
       ^string1^string2^
              Sostituzione  rapida.   Ripete  l’ultimo  comando,  rimpiazzando
              stringa1        con        stringa2.         Equivalente       a
              ‘‘!!:s/stringa1/stringa2/’’ (si veda Modificatori più avanti).
       !#     L’intera riga di comando battuta fino a questo punto.

   Designatori di parola
       I designatori di parola sono usati per selezionare parole  dall’evento.
       Un  :  separa  la  specificazione  di evento dal designatore di parola.
       Esso può essere omesso se il designatore di parola inizia con un ^,  $,
       *,  -  o  %.   Le parole sono numerate dall’inizio della riga, la prima
       parola essendo denotata da uno 0 (zero).  Le parole sono inserite nella
       riga corrente separate da spazi singoli.

       0 (zero)
              La  parola  numero  zero.   Per la shell, questa è la parola che
              costituisce il nome del comando.
       n      La n-esima parola.
       ^      Il primo argomento.  Cioè, la parola 1.
       $      L’ultimo argomento.
       %      La  parola  che  combacia  con  ‘?stringa?’  nella  più  recente
              ricerca.
       x-y    Un intervallo di parole; ‘-y’ abbrevia ‘0-y’.
       *      Tutte le parole tranne la numero zero.  Questo è un sinonimo per
              ‘1-$’.  Non è un  errore  usare  *  se  vi  è  solo  una  parola
              nell’evento; in quel caso il risultato è una stringa vuota.
       x*     Abbrevia x-$.
       x-     Abbrevia x-$ come x*, ma omette l’ultima parola.

       Se  un  designatore  di  parola  è  fornito senza una specificazione di
       evento, il comando precedente viene usato come evento.

   Modificatori
       Dopo l’opzionale designatore di parola, può comparire una  sequenza  di
       uno o più fra i seguenti modificatori, ognuno preceduto da un ‘:’.

       h      Rimuove  un componente finale in un nome di file, lasciando solo
              la testa.
       r      Rimuove un suffisso finale della forma .xxx, lasciando  il  nome
              base (basename).
       e      Rimuove tutto tranne il suffisso finale.
       t      Rimuove tutti i componenti di testa in un percorso, lasciando la
              coda.
       p      Stampa il nuovo comando ma non lo esegue.
       q      Quota le parole sostituite, prevenendo ulteriori sostituzioni.
       x      Quota le parole sostituite, come con q, ma spezza in parole  sui
              blank e newline.
       s/vecchio/nuovo/
              Sostituisce nuovo alla prima occorrenza di vecchio nella riga di
              evento.  Qualsiasi delimitatore può essere usato al posto di  /.
              Il  delimitatore finale è opzionale se esso è l’ultimo carattere
              della riga di evento.  Il delimitatore  può  essere  quotato  in
              vecchio  e  nuovo  con  un  singolo  backslash.  Se compare & in
              nuovo, esso è sostituito da vecchio.  Un singolo backslash quota
              il  carattere &.  Se vecchio è nullo, viene impostato all’ultimo
              vecchio sostituito o, se nessuna sostituzione  di  cronologia  è
              avvenuta, l’ultima stringa in una ricerca di !?stringa[?]
       &      Ripete la precedente sostituzione.
       g      Fa  sì  che  i  cambiamenti  siano applicati sull’intera riga di
              evento.   Questo  si  usa  in  congiunzione  con  ‘:s’   (p.es.,
              ‘:gs/vecchio/nuovo/’)  o  ‘:&’.   Se  usato  con ‘:s’, qualsiasi
              delimitatore può essere usato al posto di /, e  il  delimitatore
              finale è opzionale se è l’ultimo carattere della riga di evento.
              Un a può essere usato come sinonimo di g.
       G      Applica il modificatore che segue ‘s’ una volta  a  ogni  parola
              nella riga di evento.

COMANDI INCORPORATI DELLA SHELL

       Se  non  diversamente indicato, ogni comando incorporato documentato in
       questa sezione, il quale accetti opzioni precedute da -  ,  accetta  --
       per indicare la fine delle opzioni.  Per esempio, i comandi incorporati
       :, true, false e test non accettano opzioni.
       : [argomenti]
              Nessun effetto; il comando non fa  niente,  tranne  l’espansione
              degli   argomenti   e   l’effettuazione   di   ogni  ridirezione
              specificata.  È ritornato un codice di uscita zero.

        .  nomefile [argomenti]
       source nomefile [argomenti]
              Legge ed esegue comandi  dal  nomefile  nell’ambiente  di  shell
              corrente   e  ritorna  lo  stato  d’uscita  dell’ultimo  comando
              eseguito contenuto in nomefile.  Se nomefile  non  contiene  una
              barra  [/],  i  percorsi  in  PATH  sono  usati  per  trovare la
              directory contenente nomefile.  Il file cercato in PATH  non  ha
              bisogno di essere marcato come eseguibile.  Quando bash non è in
              modalit posix, viene ricercata la directory corrente se  nessun
              file viene trovato in PATH.  Se l’opzione sourcepath del comando
              incorporato shopt è disattivata, il PATH  non  viene  usato  per
              ricercare.   Se  sono  forniti degli argomenti, essi diventano i
              parametri posizionali quando nomefile è eseguito.  Altrimenti  i
              parametri posizionali sono inalterati.  Lo stato di ritorno è lo
              stato dell’ultimo comando  terminato  dentro  lo  script  (0  se
              nessun  comando  è  eseguito),  e  falso  se  nomefile non viene
              trovato o non può essere letto.

       alias [-p] [nome[=valore] ...]
              Alias senza argomenti o con l’opzione -p stampa la  lista  degli
              alias  nella  forma  alias  nome=valore  sullo  standard output.
              Quando sono forniti argomenti, viene definito un alias per  ogni
              nome per cui è dato il valore.  Uno spazio finale a valore fa sì
              che la parola seguente sia controllata per  la  sostituzione  di
              alias  quando  l’alias  è espanso.  Per ogni nome nella lista di
              argomenti per cui nessun valore è fornito, è stampato il nome  e
              il  valore  dell’alias.  Alias  ritorna  0 [vero] a meno che non
              venga dato un nome per il quale nessun alias è stato definito.

       bg [jobspec ...]
              Riprende ogni job sospeso jobspec in background, come  se  fosse
              stato  avviato con &.  Se jobspec non è presente, è usata quello
              che la shell considera  essere  il  job  corrente.   bg  jobspec
              ritorna  0  tranne  quando  viene  eseguito  con  il job-control
              disabilitato o, se eseguito con  il  job-control  abilitato,  se
              jobspec  non  è stato trovato o è stato avviato senza usare job-
              control.

       bind [-m keymap] [-lpsvPSV]
       bind [-m keymap] [-q funzione] [-u funzione] [-r keyseq]
       bind [-m keymap] -f nomefile
       bind [-m keymap] -x keyseq:comando di shell
       bind [-m keymap] keyseq:nome-funzione
       bind comando readline
              Mostra le correnti associazioni di tasti e funzioni di readline,
              associa una sequenza di tasti a una funzione o macro di readline
              o imposta una variabile readline .  Ogni argomento che  non  sia
              un’opzione  è  un  comando  come  apparirebbe  in  .inputrc,  ma
              ciascuna  associazione  deve  essere  passata   come   argomento
              separato;  per  esempio,  ’"\C-x\C-r":  re-read-init-file´.   Le
              opzioni, se fornite, hanno i seguenti significati:
              -m keymap
                     Usa keymap come mappatura della  tastiera  da  modificare
                     nelle  successive  associazioni.   I nomi accettabili per
                     keymap   sono    emacs,    emacs-standard,    emacs-meta,
                     emacs-ctlx,  vi,  vi-move,  vi-command e vi-insert.  vi è
                     equivalente  a  vi-command;   emacs   è   equivalente   a
                     emacs-standard.
              -l     Elenca i nomi di tutte le funzioni di readline.
              -p     Mostra  i  nomi  delle  funzioni di readline e delle loro
                     associazioni in modo tale che possano essere riletti.
              -P     Elenca i nomi delle funzioni di readline  correnti  e  le
                     loro associazioni.
              -v     Mostra i nomi delle variabili di readline e i loro valori
                     in modo tale che possano essere riletti.
              -V     Elenca i nomi delle variabili di readline  correnti  e  i
                     loro valori.
              -s     Mostra  sequenze di tasti di readline associati a macro e
                     le stringhe risultanti in modo tale  che  possano  essere
                     rilette.
              -S     Mostra  sequenze di tasti di readline associate a macro e
                     le stringhe risultanti.
              -f nomefile
                     Legge le associazioni dei tasti dal file nomefile.
              -q funzione
                     Chiede quali tasti invocano la funzione indicata.
              -u funzione
                     Dissocia tutti i tasti associati alla funzione  indicata.
              -r keyseq
                     Rimuove qualsiasi associazione corrente per keyseq.
              -x keyseq:comando di shell
                     Provoca  l’esecuzione  di comando di shell ogni volta che
                     viene immesso keyseq.

              Il valore di ritorno è 0 tranne quando si  specifica  un’opzione
              non riconosciuta o è avvenuto un errore.

       break [n]
              Esce dall’interno di un ciclo for, while, until o select .  Se n
              è specificato, interrompe n livelli.  n deve essere ≥ 1.  Se n è
              più  grande  del  numero  di  cicli  racchiusi,  tutti  i  cicli
              racchiusi vengono terminati.  Il valore di ritorno  è  0  tranne
              quando  la  shell  non sta eseguendo un ciclo quando break viene
              eseguito.

       builtin comando-incorporato [argomenti]
              Esegue  il  comando  incorporato  specificato,  passandogli  gli
              argomenti,  e  ritorna  il  suo  stato d’uscita.  Questo è utile
              quando si desidera definire una funzione il cui nome è lo stesso
              di un comando incorporato della shell, ottenendo la funzionalità
              del comando incorporato  attraverso  la  funzione.   Il  comando
              incorporato  cd  è  comunemente  ridefinito  in questo modo.  Lo
              stato di ritorno è falso se comando-incorporato non è un comando
              incorporato della shell.

       cd [-L|-P] [dir]
              Cambia  la  directory  corrente con dir.  La variabile HOME è il
              dir di default.  La variabile CDPATH  definisce  i  percorsi  di
              ricerca  per le directory che contengano dir.  Nomi di directory
              alternative in CDPATH sono separate da due punti (:).   Un  nome
              di directory nullo in CDPATH indica la directory corrente, cioè,
              ‘‘.’’.  Se dir inizia con una barra [/],  allora  CDPATH  non  è
              usato.   L’opzione  -P  dice  di usare la struttura di directory
              fisica invece di seguire i collegamenti simbolici (si veda anche
              l’opzione  -P del comando incorporato set ; l’opzione -L forza a
              seguire i collegamenti simbolici.  Un argomento - è  equivalente
              a $OLDPWD.  Se viene usato il nome di una directory non vuota da
              CDPATH o se  -  è  il  primo  argomento,  e  il  cambiamento  di
              directory   ha   successo,  il  percorso  completo  della  nuova
              directory di lavoro viene scritto  sullo  standard  output.   Il
              valore  di  ritorno  è 0 [vero] se la directory è stata cambiata
              con successo; falso altrimenti.

       caller [expr]
              Restituisce il contesto  di  qualsiasi  chiamata  di  subroutine
              attiva  (una funzione di shell o uno script eseguito coi comandi
              incorporati .  o source.  Senza expr, il caller mostra il numero
              di  riga  e  il  nome  di  file  di  origine  della  chiamata di
              subroutine corrente.  Se è fornito un intero non  negativo  come
              expr,  caller  mostra il numero di riga, il nome di subroutine e
              il file di origine corrispondente a quella posizione nello stack
              delle  chiamate  di  esecuzione.  Questa informazione aggiuntiva
              può essere usata, per esempio, per stampare uno stack trace.  Il
              frame  corrente  è  il frame 0.  Il valore di ritorno è 0 tranne
              quando la shell sta  eseguendo  una  chiamata  di  subroutine  o
              quando  expr  non corrisponde a una posizione valida nello stack
              delle chiamate.

       command [-pVv] comando [arg ...]
              Esegue comando con gli arg sopprimendo la normale ricerca tra le
              funzione  di  shell.  Sono eseguiti solo i comandi incorporati o
              comandi trovati in PATH.  Se  è  specificata  l’opzione  -p,  la
              ricerca  di comando viene effettuata usando un valore di default
              per PATH usando il quale è garantito che siano trovate tutte  le
              utilità  standard.   Se  è  fornita  l’opzione  -V  o  -v, viene
              stampata una descrizione di comando.  L’opzione  -v  provoca  la
              visualizzazione di una singola parola che indica il comando o il
              nome di file usato per invocare comando;  l’opzione  -V  produce
              una  descrizione più completa.  Se è fornita l’opzione -V o -v ,
              lo  stato  d’uscita  è  0  se  comando  è  stato  trovato,  e  1
              altrimenti.  Se nessuna delle due opzioni è fornita e avviene un
              errore o comando non può essere trovato,  lo  stato  d’uscita  è
              127.   Altrimenti,  lo  stato  d’uscita  del comando incorporato
              command è lo stato d’uscita di comando.

        compgen [opzione] [parola]
              Genera possibili corrispondenze di completamento per  parola  in
              accordo  con  le  opzioni,  che possono essere qualsiasi opzione
              accettata dal comando incorporato complete ad eccezione di -p  e
              -r, e scrive le corrispondenze sullo standard output.  Quando si
              usano le  opzioni  -F  o  -C,  le  diverse  variabili  di  shell
              impostate  dai  servizi di completamento programmabile, anche se
              disponibili, non conterranno valori utili.

              Le  corrispondenze  saranno  generate  come  se  il  codice   di
              completamento  programmabile  le avesse generate direttamente da
              una specifica di completamento con gli stessi  flag.   Se  viene
              specificata   parola,  vengono  mostrati  solo  i  completamenti
              disponibili per parola.

              Il valore di ritorno è 0 [vero],  tranne  quando  viene  fornita
              un’opzione   non   valida,   o   non   viene   generata   alcuna
              corrispondenza.

       complete [-abcdefgjksuv] [-o comp-option] [-A azione] [-G globpat]  [-W
       wordlist] [-P prefisso] [-S suffisso]
              [-X filterpat] [-F funzione] [-C comando] nome [nome ...]
       complete -pr [nome ...]
              Specifica come devono essere completati gli argomenti  per  ogni
              nome.   Se  viene  fornita  l’opzione  -p o se non viene fornita
              alcuna opzione, le specifiche di  completamento  esistenti  sono
              stampate  in  modo  tale  da  essere  riutilizzabili come input.
              L’opzione -r rimuove una specifica  di  completamento  per  ogni
              nome  o,  se  non  è  fornito alcun nome, tutte le specifiche di
              completamento.

              Il processo per applicare  queste  specifiche  di  completamento
              quando  si  tenta  il  completamento della parola è descritto in
              precedenza, sotto  Completamento programmabile.

              Altre opzioni, se specificate,  hanno  i  seguenti  significati.
              Gli  argomenti alle opzioni  -G, -W, e -X (e, se necessario alle
              opzioni  -P e -S)  dovrebbero  essere  quotati  per  proteggerli
              dall’espansione  prima che venga invocato il comando incorporato
              complete .
              -o comp-option
                      L’opzione  comp-option  controlla  diversi  aspetti  del
                      comportamento  di  comspec oltre la semplice generazione
                      di completamenti.  comp-option può essere uno di questi:
                      bashdefault
                              Effettua  il  resto dei completamenti di default
                              di bash se comspec non genera corrispondenze.
                      default Usa il completamento del nome di file di default
                              di    readline    se    comspec    non    genera
                              corrispondenze.
                      dirnames
                              Effettua il completamento del nome di  directory
                              se comspec non genera corrispondenze.
                      filenames
                              Dice  a  readline  che il comspec genera nomi di
                              file, consentendo così di  effettuare  qualsiasi
                              elaborazione di uno specifico nome di file (come
                              aggiungere una barra [/] ai nomi di directory  o
                              sopprimere  gli spazi finali).  Fatto per essere
                              usato con le funzioni di shell.
                      nospace Dice a readline di  non  aggiungere  uno  spazio
                              (che  viene  aggiunto  per  default) alle parole
                              completate alla fine della riga.
                      plusdirs
                              Dopo che le corrispondenze definite  da  comspec
                              sono    state   generate,   viene   tentato   il
                              completamento  dei  nomi  di  directory   e   il
                              risultato  viene  aggiunto  ai  risultati  delle
                              altre azioni.
              -A azione
                      L’azione pu essere una delle seguenti per generare  una
                      lista di possibili completamenti:
                      alias   Nome  di  alias.   Può  anche essere specificata
                              come -a.
                      arrayvar
                              Nomi di variabili di array.
                      binding Nomi di associazioni di tasti Readline.
                      builtin Nomi di comandi incorporati  della  shell.   Può
                              anche essere specificata come -b.
                      command Nomi  di  comandi.  Può anche essere specificata
                              come -c.
                      directory
                              Nomi di directory.  Può anche essere specificata
                              come -d.
                      disabled
                              Nomi   di   comandi   incorporati   della  shell
                              disabilitati.
                      enabled Nomi  di   comandi   incorporati   della   shell
                              abilitati.
                      export  Nomi di variabili di shell esportate.  Può anche
                              essere specificata come -e.
                      file    Nomi di file.  Può anche essere specificata come
                              -f.
                      function
                              Nomi di funzioni di shell.
                      group   Nomi  di  gruppo.   Può anche essere specificata
                              come -g.
                      helptopic
                              Argomenti di aiuto come  accettati  dal  comando
                              incorporato help.
                      hostname
                              Nomi  di  host,  come presi dal file specificato
                              dalla variabile di shell HOSTFILE .
                      job     Nomi di job, se il job-control  è  attivo.   Può
                              anche essere specificata come -j.
                      keyword Parole  riservate della shell.  Può anche essere
                              specificata come -k.
                      running Nomi di job in esecuzione, se il  job-control  è
                              attivo.
                      service Nome  di  servizi.  Può anche essere specificata
                              come -s.
                      setopt  Argomenti validi per l’opzione  -o  del  comando
                              incorporato set.
                      shopt   Nomi  di  opzioni  di  shell  come accettati dal
                              comando incorporato shopt.
                      signal  Nomi di segnali
                      stopped Nomi di job sospesi, se il job-control è attivo.
                      user    Nomi  di  utente.   Può anche essere specificata
                              come -u.
                      variable
                              Nomi di variabili di shell.   Può  anche  essere
                              specificata come -v.
              -G globpat
                      Il  modello di espansione dei nomi di file globpat viene
                      espanso per generare i possibili completamenti.
              -W wordlist
                      La  wordlist  è  suddivisa  usando  i  caratteri   nella
                      variabile   speciale  IFS  come  delimitatori,  e  viene
                      espansa   ogni   parola   risultante.     I    possibili
                      completamenti  sono  gli elementi della lista risultante
                      che sono appropriati per la parola da completare.
              -C comando
                      comando viene eseguito in un ambiente di subshell, e  il
                      suo   output   viene   usato  come  lista  di  possibili
                      completamenti.
              -F funzione
                      La   funzione   di   shell   funzione   viene   eseguita
                      nell’ambiente  di  shell  corrente.   Quando  finisce, i
                      possibili completamenti sono a disposizione  nei  valori
                      della variabile di array COMPREPLY .
              -X filterpat
                      filterpat   è   un   modello   come   quelli  usati  per
                      l’espansione del nome di file.  È  applicato  all’elenco
                      dei  possibili  completamenti  generati  dalle opzioni e
                      dagli argomenti precedenti,  e  ogni  completamento  che
                      corrisponde a filterpat viene rimosso dall’elenco.  Un !
                      iniziale in filterpat nega il modello;  in  questo  caso
                      ogni  completamento che non concorda con filterpat viene
                      rimosso.
              -P prefisso
                      prefisso  è  aggiunto  all’inizio  di   ogni   possibile
                      completamento  dopo  che  sono  state applicate tutte le
                      altre opzioni.
              -S suffisso
                      suffisso  è  aggiunto  alla  fine  di   ogni   possibile
                      completamento  dopo  che  sono  state applicate tutte le
                      altre opzioni.

              Il valore di ritorno è 0  [vero]  tranne  quando  viene  fornita
              un’opzione  non  valida, viene fornita un’opzione all’infuori di
              -p o - r senza un argomento nome, vien  fatto  un  tentativo  di
              rimuovere  una  specifica  di  completamento  per un nome per il
              quale non vi  sono  specifiche,  o  se  si  verifica  un  errore
              aggiungendo una specifica di completamento.

       continue [n]
              Riprende  la successiva iterazione del ciclo for, while, until o
              select dentro cui  si  trova.   Se  n  è  specificato,  riprende
              all’n-esima nidificazione del ciclo.  n deve essere ≥ 1.  Se n è
              più grande del numero di cicli nidificati, riprende  dall’ultimo
              ciclo  esistente  (il  ciclo  a più alto livello).  Il valore di
              ritorno è 0 tranne quando la shell non si trova  all’interno  di
              un ciclo quando continue è eseguito.

       declare [-afFirtx] [-p] [nome[=valore] ...]
       typeset [-afFirtx] [-p] [nome[=valore] ...]
              Dichiara  variabili e/o dà loro degli attributi.  Se il è nome è
              omesso, mostra i valori delle variabili.   L’opzione  -p  mostra
              gli  attributi e i valori di ogni nome.  Quando viene usato -p ,
              vengono ignorate opzioni addizionali.  L’opzione -F inibisce  la
              visualizzazione  delle definizioni di funzione; vengono stampati
              solo il nome della funzione e i suoi attributi.  Se l’opzione di
              shell  extdebug è abilitata con shopt, il nome di file d’origine
              e il numero di riga dov’è definita la funzione vengono anch’esse
              visualizzati.   L’opzione  -F sottintende -f Le seguenti opzioni
              possono  essere  usate  per  restringere  l’output   alle   sole
              variabili   con   gli  attributi  specificati  o  per  assegnare
              attributi di variabili.
              -a     Ogni nome è una variabile di array (si veda Array sopra).
              -f     Usa solo nomi di funzioni.
              -i     La  variabile  è  trattata come un intero; la valutazione
                     aritmetica (si veda VALUTAZIONE ARITMETICA ) è effettuata
                     quando alla variabile è assegnato un valore.
              -r     Rende  nomi  accessibili  in sola lettura.  A questi nomi
                     non possono quindi essere assegnati valori da  successive
                     istruzioni  di  assegnamento,  e  i  valori assegnati non
                     possono essere rimossi.
              -t     Dà a ogni nome l’attributo trace.  Le funzioni  tracciate
                     ereditano  i  segnali  intercettati  DEBUG e RETURN dalla
                     shell chiamante.  L’attributo trace non ha un significato
                     speciale per le variabili.
              -x     Marca  nomi  per  l’esportazione  ai  successivi  comandi
                     attraverso l’ambiente.

              Usare ‘+’ invece di ‘-’ disattiva l’attributo,  con  l’eccezione
              che  +a  non può essere usato per eliminare una variabile array.
              Quando usato in una funzione, rende ogni nome locale,  come  con
              il  comando  local  .   Se  un  nome  di  variabile è seguito da
              =valore, il valore della variabile è  impostato  a  valore.   Il
              valore  di ritorno è 0 tranne quando viene incontrata un’opzione
              non valida, vien fatto un tentativo  di  definire  una  funzione
              usando  ‘‘-f foo=bar’’, vien fatto un tentativo per assegnare un
              valore a una variabile in sola lettura, vien fatto un  tentativo
              per  assegnare  un  valore  a una variabile array senza usare la
              sintassi di assegnamento composto (si veda Array sopra), uno dei
              nomi  non  è un nome valido di variabile di shell, vien fatto un
              tentativo per disattivare lo  stato  di  sola  lettura  per  una
              variabile   in   sola  lettura,  vien  fatto  un  tentativo  per
              disattivate lo stato di array per una variabile  array,  o  vien
              fatto  un  tentativo per mostrare una funzione non esistente con
              -f.

       dirs [-clpv] [+n] [-n]
              Senza opzioni, mostra la  lista  delle  directory  correntemente
              memorizzate.  La visualizzazione di default è su un singola riga
              coi nomi di directory separate  da  spazi.   Le  directory  sono
              aggiunte  alla  lista  con  il  comando  pushd;  il comando popd
              rimuove elementi dalla lista.
              +n     Mostra l’n-esimo elemento contando dalla  sinistra  della
                     lista  mostrata  da dirs quando è chiamato senza opzioni,
                     partendo da zero.
              -n     Mostra l’n-esimo elemento  contando  dalla  destra  della
                     lista  mostrata  da dirs quando è chiamato senza opzioni,
                     partendo da zero.
              -c     Svuota lo stack delle  directory  cancellando  tutti  gli
                     elementi.
              -l     produce  un  elenco  più lungo; il formato di default per
                     l’elencazione usa un carattere tilde per indicare la home
                     directory.
              -p     Stampa lo stack delle directory con un elemento per riga.
              -v     Stampa lo stack delle directory con un elemento per riga,
                     anteponendo a ogni elemento il suo indice nello stack.

              Il  valore di ritorno è 0 tranne quando viene fornita un’opzione
              non valida o n  un  indice  oltre  la  fine  dello  stack  delle
              directory.

       disown [-ar] [-h] [jobspec ...]
              Senza  opzioni, ogni jobspec viene rimosso dalla tabella dei job
              attivi.  Se viene data l’opzione  -h,  ogni  jobspec  non  viene
              rimosso dalla tabella, ma è marcato in modo che SIGHUP non venga
              inviato al job se la shell riceve un SIGHUP .  Se non è presente
              alcun  jobspec  e non viene fornita né l’opzione -a né l’opzione
              -r , viene usato il job corrente.  Se non è  specificata  alcuna
              jobspec  l’opzione  -a  richiede la rimozione o il marcamento di
              tutti i job; l’opzione -r senza un argomento  jobspec  restringe
              l’operazione  ai  job  in  esecuzione.  Il valore di ritorno è 0
              tranne quando jobspec non specifica un job valido.

       echo [-neE] [arg ...]
              Emette gli arg, separati da spazi, seguiti da  un  newline.   Lo
              stato  di  ritorno  è sempre 0.  Se è specificato -n, il newline
              finale è soppresso.  Se è data  l’opzione  -e,  viene  abilitata
              l’interpretazione   dei   successivi   caratteri  preceduti  dal
              carattere di  protezione  backslash.   L’opzione  -E  disabilita
              l’interpretazione  di  questi  caratteri di protezione, anche su
              sistemi dove essi sono interpretati per default.   L’opzione  di
              shell xpg_echo può essere usata per determinare dinamicamente se
              echo espande questi caratteri di protezione per  default  oppure
              no.   echo  non  interpreta  --  come  fine delle opzioni.  echo
              interpreta le seguenti sequenze di protezione:
              \a     allarme (segnale acustico)
              \b     spazio indietro (backspace)
              \c     sopprime il newline finale
              \e     un caratteri di escape
              \f     nuova pagina (form feed)
              \n     nuova riga (newline)
              \r     ritorno carrello (carriage return)
              \t     segno di tabulazione orizzontale
              \v     segno di tabulazione verticale
              \\     backslash
              \0nnn  il carattere a otto bit il cui valore è il valore  ottale
                     nnn (da zero a tre cifre ottali)
              \xHH   il  carattere  a  otto  bit  il  cui  valore  è il valore
                     esadecimale HH (una o due cifre esadecimali)

       enable [-adnps] [-f nomefile] [nome ...]
              Abilita  e  disabilita  i  comandi  incorporati   della   shell.
              Disabilitare  un comando incorporato permette l’esecuzione di un
              comando residente su disco con lo  stesso  nome  di  un  comando
              incorporato  della  shell  senza  dover  specificare un percorso
              completo,  anche  se  la  shell  normalmente  cerca  i   comandi
              incorporati  prima di quelli su disco.  Se è usato -n, ogni nome
              è disabilitato; altrimenti, nomi sono abilitati.   Per  esempio,
              per usare il programma binario test trovato attraverso il PATH ,
              invece  della  versione  incorporata  nella  shell,  si   esegue
              ‘‘enable  -n test’’.  L’opzione -f richiede di caricare il nuovo
              comando incorporato nome dall’oggetto  condiviso  nomefile,  sui
              sistemi  che  supportano  il caricamento dinamico.  L’opzione -d
              elimina un comando incorporato precedentemente caricato con  -f.
              Se  nessun  argomento  nome  è  specificato,  o se viene fornita
              l’opzione -p  viene  stampata  una  lista  di  tutti  i  comandi
              incorporati  della  shell.   Senza altri argomenti di opzione la
              lista è formata da  tutti  i  comandi  incorporati  della  shell
              abilitati.   Se  è  fornito  -n, vengono stampati solo i comandi
              incorporati disabilitati.  Se è fornito -a,  la  lista  stampata
              include  tutti  i  comandi  incorporati,  con  l’indicazione per
              ciascuno se è abilitato o no.  Se viene fornito -s,  l’output  è
              ristretto  ai  comandi incorporati speciali POSIX.  Il valore di
              ritorno è 0 tranne quando nome  non  è  un  comando  incorporato
              della  shell o si verifica un errore nel caricamento di un nuovo
              comando incorporato da un oggetto condiviso.

       eval [arg ...]
              Gli arg sono letti e concatenati  insieme  formando  un  singolo
              comando.  Questo comando è quindi letto ed eseguito dalla shell,
              e il suo stato di uscita è ritornato  come  valore  del  comando
              eval.   Se  non  vi è alcun arg, o vi sono solo argomenti nulli,
              eval ritorna 0.

       exec [-cl] [-a nome] [comando [argomenti]]
              Se comando è specificato, esso  sostituisce  la  shell.   Nessun
              nuovo  processo  viene  creato.   Gli  argomenti  diventano  gli
              argomenti per comando.  Se viene fornita l’opzione -l  la  shell
              pone  un  trattino  all’inizio  dell’arg  numero  zero passato a
              comando.  Questo è quello che fa login(1).  L’opzione -c provoca
              l’esecuzione di comando con un ambiente vuoto.  Se viene fornita
              -a la shell passa nome come argomento numero  zero  del  comando
              eseguito.   Se  comando  non  può  essere  eseguito  per qualche
              ragione, una shell non interattiva termina, a meno che  non  sia
              abilitata   l’opzione   di   shell  execfail  ,  nel  qual  caso
              restituisce  insuccesso.   Una  shell  interattiva   restituisce
              insuccesso se il file non può essere eseguito.  Se comando non è
              specificato,  qualsiasi  ridirezione  ha  effetto  nella   shell
              corrente,  e  lo stato di ritorno è 0.  Se si verifica un errore
              di ridirezione lo stato di ritorno è 1.

       exit [n]
              Causa l’uscita della shell con uno stato d’uscita  n.   Se  n  è
              omesso, lo stato d’uscita è quello dell’ultimo comando eseguito.
              Un’intercettazione di segnale su EXIT è eseguita  prima  che  la
              shell termini.

       export [-nf] [nome[=parola]] ...
       export -p
              I  nomi  forniti  sono  marcati  per  l’esportazione  automatica
              nell’ambiente dei comandi eseguiti in seguito.  Se è specificata
              l’  opzione -f , i nomi si riferiscono a funzioni.  Se il nome è
              omesso o se se è fornita l’opzione -p , viene stampata una lista
              di  tutti  i nomi che sono esportati in questa shell.  L’opzione
              -n provoca la rimozione della proprietà di esportazione da  ogni
              nome.   Se un nome di variabile è seguito da  =parola, il valore
              della variabile è impostato a parola.  export ritorna una  stato
              d’uscita di 0 tranne quando viene trovata un’opzione non valida,
              uno dei nomi non è un nome valido di variabile di shell, o viene
              fornita  l’opzione  -f  con  un  nome  che  non è il nome di una
              funzione.

       fc [-e nome-editor] [-nlr] [primo] [ultimo]
       fc -s [pat=rep] [cmd]
              Corregge un  comando.   Nella  prima  forma,  un  intervallo  di
              comandi  fra  primo e ultimo viene selezionato dalla lista della
              cronologia.  Primo e ultimo possono essere specificati come  una
              stringa  (per individuare l’ultimo comando che inizia con quella
              stringa) o come numero (un indice nella lista della  cronologia,
              dove un numero negativo è usato a partire dal numero del comando
              corrente).  Se ultimo non è specificato è impostato  al  comando
              corrente  per  l’elencazione  (così che ‘‘fc -l -10’’ stampa gli
              ultimi 10 comandi)  e  a  primo  altrimenti.   Se  primo  non  è
              specificato  è impostato al precedente comando per l’editing e a
              -16 per l’elencazione.

              L’opzione -n sopprime i numeri dei  comandi  quando  li  elenca.
              L’opzione  -r  inverte  l’ordine  dei comandi.  Se è specificata
              l’opzione -l, i comandi sono  elencati  sullo  standard  output.
              Altrimenti, è invocato l’editor indicato da ename su un file che
              contiene questi comandi.  Se ename è omesso, è usato  il  valore
              della  variabile  FCEDIT,  e il valore di EDITOR se FCEDIT non è
              impostata.  Se né l’una né  l’altra  variabile  è  impostata,  è
              usato  vi  Quando l’editing è completato, i comandi editati sono
              listati ed eseguiti.

              Nella seconda forma, comando è rieseguito dopo che ogni  istanza
              di  pat è sostituita da rep.  Un utile alias da usare con questo
              è ‘‘r="fc -s"’’, così che digitando ‘‘r cc’’ si esegue  l’ultimo
              comando  che  inizia  con  ‘‘cc’’  e  battendo ‘‘r’’ si riesegue
              l’ultimo comando.

              Se è usata la prima forma, il valore di ritorno è 0 a  meno  che
              sia   incontrata   un’opzione   non  valida  o  primo  o  ultimo
              specifichino   righe   di   cronologia   fuori   dall’intervallo
              esistente.  Se è fornita l’opzione -e, il valore di ritorno è il
              valore dell’ultimo comando eseguito, o insuccesso se avviene  un
              errore  con  il  file  temporaneo  dei  comandi.   Se è usata la
              seconda  forma,  lo  stato  di  ritorno  è  quello  del  comando
              rieseguito,   tranne  quando  cmd  non  specifica  una  riga  di
              cronologia valida, nel qual caso fc ritorna insuccesso.

       fg [jobspec]
              Riprende jobspec in primo piano, e lo rende il job corrente.  Se
              jobspec  non  è  presente, è usata la nozione della shell di job
              corrente.  Il valore di ritorno è quello del  comando  posto  in
              primo  piano,  o  insuccesso se eseguito mentre il job-control è
              disabilitato o, quando eseguito col  job-control  abilitato,  se
              jobspec  non  specifica un job valido o jobspec specifica un job
              che era stato avviato senza job-control.

       getopts optstring nome [args]
              getopts è usato  dalle  procedure  di  shell  per  analizzare  i
              parametri  posizionali.   optstring  contiene  i caratteri delle
              opzioni che  devono  essere  riconosciuti;  se  un  carattere  è
              seguito   da  due  punti,  l’opzione  si  aspetta  di  avere  un
              argomento, che dovrà  essere  separato  dalla  stessa  da  spazi
              bianchi.   I  due  punti  e  il  punto interrogativo non possono
              essere usati come  caratteri  di  opzione.   Ogni  volta  che  è
              invocato,  getopts pone la successiva opzione nella variabile di
              shell nome, inizializzando nome se non esiste,  e  l’indice  del
              prossimo  argomento da elaborare nella variabile OPTIND.  OPTIND
              è inizializzato a 1 ogni volta che la  shell  o  uno  script  di
              shell  viene invocato.  Quando un’opzione richiede un argomento,
              getopts pone quell’argomento nella variabile OPTARG.   La  shell
              non  reimposta  OPTIND  automaticamente;  questa  variabile deve
              essere manualmente reimpostata tra più chiamate a getopts dentro
              la  stessa esecuzione della shell, se deve essere usato un nuovo
              insieme di parametri.

              Quando viene raggiunta la fine delle opzioni getopts esce con un
              valore   di  ritorno  maggiore  di  zero.   OPTIND  è  impostato
              all’indice del  primo  argomento  senza  opzioni  e  nome  viene
              impostato a ?.

              getopts  normalmente analizza i parametri posizionali, ma se più
              argomenti vengono dati in args, getopts analizza solo quelli.

              getopts può informare degli errori in due  modi.   Se  il  primo
              carattere  di  optstring è un due punti, è usata un’informazione
              di errore  silenziosa  .   Normalmente  i  messaggi  diagnostici
              vengono  stampati  quando  vengono  trovate opzioni non valide o
              mancano argomenti  alle  opzioni.   Se  la  variabile  OPTERR  è
              impostata  a 0, nessun messaggio di errore viene mostrato, anche
              se il primo carattere di optstring non è due punti.

              Se è incontrata un’opzione non valida, getopts pone ?  nel  nome
              e,  se  non  silenziosa, stampa un messaggio di errore e annulla
              OPTARG.  Se  getopts  è  silenziosa,  il  carattere  di  opzione
              trovato  è  posto  in  OPTARG  e  nessun messaggio diagnostico è
              stampato.

              Se un argomento  richiesto  non  è  trovato,  e  getopts  non  è
              silenziosa,  un  punto interrogativo (?) è posto in nome, OPTARG
              viene annullato, e viene stampato un messaggio diagnostico.   Se
              getopts  è  silenziosa,  allora  un carattere di due punti (:) è
              posto in nome e OPTARG  è  impostato  al  carattere  di  opzione
              trovato.

              getopts   ritorna   0   [vero]   se  viene  trovata  un’opzione,
              specificata  o  non  specificata.   Ritorna   falso   se   viene
              incontrata la fine delle opzioni o avviene un errore.

       hash [-lr] [-p nomefile] [-dt] [nome]
              Per ciascun nome, il percorso completo del comando è determinato
              ricercando le directory in $PATH e viene memorizzato.  Se  viene
              fornita  l’opzione  -p , non viene effettuata nessuna ricerca di
              percorso e nomefile è usato  come  nome  completo  del  comando.
              L’opzione  -r  fa sì che la shell dimentichi tutte le i percorsi
              memorizzati.  L’opzione -d fa  sì  che  la  shell  dimentichi  i
              percorsi  memorizzati  di ogni nome.  Se viene fornita l’opzione
              -t è stampato il percorso completo  al  quale  corrisponde  ogni
              nome.   Se vengono forniti argomenti multipli di nome con -t, il
              nome viene stampato prima  del  percorso  completo  indicizzato.
              L’opzione  -l  provoca  la  visualizzazione  dell’output  in  un
              formato riutilizzabile come input.  Se nessun argomento è  dato,
              ed  è fornito solo -l, è stampata l’informazione circa i comandi
              memorizzati.  Lo stato di ritorno è 0 [vero] tranne quando  nome
              è irreperibile o viene fornita un’opzione non valida.

       help [-s] [modello]
              Mostra utili informazioni sui i comandi incorporati.  Se modello
              è specificato, help fornisce un aiuto  dettagliato  su  tutti  i
              comandi  che  corrispondono  al  modello;  altrimenti è stampato
              l’aiuto per tutti  i  comandi  incorporati  e  le  strutture  di
              controllo  della  shell.  L’opzione -s restringe le informazioni
              visualizzate a una breve sintassi d’uso.  Lo stato di ritorno  è
              0 tranne quando nessun comando è individuato dal modello.

       history [n]
       history -c
       history -d offset
       history -anrw [nomefile]
       history -p arg [arg ...]
       history -s arg [arg ...]
              Senza  opzioni, mostra la lista della cronologia dei comandi con
              i numeri di riga.   Le  righe  elencate  con  un  *  sono  state
              modificate.   Con  l’argomento  n elenca solo le ultime n righe.
              Se la variabile di shell HISTTIMEFORMAT è impostata e non nulla,
              è  usata  come stringa di formato di strftime(3) per mostrare la
              data/ora associata a ogni elemento  della  cronologia.   Nessuno
              spazio  è  interposto fra la data/ora formattata e la riga della
              cronologia.  Se è fornito nomefile, questo è usato come nome del
              file  di  cronologia; altrimenti, è usato il valore di HISTFILE.
              Le opzioni, se fornite, hanno i seguenti significati:
              -c     Svuota l’elenco della  cronologia  eliminando  tutti  gli
                     elementi.
              -d offset
                     Cancella   l’elemento  della  cronologia  alla  posizione
                     offset.
              -a     Accoda le ‘‘nuove’’ righe della cronologia  (righe  della
                     cronologia  inserite  dall’inizio della corrente sessione
                     di bash) al file di cronologia.
              -n     Inserisce le righe della cronologia non ancora lette  dal
                     file di cronologia nella corrente lista della cronologia.
                     Queste sono le  righe  accodate  al  file  di  cronologia
                     dall’inizio della corrente sessione di bash.
              -r     Legge  il  contenuto del file di cronologia e lo usa come
                     cronologia corrente.
              -w     scrive la cronologia corrente  sul  file  di  cronologia,
                     sovrascrivendo il contenuto del file di cronologia.
              -p     Effettua  la  sostituzione  della cronologia sui seguenti
                     arg e mostra il risultato  sullo  standard  output.   Non
                     conserva il risultato nell’elenco della cronologia.  Ogni
                     arg  dev’essere  quotato  per  disabilitare  la   normale
                     espansione della cronologia.
              -s     Memorizza  gli  arg  nell’elenco della cronologia come un
                     singolo  comando.   L’ultimo  comando  nell’elenco  della
                     cronologia  viene  rimosso  prima  che  gli  arg  vengano
                     aggiunti.

              Se HISTTIMEFORMAT è impostata, l’informazione data/ora associata
              a  ogni  elemento  di  cronologia  viene  scritta  nel  file  di
              cronologia.  Il valore  di  ritorno  è  0  tranne  quando  viene
              incontrata  un’opzione  non  valida, avviene un errore mentre si
              legge o si scrive il file di cronologia, viene fornito un offset
              non  valido  come argomento a -d o l’espansione della cronologia
              fornita come argomento a -p non ha successo.

       jobs [-lnprs] [ jobspec ... ]
       jobs -x comando [ args ... ]
              La prima forma elenca i job attivi.  Le opzioni hanno i seguenti
              significati:
              -l     Elenca  gli  ID  dei  processi  in  aggiunta alle normali
                     informazioni.
              -p     Elenca solo l’ID  di  processo  del  principale  job  del
                     gruppo di processo.
              -n     Mostra  le  informazioni  solo sui job che hanno cambiato
                     stato dall’ultima notifica di stato mostrata  all’utente.
              -r     Restringe l’output ai job in esecuzione.
              -s     Restringe l’output ai job sospesi.

              Se  jobspec è specificato, l’output è limitato alle informazioni
              su quel job.   Lo  stato  di  ritorno  è  0  a  meno  che  venga
              incontrata  un’opzione  non  valida o sia fornito un jobspec non
              valido.

              Se è fornita l’opzione -x, jobs  sostituisce  qualsiasi  jobspec
              trovato in comando o args con il corrispondente ID del gruppo di
              processo, ed esegue comando passandogli args,  e  ritornando  il
              suo stato d’uscita.

       kill [-s sigspec | -n signum | -sigspec] [pid | jobspec] ...
       kill -l [sigspec | stato duscita]
              Manda  il  segnale  indicato  da  sigspec  o  signum al processo
              indicato da pid o jobspec.  sigspec è  o  un  nome  di  segnale,
              senza  distinzione tra maiuscole e minuscole, come SIGKILL, (con
              o senza il prefisso SIG ) o un numero di segnale;  signum  è  un
              numero di segnale.  Se sigspec non è presente, si suppone essere
              SIGTERM.  Un argomento -l elenca i nomi dei  segnali.   Se  sono
              forniti  degli argomenti quando è specificata l’opzione -l, sono
              elencati i nomi dei segnali corrispondenti agli argomenti, e  lo
              stato  di  ritorno  è  0.  L’argomento stato duscita di -l è un
              numero che specifica o un numero di segnale o lo stato  d’uscita
              di  un  processo  terminato  da  un segnale.  kill restituisce 0
              [vero] se almeno un segnale è  stato  inviato  con  successo,  o
              falso  se  avviene  un  errore  o se è incontrata un’opzione non
              valida.

       let arg [arg ...]
              Ogni arg è un’espressione aritmetica che  deve  essere  valutata
              (si   veda  VALUTAZIONE  ARITMETICA).   Se  l’ultimo  arg  viene
              valutato 0, let ritorna 1; altrimenti è ritornato 0.

       local [opzione] [nome[=valore] ...]
              Per ogni argomento viene creata una  variabile  locale  chiamata
              nome  e  le  viene  assegnato  valore.  L’opzione può essere una
              qualunque delle opzioni accettate da declare.   Quando  local  è
              usato dentro una funzione, fa sì che la variabile nome abbia una
              visibilità ristretta a quella funzione e ai suoi  figli.   Senza
              alcun operando, local scrive una lista di variabili locali sullo
              standard output.  È un errore usare local quando non si è dentro
              una  funzione.   Lo  stato  di ritorno è 0 tranne quando local è
              usata fuori da una funzione, viene fornito un nome non valido  o
              nome è una variabile in sola lettura.

       logout Termina una shell di login.

       popd [-n] [+n] [-n]
              Rimuove  degli  elementi  dallo  stack  delle  directory.  Senza
              argomenti, rimuove la directory in cima allo stack, ed  effettua
              un  cd  verso  la  nuova  directory  in  cima  allo  stack.  Gli
              argomenti, se forniti, hanno il seguente significato:
              +n     Rimuove l’n-esimo elemento contando dalla sinistra  della
                     lista  mostrata  da dirs, partendo da zero.  Per esempio:
                     ‘‘popd +0’’ rimuove la prima directory,  ‘‘popd  +1’’  la
                     seconda.
              -n     Rimuove  l’n-esimo  elemento  contando dalla destra della
                     lista mostrata da dirs, partendo da zero.   Per  esempio:
                     ‘‘popd  -0’’  Rimuove  l’ultima directory, ‘‘popd -1’’ la
                     penultima.
              -n     Sopprime  il  normale  cambiamento  di  directory  quando
                     rimuove  directory  dallo  stack,  ossia viene manipolato
                     solo lo stack.

              Se il comando popd ha successo, viene anche effettuato un  dirs,
              e  lo  stato  di  ritorno  è  0.   popd  ritorna  falso se viene
              incontrata un’opzione non valida, lo  stack  delle  directory  è
              vuoto, è specificato un elemento non esistente nello stack delle
              directory, o il cambio di directory non ha successo.

       printf [-v var] formato [argomenti]
              Scrive gli argomenti formattati sullo standard output  sotto  il
              controllo  del  formato.   Il formato è una stringa di caratteri
              che contiene tre tipi di oggetti: caratteri  semplici,  i  quali
              sono  semplicemente  copiati  sullo standard output, sequenze di
              protezione dei caratteri, che sono convertite  e  copiate  sullo
              standard  output,  e  specifiche  di formato, ognuna delle quali
              provoca la  stampa  dell’argomento  seguente.   In  aggiunta  ai
              formati  printf(1)  standard,  %b  fa  sì  che printf espanda le
              sequenze di protezione backslash  nell’argomento  corrispondente
              (con  l’eccezione  che  \c fa terminare l’output, i backslash in
              \', \" e \? non sono rimossi e gli escape  ottali  che  iniziano
              con  \0  possono contenere fino a quattro cifre), e %q fa sì che
              printf  stampi  sull’output  l’argomento  corrispondente  in  un
              formato riutilizzabile come input di shell.

              L’opzione -v fa sì che l’output sia assegnato alla variabile var
              invece di essere stampato sullo standard output.

              Il formato è riutilizzato più volte fino  all’esaurimento  degli
              argomenti.   Se  il  formato  richiede  più  argomenti di quelli
              forniti, le specifiche di formato extra si  comportano  come  se
              fosse  stato  fornito,  a seconda del caso, il valore zero o una
              stringa nulla.  Il valore di ritorno è 0 in  caso  di  successo,
              diverso da zero in caso di insuccesso.

       pushd [-n] [dir]
       pushd [-n] [+n] [-n]
              Aggiunge  una  directory  in  cima allo stack delle directory, o
              ruota lo stack, rendendo la nuova cima dello stack  la  corrente
              directory  di lavoro.  Senza argomenti, scambia le due directory
              in cima e ritorna 0, a meno che lo stack delle directory non sia
              vuoto.    Gli   argomenti,   se   forniti,   hanno  il  seguente
              significato:
              +n     Ruota lo stack così che la  n-esima  directory  (contando
                     dalla  sinistra della lista mostrata da dirs, partendo da
                     zero) vada in cima.
              -n     Ruota lo stack così che la n-esima directory (contando da
                     destra  della  lista  mostrata da dirs, partendo da zero)
                     vada in cima.
              -n     Sopprime  il  normale  cambio  di  directory  quando   si
                     aggiungono  directory  allo stack, ossia viene manipolato
                     solo lo stack.
              dir    Aggiunge  dir  in  cima  allo  stack   delle   directory,
                     rendendola la nuova directory di lavoro corrente.

              Se  il comando pushd ha successo, viene anche effettuato un dirs
              .  Se è usata la prima forma, pushd ritorna 0 a meno che  il  cd
              verso  dir  non  abbia  successo.   Con  la seconda forma, pushd
              ritorna 0 tranne quando lo stack  delle  directory  è  vuoto,  è
              specificato   un   elemento  non  esistente  nello  stack  delle
              directory,  o  il  cambiamento  di  directory  verso  la   nuova
              directory corrente specificata non ha successo.

       pwd [-LP]
              Stampa  il percorso assoluto della corrente directory di lavoro.
              Il percorso stampato non contiene alcun  collegamento  simbolico
              se  è  fornita  l’opzione  -P o l’opzione -o physical al comando
              incorporato set è abilitata.  Se viene  usata  l’opzione  -L  il
              percorso  stampato  può  contenere  collegamenti  simbolici.  Lo
              stato di ritorno è 0 tranne quando avviene un errore  mentre  si
              legge  il  percorso  della  directory  corrente  o viene fornita
              un’opzione non valida.

       read [-ers] [-u fd] [-t timeout] [-a aname] [-p prompt] [-n nchars] [-d
       delim] [nome ...]
              Viene letta una riga dallo standard input, o dal descrittore  di
              file  fd  fornito  come  argomento  dell’opzione  -u, e la prima
              parola è assegnata al primo nome, la seconda parola  al  secondo
              nome,  e  così  via, e le parole rimaste, compresi i separatori,
              sono assegnate all’ultimo nome.  Se ci sono  meno  parole  lette
              dalla  riga  di  input  che  nomi,  ai  nomi  rimanenti  vengono
              assegnati valori nulli.  I  caratteri  in  IFS  sono  usati  per
              suddividere  la  riga  in  parole.  Il carattere backslash \ può
              essere usato per rimuovere qualsiasi  significato  speciale  dal
              successivo  carattere  letto e per la continuazione di riga.  Le
              opzioni, se fornite, hanno il seguente significato:
              -a aname
                     Le parole  sono  assegnate  a  indici  sequenziali  della
                     variabile  array  aname,  partendo  da  0.   aname  viene
                     annullata  prima  dell’assegnamento  dei  nuovi   valori.
                     Altri argomenti nome vengono ignorati.
              -d delim
                     Il  primo carattere di delim è usato per far terminare la
                     riga di input, invece di newline.
              -e     Se lo standard input viene da un terminale, readline  (si
                     veda READLINE sopra) è usato per ottenere la riga.
              -n nchars
                     read  è  considerata  completata dopo aver letto inchars,
                     invece di aspettare una riga di input completa.
              -p prompt
                     Visualizza prompt sullo standard error, senza un  newline
                     finale,  prima di tentare di leggere qualsiasi input.  Il
                     prompt  è  mostrato  solo  se  l’input  proviene  da   un
                     terminale.
              -r     Backslash   non   fa  da  carattere  di  protezione.   Il
                     backslash  è  considerato  come  parte  della  riga.   In
                     particolare,  una coppia backslash-newline non può essere
                     usata come una continuazione di riga.
              -s     Modalità silenziosa.  Se l’input viene da un terminale  i
                     caratteri immessi non vengono visualizzati sul terminale.
              -t timeout
                     Fa sì  che  read  vada  fuori  tempo  massimo  e  ritorni
                     insuccesso  se  un riga completa di input non viene letta
                     entro timeout secondi.  Quest’opzione non produce effetti
                     se read non sta leggendo l’input da un terminale o da una
                     pipe.
              -u fd  Legge l’input dal descrittore di file fd.

              Se non sono forniti nomi la riga viene assegnata alla  variabile
              REPLY.   Lo stato d’uscita è 0, tranne quando viene raggiunta la
              fine del file, read esaurisce il tempo limite consentito o viene
              fornito un descrittore di file non valido come argomento a -u.

       readonly [-apf] [nome[=parola] ...]
              I  nomi  dati  sono  da considerare in sola lettura; i valori di
              questi nomi  non  possono  essere  cambiati  dagli  assegnamenti
              successivi.   Se  è  fornita  l’opzione -f, sono così marcate le
              funzioni corrispondenti ai  nomi.   L’opzione  -a  restringe  le
              variabili  agli  array.  Se nessun argomento nome è dato, o se è
              fornita l’opzione -p, viene stampata una lista di tutti  i  nomi
              in  sola  lettura.   L’opzione  -p  provoca  la  visualizzazione
              dell’output in un formato riutilizzabile come input.  Se un nome
              di  variabile  è  seguito da =parola il valore della variabile è
              impostato a parola.  Lo stato di ritorno è  0  tranne  quando  è
              incontrata  un’opzione non valida, uno dei nomi non è un nome di
              variabile di shell valido, o viene fornita l’opzione -f  con  un
              nome che non è una funzione.

       return [n]
              Fa sì che una funzione esca con il valore di ritorno specificato
              da n.  Se n è omesso, lo stato di ritorno è  quello  dell’ultimo
              comando  eseguito  nel  corpo della funzione.  Se usato fuori da
              una funzione, ma durante l’esecuzione di un  script  tramite  il
              comando  .   (source),  fa  sì  che  la shell smetta di eseguire
              quello script e ritorni o n  o  lo  stato  d’uscita  dell’ultimo
              comando  eseguito  dentro  lo  script  come stato d’uscita dello
              script.   Se  usato  fuori  da  una  funzione  e   non   durante
              l’esecuzione di uno script per mezzo di ., lo stato di ritorno è
              falso.  Qualsiasi comando associato alla  gestione  del  segnale
              RETURN  viene  eseguito  prima che l’esecuzione riprenda dopo la
              funzione o script.

       set [--abefhkmnptuvxBCHP] [-o option] [arg ...]
              Senza opzioni, il nome e il valore di ogni  variabile  di  shell
              vengono visualizzati in un formato riutilizzabile come input per
              impostare o reimpostare le variabili attualmente impostate.   Le
              variabili  in  sola  lettura non possono essere reimpostate.  In
              modalit  posix  sono  elencate  solo  le  variabili  di  shell.
              L’output  è  ordinato  in  base  alla  localizzazione  corrente.
              Quando sono specificate opzioni, queste  impostano  o  annullano
              attributi  di  shell.   Gli  argomenti che rimangono dopo che le
              opzioni sono state elaborate sono trattati  come  valori  per  i
              parametri  posizionali  e  vengono assegnati, nell’ordine, a $1,
              $2, ...  $n.  Le  opzioni,  se  specificate,  hanno  i  seguenti
              significati:
              -a      Automaticamente  marca  le  variabili  e le funzioni che
                      sono  modificate  o  create,  come  da  esportare  verso
                      l’ambiente dei comandi successivi.
              -b      Riporta  immediatamente  lo  stato dei job in background
                      terminati, invece che  prima  di  stampare  il  prossimo
                      prompt  primario.   Questo  è  applicabile solo quando è
                      abilitato il job-control.
              -e      Esce immediatamente se  un  comando  semplice  (si  veda
                      GRAMMATICA  DELLA  SHELL  sopra)  termina  con uno stato
                      diverso da zero.  La shell non esce se  il  comando  che
                      non  ha  successo  fa  parte di un elenco di comandi che
                      segue subito dopo una parola chiave while o until  ,  se
                      fa  parte  di  un  controllo in un’istruzione if , se fa
                      parte di una lista && o ││ , o se il valore  di  ritorno
                      del  comando  è stato negato per mezzo di !.  Un comando
                      sul segnale intercettato ERR, se impostato,  è  eseguito
                      prima dell’uscita della shell.
              -f      Disabilita l’espansione di percorso.
              -h      Ricorda  la  posizione  dei  comandi  man  mano che sono
                      ritrovati per  l’esecuzione.   Questa  è  abilitata  per
                      default.
              -k      Tutti   gli  argomenti  nella  forma  di  istruzioni  di
                      assegnamento sono posti nell’ambiente  per  un  comando,
                      non  solo  quelli  che  precedono  il  nome  del comando
                      stesso.
              -m      Modo   monitor.     Il    job-control    è    abilitato.
                      Quest’opzione   è   attiva  per  default  per  le  shell
                      interattive, su sistemi che lo supportano (si veda  JOB-
                      CONTROL  sopra).   I processi in background girano in un
                      gruppo di processo separato e una riga che  contiene  il
                      loro stato d’uscita viene stampata al termine della loro
                      esecuzione.
              -n      Legge i comandi ma non li  esegue.   Questo  può  essere
                      usato  per controllare uno script di shell per errori di
                      sintassi.   Questo  viene  ignorato  se   la   shell   è
                      interattiva.
              -o nome-opzione
                      Il nome-opzione può essere uno dei seguenti:
                      allexport
                              Lo stesso di -a.
                      braceexpand
                              Lo stesso di -B
                      emacs   Usa  una  interfaccia  di  editing della riga di
                              comando in stile emacs.  Questo è abilitato  per
                              default  quando  la  shell è interattiva, a meno
                              che la  shell  non  sia  avviata  con  l’opzione
                              --noediting.
                      errtrace
                              Lo stesso di -E.
                      functrace
                              Lo stesso di -T.
                      errexit Lo stesso di -e.
                      hashall Lo stesso di -h.
                      histexpand
                              Lo stesso di -H.
                      history Abilita   la   cronologia   dei   comandi,  come
                              descritto  in  precedenza,   sotto   CRONOLOGIA.
                              Questa  opzione è attiva per default nelle shell
                              interattive.
                      ignoreeof
                              L’effetto  è  lo  stesso  come  se  fosse  stato
                              eseguito  il  comando  di shell ‘‘IGNOREEOF=10’’
                              (si veda Variabili di shell sopra).
                      keyword Lo stesso di -k.
                      monitor Lo stesso di -m.
                      noclobber
                              Lo stesso di -C.
                      noexec  Lo stesso di -n.
                      noglob  Lo stesso di -f.  nolog Attualmente ignorato.
                      notify  Lo stesso di -b.
                      nounset Lo stesso di -u.
                      onecmd  Lo stesso di -t.
                      physical
                              Lo stesso di -P.
                      pipefail
                              Se  impostato,  il  valore  di  ritorno  di  una
                              pipeline è il valore dell’ultimo comando (quello
                              più a destra) che esce con  uno  stato  d’uscita
                              diverso da zero, o zero se tutti i comandi nella
                              pipeline escono con successo.  Questa opzione  è
                              disabilitata per default.
                      posix   Cambia   il  comportamento  di  bash  quando  il
                              comportamento di default  differisce  da  quello
                              standard  POSIX  per  farlo  concordare  con  la
                              (modalit posix standard.
                      privileged
                              Lo stesso di -p.
                      verbose Lo stesso di -v.
                      vi      Usa un’interfaccia  di  editing  della  riga  di
                              comando in stile vi.
                      xtrace  Lo stesso di -x.

                      Se -o è fornito con nessun nome-opzione, sono stampati i
                      valori delle opzioni correnti.   Se  +o  è  fornito  con
                      nessun  nome-opzione,  una  serie  di  comandi  set  per
                      ricreare le  impostazioni  dell’opzione  corrente  viene
                      visualizzata sullo standard output.
              -p      Attiva  il  modo  privilegiato.   In questo modo, i file
                      $ENV e $BASH_ENV non vengono elaborati, le  funzioni  di
                      shell  non  sono  ereditate dall’ambiente e la variabile
                      SHELLOPTS , se appare in un  ambiente,  viene  ignorata.
                      Se  la  shell  è  avviata  con  l’id  (gruppo) effettivo
                      dell’utente   non   uguale   all’id    (gruppo)    reale
                      dell’utente,  e  non  viene fornita l’opzione -p, queste
                      azioni vengono eseguite e l’id effettivo  dell’utente  è
                      impostato  all’id  reale  dell’utente.  Se viene fornita
                      l’opzione -p all’avvio, l’id effettivo dell’utente non è
                      reimpostato.   Disattivare  questa opzione fa sì che gli
                      id effettivi dell’utente e del  gruppo  siano  impostati
                      agli id reali dell’utente e del gruppo.
              -t      Esce dopo aver letto ed eseguito un comando.
              -u      Considera  errore  le  variabili  non  impostate  quando
                      effettua l’espansione di parametro.  Se  l’espansione  è
                      tentata  su una variabile non impostata, la shell stampa
                      un messaggio di errore e, se non interattiva,  esce  con
                      uno stato diverso da zero.
              -v      Stampa le righe in input alla shell appena sono lette.
              -x      Dopo l’espansione di ogni comando semplice, comando for,
                      comando case, comando select o comando  for  aritmetico,
                      mostra  il  valore espanso di PS4, seguito dal comando e
                      dai suoi  argomenti  espansi  o  dall’elenco  di  parole
                      associate.
              -B      La  shell  effettua  l’espansione delle parentesi graffe
                      (si  veda  Espansione  delle  parentesi  graffe  sopra).
                      Questo è attivo per default.
              -C      Se impostato, bash non sovrascrive un file esistente con
                      gli  operatori  di  ridirezione  >,  >&  e  <>  .    Una
                      sovrascrittura può ancora essere ottenuta creando i file
                      di output usando l’operatore di ridirezione >| al  posto
                      di >.
              -E      Se  impostato, ogni segnale intercettato ERR è ereditato
                      dalle funzioni  di  shell,  sostituzioni  di  comando  e
                      comandi eseguiti in un ambiente di subshell.  Il segnale
                      intercettato ERR  non  viene  normalmente  ereditato  in
                      questi casi.
              -H      Abilita  la  sostituzione  della cronologia in stile ! .
                      Quest’opzione è attiva per default  quando  la  shell  è
                      interattiva.
              -P      Se  impostato, non segue i collegamenti simbolici quando
                      esegue comandi come cd  che  cambiano  la  directory  di
                      lavoro   corrente.   È  invece  usata  la  struttura  di
                      directory fisica. Per default, bash segue la successione
                      logica  delle  directory  quando si eseguono comandi che
                      cambiano la directory corrente.
              -T      Se impostata, i comandi sui segnali intercettati DEBUG e
                      RETURN  sono  ereditati  dalle  funzioni di shell, dalle
                      sostituzioni di comando e dai  comandi  eseguiti  in  un
                      ambiente  di  subshell.   I segnali intercettati DEBUG e
                      RETURN normalmente non vengono ereditati in questi casi.
              --      Se  nessun  argomento  segue  questa  opzione,  allora i
                      parametri  posizionali  sono  assenti.   Altrimenti,   i
                      parametri  posizionali sono impostati agli arg, anche se
                      alcuni di loro iniziano con un -.
              -       Segnala la fine delle opzioni,  e  fa  sì  che  tutti  i
                      rimanenti  arg siano assegnati ai parametri posizionali.
                      Le opzioni -x e -v sono disattivate.  Se non vi è  alcun
                      arg, i parametri posizionali rimangono inalterati.

              Le  opzioni  sono  disattivate  per  default  se non specificato
              diversamente.  Usare + piuttosto che - causa  la  disattivazione
              di  queste opzioni.  Le opzioni possono anche essere specificate
              come  argomenti  a  un’invocazione  della  shell.   Il  corrente
              insieme  di  opzioni  può  essere  trovato  in  $-.  Lo stato di
              ritorno è sempre 0 [vero] a meno che non si incontri  un’opzione
              non valida.

       shift [n]
              I  parametri  posizionali  da n+1 ... sono rinominati $1 ....  I
              parametri rappresentati dai numeri $# fino  a  $#-n+1  non  sono
              impostati.   n dev’essere un numero non negativo minore o uguale
              a $#.  Se n è 0,  nessun  parametro  viene  cambiato.   Se  n  è
              omesso,  è  considerato  valere  1.   Se n è più grande di $#, i
              parametri posizionali non sono cambiati.  Lo stato di ritorno  è
              più  grande  di  0  se  n  è  più  grande  di  $# o minore di 0;
              altrimenti 0.

       shopt [-pqsu] [-o] [optname ...]
              Attiva/disattiva  i  valori  di  variabili  che  controllano  il
              comportamento  opzionale  della  shell.   Senza  opzioni,  o con
              l’opzione -p , viene mostrata una  lista  di  tutte  le  opzioni
              impostabili,  con  una  indicazione  se ognuna è impostata o no.
              L’opzione -p fa sì che l’output sia mostrato in  una  forma  che
              può  essere  riutilizzata  come  input.   Altre opzioni hanno il
              seguente significato:
              -s     Abilita (attiva) ogni optname.
              -u     Disabilita (disattiva) ogni optname.
              -q     Sopprime il  normale  output  (modalità  silenziosa);  lo
                     stato  di  ritorno  indica se il optname è attivato o non
                     attivato.  Se sono dati argomenti  optname  multipli  con
                     -q,  lo  stato  di  ritorno è 0 se tutti gli optname sono
                     attivati; diverso da zero altrimenti.
              -o     Restringe i valori  di  optname  a  quelli  definiti  per
                     l’opzione -o del comando incorporato set .

              Se  una  delle  opzioni  -s  o  -u  viene  usata senza argomenti
              optname, la visualizzazione è  limitata  a  quelle  opzioni  che
              sono,   rispettivamente,   attivate  o  non  attivate.   Se  non
              diversamente indicato le opzioni shopt  sono  disabilitate  (non
              attivate) per default.

              Lo stato di ritorno quando vengono elencate delle opzioni è 0 se
              tutti gli optname sono abilitati, altrimenti è diverso da  zero.
              Quando  si impostano o si rimuovono opzioni, lo stato di ritorno
              è 0 tranne quando optname non è una valida opzione di shell.

              L’elenco delle opzioni di shopt è:

              cdable_vars
                      Se impostata, un argomento al comando incorporato cd che
                      non  sia una directory è considerato come il nome di una
                      variabile  il  cui  valore  è  la  directory  verso  cui
                      cambiare.
              cdspell Se    impostata,    vengono   corretti   errori   minori
                      nell’ortografia di un  componente  di  directory  in  un
                      comando  cd  .   Gli  errori  ricercati  sono  caratteri
                      invertiti, mancanza di un carattere e  un  carattere  in
                      più.   Se  viene  trovata una correzione il nome di file
                      corretto  viene  stampato   e   il   comando   prosegue.
                      Quest’opzione è usata solo dalle shell interattive.
              checkhash
                      Se  impostata,  bash controlla che un comando trovato in
                      una tabella hash esista prima di tentarne  l’esecuzione.
                      Se  un  comando  la  cui  posizione  è disponibile in un
                      elemento  della  tabella  hash  non  esiste  più,  viene
                      effettuata una normale ricerca di percorso.
              checkwinsize
                      Se   impostata,   bash  controlla  la  dimensione  della
                      finestra dopo ogni comando e, se necessario, aggiorna  i
                      valori di LINES e COLUMNS
              cmdhist Se impostata, bash tenta di salvare tutte le righe di un
                      comando  a  riga  multipla  nello  stesso  elemento   di
                      cronologia.   Questo  facilita la ripetizione di comandi
                      multiriga.
              dotglob Se impostata, bash include i nomi di file  che  iniziano
                      con un ‘.’ nel risultato dell’espansione del percorso.
              execfail
                      Se  impostata, una shell non interattiva non esce se non
                      può eseguire  il  file  specificato  come  argomento  al
                      comando  incorporato  exec  .  Una shell interattiva non
                      esce se exec non ha successo.
              expand_aliases
                      Se impostata, gli alias vengono espansi  come  descritto
                      in   precedenza,   sotto   ALIASES.   Questa  opzione  è
                      abilitata per default per le shell interattive.
              extdebug
                      Se impostata, il comportamento previsto per poter  usare
                      dei debugger è abilitato:
                      1.     L’opzione   -F  al  comando  incorporato  declare
                             mostra il nome di file di origine e il numero  di
                             riga  corrispondente  a  ogni  nome  di  funzione
                             fornita come argomento.
                      2.     Se il comando eseguito nella gestione del segnale
                             DEBUG  ritorna  un  valore  diverso  da  zero, il
                             comando  successivo  viene  saltato   e   non   è
                             eseguito.
                      3.     Se il comando eseguito nella gestione del segnale
                             DEBUG ritorna il  valore  2,  e  la  shell  è  in
                             esecuzione  in  una  subroutine  (una funzione di
                             shell o uno script di shell eseguito dai  comandi
                             incorporati   .  o  source),  viene  simulata una
                             chiamata a return.
                      4.     BASH_ARGC  e  BASH_ARGV  sono   aggiornati   come
                             descritto nelle loro descrizioni viste sopra.
                      5.     Il   tracciamento  delle  funzioni  è  abilitato:
                             sostituzione di comando,  funzioni  di  shell,  e
                             subshell  invocate  con  ( comando ) ereditano le
                             intercettazione di segnale DEBUG e RETURN.
                      6.     Il  tracciamento  degli   errori   è   abilitato:
                             sostituzione  di  comando,  funzioni  di shell, e
                             subshell invocate con ( comando  )  ereditano  le
                             intercettazione di segnale ERROR.
              extglob Se   impostata,  le  caratteristiche  di  corrispondenza
                      estesa  di  modelli  descritte  in   precedenza,   sotto
                      Espansione di percorso sono abilitate.
              extquote
                      Se  impostato,  la  quotatura  $'stringa' e $"stringa" è
                      effettuata all’interno delle espansioni di  ${parametro}
                      racchiuse tra virgolette.  Quest’opzione è abilitata per
                      default.
              failglob
                      Se impostata, i modelli che non generano nomi validi  di
                      file   durante  l’espansione  del  percorso  danno  come
                      risultato un errore di espansione.
              force_fignore
                      Se impostata, i suffissi specificati dalla variabile  di
                      shell FIGNORE fanno si che delle parole vengano ignorate
                      quando viene effettuato il  completamento  delle  parole
                      anche  se  le  parole  ignorate  sono  i  soli possibili
                      completamenti.  Si veda VARIABILI DI SHELL sopra per una
                      descrizione  di  FIGNORE.  Quest’opzione è abilitata per
                      default.
              gnu_errfmt
                      Se impostata, i messaggi di errore della  shell  vengono
                      scritti nel formato GNU standard dei messaggi di errore.
              histappend
                      Se impostata, l’elenco della cronologia  è  accodato  al
                      file  indicato dalla variabile HISTFILE all’uscita della
                      shell, invece che sostituire il file preesistente.
              histreedit
                      Se  impostata,  e  readline  è  in   uso,   viene   data
                      l’opportunità  a  un utente di ripetere una sostituzione
                      della cronologia che non ha avuto successo.
              histverify
                      Se impostata, e readline è in  uso,  i  risultati  della
                      sostituzione  della  cronologia  non sono immediatamente
                      passati all’analizzatore della shell.  Invece,  la  riga
                      risultante   viene   caricata   nel  buffer  di  editing
                      readline,permettendo ulteriori modifiche.
              hostcomplete
                      Se impostata,  e  readline  è  in  uso,  bash  tenta  di
                      effettuare  il completamento del nome di host quando una
                      parola contenente un @ è in corso di  completamento  (si
                      veda  Completamento  in  precedenza,  sotto  READLINE  .
                      Questa è abilitata per default.
              huponexit
                      Se impostata, bash invia SIGHUP a tutti i job all’uscita
                      di una shell di login interattiva.
              interactive_comments
                      Se  impostata,  fa  sì che, se una parola inizia con # ,
                      quella parola e tutti i caratteri  rimanenti  su  quella
                      riga  siano  ignorati  in una shell interattiva (si veda
                      COMMENTI sopra).  Quest’opzione è abilitata per default.
              lithist Se impostata, e l’opzione cmdhist è abilitata, i comandi
                      multiriga sono salvati  nella  cronologia  includendo  i
                      newline, piuttosto che usando come separatori il punto e
                      virgola, dove possibile.
              login_shell
                      La shell imposta quest’opzione  se  viene  avviata  come
                      shell  di  login (si veda INVOCAZIONE sopra).  Il valore
                      non può essere cambiato.
              mailwarn
                      Se impostata, e un file sul quale  bash  sta  ricercando
                      della  posta ha avuto un accesso dall’ultima volta che è
                      stato controllato, viene visualizzato il messagio  ‘‘The
                      mail in mailfile has been read’’.
              no_empty_cmd_completion
                      Se  impostata,  e  readline  è in uso, bash non tenta di
                      cercare il PATH per possibili completamenti quando viene
                      tentato il completamento di una riga vuota.
              nocaseglob
                      Se  impostata,  bash  individua  i  nomi  di  file senza
                      distinguere le maiuscole dalle minuscole quando effettua
                      l’espansione   del  percorso  (si  veda  Espansione  del
                      percorso sopra).
              nocasematch
                      Se impostata, bash confronta modellisenza distinguere le
                      maiuscole  dalle minuscole quando ricerca corrispondenze
                      mentre esegue i comandi condizionali case o [[.
              nullglob
                      Se  impostata,  bash  permette  ai   modelli   che   non
                      individuano nessun file (si veda Espansione del percorso
                      sopra) di espandere come una  stringa  nulla,  piuttosto
                      che essere presi letteralmente.
              progcomp
                      Se  impostata,  i servizi di completamento programmabile
                      (si  veda  Completamento  programmabile  sopra)  vengono
                      abilitati.  Quest’opzione è abilitata per default.
              promptvars
                      Se impostata, le stringhe di prompt subiscono espansione
                      di  parametro,  sostituzione  di   comando,   espansione
                      aritmetica  e  rimozione dei segni di quotatura dopo che
                      sono stati espansi come descritto in STRINGHE DI  PROMPT
                      sopra.  Quest’opzione è abilitata per default.
              restricted_shell
                      La  shell  imposta  quest’opzione  se è stata avviata in
                      modalità ristretta (si veda SHELL RISTRETTA più avanti).
                      Il  valore  non  può  essere cambiato.  Questo non viene
                      reimpostato quando i file  di  avvio  vengono  eseguiti,
                      permettendo ai file di avvio di accertare se una shell è
                      ristretta o meno.
              shift_verbose
                      Se impostata, il comando  incorporato  shift  stampa  un
                      messaggio  di  errore  quando il numero di comandi shift
                      effettuati eccede il numero dei parametri posizionali.
              sourcepath
                      Se impostata, il comando incorporato source (.)  usa  il
                      valore  di  PATH  per trovare la directory contenente il
                      file fornito come argomento.  Quest’opzione è  abilitata
                      per default.
              xpg_echo
                      Se   impostata,  il  comando  incorporato  echo  espande
                      sequenze di protezione backslash per default.
       suspend [-f]
              Sospende l’esecuzione di questa shell fino a che non  riceve  un
              segnale  SIGCONT.   L’opzione  -f  dice  di  non preoccuparsi se
              questa è una shell di login; va sospesa comunque.  Lo  stato  di
              ritorno  è 0 tranne quando la shell è una shell di login e non è
              fornito -f, o se il job-control non è abilitato.
       test expr
       [ expr ]
              Ritorna uno stato di 0   o  1  a  seconda  del  risultato  della
              valutazione  dell’espressione condizionale expr.  Ogni operatore
              e operando deve essere un argomento  separato.   Le  espressioni
              sono  composte  dagli  elementi  descritti  in precedenza, sotto
              ESPRESSIONI CONDIZIONALI.  test non accetta opzioni, né accetta,
              ignorandolo,  un  argomento  --  come  indicatore  di fine delle
              opzioni.

              Le  espressioni  possono  essere  combinate  usando  i  seguenti
              operatori, elencati in ordine decrescente di precedenza.
              ! expr Vero se expr è falso.
              ( expr )
                     Ritorna  il  valore di expr.  Questo può essere usato per
                     modificare la normale precedenza degli operatori.
              expr1 -a expr2
                     Vero se sia expr1 che expr2 sono vere.
              expr1 -o expr2
                     Vero se o expr1 o expr2 è vera.

              test e [ valutano espressioni condizionali usando una  serie  di
              regole basate sul numero di argomenti.

              0 argomenti
                     L’espressione è falsa.
              1 argomento
                     L’espressione  è  vera  se  e  solo  se l’argomento non è
                     nullo.
              2 argomenti
                     Se il primo argomento è !, l’espressione è vera se e solo
                     se il secondo argomento è nullo.  Se il primo argomento è
                     uno degli operatori condizionali elencati in  precedenza,
                     sotto  ESPRESSIONI  CONDIZIONALI, l’espressione è vera se
                     il test unario è vero.  Se il primo argomento  non  è  un
                     operatore  condizionale  unario  valido,  l’espressione è
                     falsa.
              3 argomenti
                     Se il secondo argomento  è  uno  degli  operatori  binari
                     condizionali  elencati  in  precedenza, sotto ESPRESSIONI
                     CONDIZIONALI,  il   risultato   dell’espressione   è   il
                     risultato  del test binario che usa gli argomenti primo e
                     terzo come operandi.  Se  il  primo  argomento  è  !,  il
                     valore   è  la  negazione  del  test  con  due  argomenti
                     costituito dagli argomenti secondo e terzo.  Se il  primo
                     argomento   è  esattamente  (  e  il  terzo  argomento  è
                     esattamente ), il risultato è il test, con  1  argomento,
                     del   secondo  argomento.   Altrimenti,  l’espressione  è
                     falsa.  Gli operatori -a e -o sono considerati in  questo
                     caso operatori binari
              4 argomenti
                     Se  il  primo  argomento è !, il risultato è la negazione
                     dell’espressione  composta   dai   rimanenti   argomenti.
                     Altrimenti, l’espressione è analizzata e valutata secondo
                     le precedenze usando le regole elencate sopra.
              5 o più argomenti
                     L’espressione  è  analizzata  e   valutata   secondo   le
                     precedenze usando le regole elencate sopra.

       times  Stampa  i  tempi spesi come utente e come sistema per la shell e
              per i processi eseguiti dalla shell.  Lo stato di ritorno è 0.

       trap [-lp] [[arg] sigspec ...]
              Il comando arg dev’essere  letto  e  eseguito  quando  la  shell
              riceve  il  segnale(i)  sigspec.   Se  arg  è  assente (e c’è un
              singolo sigspec) o -, ogni segnale specificato è riportato  alla
              sua  configurazione  originale  (il  valore che aveva al momento
              dell’ingresso nella shell).   Se  arg  è  la  stringa  nulla  il
              segnale specificato da ogni sigspec è ignorato dalla shell e dai
              comandi che essa invoca.  Se arg non è presente  e  -p  è  stato
              fornito,   allora   i  comandi  di  intercettazione  di  segnale
              associati a ogni sigspec vengono  visualizzati.   Se  non  viene
              fornito  alcun  argomento  o  se è dato solo -p , trap stampa la
              lista dei comandi associati a ogni segnale.  L’opzione -l fa  sì
              che  la  shell  stampi una lista di nomi di segnale e i numeri a
              loro corrispondenti.  Ogni  sigspec  è  o  un  nome  di  segnale
              definito  in  <signal.h>,  o  un  numero  di segnale.  I nomi di
              segnale possono essere scritti sia in minuscolo che in maiuscolo
              e  il  prefisso  SIG  è  opzionale.  Se un sigspec è EXIT (0) il
              comando arg è eseguito all’uscita della shell.  Se un sigspec  è
              DEBUG,  il  comando  arg  viene  eseguito  prima di ogni comando
              semplice,  comando  for,  comando  case,  comando  select,  ogni
              comando  for aritmetico, e prima di eseguire il primo comando in
              una funzione di shell (si veda GRAMMATICA  DELLA  SHELL  sopra).
              Fare  riferimento  alla  descrizione  dell’opzione  extdebug del
              comando incorporato shopt per dettagli  sul  suo  effetto  nella
              gestione  del segnale DEBUG.  Se un sigspec è ERR il comando arg
              viene eseguito ogni volta che un comando semplice ha  uno  stato
              di  uscita diverso da 0, tenuto conto delle seguenti condizioni.
              La gestione del segnale ERR non viene invocata se il comando  in
              errore  fa  parte della lista di comandi immediatamente seguente
              un comando while o until , se fa parte del test in un’istruzione
              if ,
               se  fa  parte  di una lista && o ││ , o se il valore di ritorno
              del comando in esecuzione viene negato da un !.  Queste sono  le
              stesse  condizioni imposte all’opzione errexit.  Se un sigspec è
              RETURN, il  comando  arg  viene  eseguito  ogni  volta  che  una
              funzione  di shell o uno script eseguito coi comandi incorporati
              . o source completa l’esecuzione.  I segnali ignorati al momento
              dell’ingresso  della  shell  non  possono  essere intercettati o
              resettati.  I segnali intercettati non ignorati  sono  riportati
              al  loro  valore  originale  in un processo figlio quando esso è
              creato.  Lo stato di ritorno è falso se un sigspec non è valido;
              altrimenti trap ritorna 0 [vero].

       type [-aftpP] nome [nome ...]
              Senza  opzioni,  indica  come  dovrà essere interpretato ciascun
              nome se usato come un nome di comando.  Se è usata l’opzione -t,
              type  stampa una stringa che è una fra alias, keyword, function,
              builtin, o file se nome è, rispettivamente, un alias, una parola
              riservata  della  shell, una funzione, un comando incorporato, o
              un file su disco.  Se il nome non è trovato, non viene  stampato
              nulla,  ed  è  ritornato  uno stato d’uscita di falso.  Se viene
              usata l’opzione -p, type ritorna o il nome del file su disco che
              dovrebbe  essere eseguito se nome fosse specificato come nome di
              comando, o nulla se ‘‘type -t nome’’ non avesse ritornato  file.
              L’opzione  -P  forza PATH a ricercare ogni nome, anche se ‘‘type
              -t nome’’ non dovesse ritornare file.  Se  un  comando  è  nella
              tabella hash, -p e -P stampano il valore nella tabella hash, non
              necessariamente il file che appare per primo in PATH.  Se  viene
              usata   l’opzione   -a,  type  stampa  tutti  le  posizioni  che
              corrispondono a un eseguibile  chiamato  nome.   Questo  include
              alias  e  funzioni, se e solo se non viene usata anche l’opzione
              -p.  La tabella hash dei comandi non è consultata quando si  usa
              -a.   L’opzione  -f sopprime la ricerca della funzione di shell,
              come col comando incorporato command.  type ritorna 0 [vero]  se
              uno  qualsiasi  degli argomenti viene trovato, falso se non ne è
              trovato nemmeno uno.

       ulimit [-SHacdefilmnpqrstuvx [limite]]
              Fornisce controllo sulle risorse disponibili per la shell e  per
              i  processi  avviati da essa, sui sistemi che consentono un tale
              controllo.  Le opzioni -H e -S specificano che  viene  impostato
              il  limite  hard  o  limite soft per la data risorsa.  Un limite
              hard non può essere aumentato una  volta  impostato;  un  limite
              soft può essere aumentato fino al valore del limite hard.  Se né
              -H-S sono specificati, vengono impostati entrambi i  limiti,
              hard  e  soft.   Il  valore  di  limite  può  essere  un  numero
              nell’unità specificata per la risorsa, o uno dei valori speciali
              hard,  soft  o unlimited.  che stanno rispettivamente per limite
              hard corrente, limite soft corrente e nessun limite.  Se  limite
              è  omesso,  viene  stampato  il  valore corrente del limite soft
              della risorsa, a meno che non venga data l’opzione -H.  Quando è
              specificata  più  di  una  risorsa, il nome del limite e l’unità
              vengono stampati  prima  del  valore.   Le  altre  opzioni  sono
              interpretate come segue:
              -a     sono riportati tutti i limiti correnti
              -c     la dimensione massima dei file core creati
              -d     la dimensione massima del segmento dati di un processo
              -e     La   priorità   massima  di  schedulazione  dei  processi
                     ("nice")
              -f     la dimensione massima dei file scritti dalla shell e  dai
                     suoi figli
              -i     Il numero massimo di segnali pendenti
              -l     la dimensione massima di memoria che può essere bloccata
              -m     la dimensione massima della memoria occupata.
              -n     il  numero  massimo  di  descrittori  di  file aperti (la
                     maggior parte dei sistemi non permette che questo  valore
                     sia cambiato)
              -p     la  dimensione  delle pipe in blocchi da 512 byte (questo
                     non può essere cambiato)
              -q     Il numero massimo di byte nelle code dei messaggi POSIX
              -r     La priorità massima  di  schedulazione  dei  processi  in
                     tempo reale
              -s     la dimensione massima dello stack
              -t     il  massimo  quantitativo di tempo macchina utilizzabile,
                     in secondi
              -u     il numero massimo di processi disponibili per un  singolo
                     utente
              -v     Il  massimo ammontare di memoria virtuale disponibile per
                     la shell
              -x     Il numero massimo di file lock

              Se  limite  è  dato,  esso  è  il  nuovo  valore  della  risorsa
              specificata  (l’opzione  -a  è  solo  per  visualizzazione).  Se
              nessuna opzione è data, allora è assunta -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  puri.   Lo  stato  di  ritorno  è  0 tranne quando viene
              incontrata un’opzione o un argomento non valido,  o  avvenga  un
              errore mentre si imposta un nuovo limite.

       umask [-p] [-S] [modo]
              La  maschera  di  creazione  dei  file dell’utente è impostata a
              modo.  Se modo inizia con una cifra, è interpretato come  numero
              ottale; altrimenti è interpretato come una maschera simbolico di
              modo simile a quelle accettate da chmod(1).  Se modo  è  omesso,
              viene  stampato il valore corrente della maschera.  L’opzione -S
              fa sì che la  maschera  venga  stampata  in  formato  simbolico;
              l’output  di  default  è  un  numero  ottale.   Se viene fornita
              l’opzione  -p  e  modo  è  omesso,  l’output  è  in  una   forma
              riutilizzabile come input.  Lo stato di ritorno è 0 se il modo è
              stato cambiato con successo o se nessun argomento modo era stato
              fornito, e falso altrimenti.

       unalias [-a] [nome ...]
              Rimuove  ciascun  nome  dalla lista degli alias definiti.  Se si
              specifica -a , sono rimosse tutte le definizioni di  alias.   Il
              valore di ritorno è 0 [vero] tranne quando un nome fornito non è
              un alias attualmente definito.

       unset [-fv] [nome ...]
              Per  ciascun  nome,  rimuove  la  corrispondente   variabile   o
              funzione.   Se  non  vengono  fornite  opzioni,  o è specificata
              l’opzione -v , ogni nome designa una  variabile  di  shell.   Le
              variabili  in sola lettura non possono essere rimosse.  Se viene
              specificata -f , ogni nome designa una funzione di shell,  e  la
              definizione   di  funzione  viene  rimossa.   Ogni  variabile  o
              funzione rimossa è eliminata dall’ambiente  passato  ai  comandi
              successivi.   Se  una  qualsiasi  fra  RANDOM,  SECONDS, LINENO,
              HISTCMD, FUNCNAME, GROUPS o DIRSTACK è annullata, perde  la  sua
              speciale  proprietà,  anche se viene successivamente ridefinita.
              Lo stato d’uscita è 0 [vero] a meno che un nome non sia in  sola
              lettura.

       wait [n ...]
              Aspetta  ogni  processo  specificato  e  ritorna il suo stato di
              completamento.  Ciascun n può essere un ID  di  processo  o  una
              specificazione  di  job; se è data una specificazione di job, si
              aspettano tutti i processi nella pipeline di quel job.  Se  n  è
              omesso,  si  aspettano  tutti  i  processi  figli  correntemente
              attivi, e lo stato di ritorno è 0.  Se n specifica un processo o
              job  non  esistenti,  lo stato di ritorno è 127.  Altrimenti, lo
              stato di ritorno è lo stato d’uscita dell’ultimo processo o  job
              di cui si è atteso il completamento.

SHELL RISTRETTA

       Se  bash  è  avviata  col  nome  rbash,  o  l’opzione  -r viene fornita
       all’invocazione, la shell diventa ristretta.   Una  shell  ristretta  è
       usata  per  impostare un ambiente più controllato di quello della shell
       standard.  Si comporta identicamente a bash con  l’eccezione  che  quel
       che segue è o non permesso o non effettuato:

       ·      cambiare le directory con cd

       ·      impostare o rimuovere i valori di SHELL, PATH, ENV o BASH_ENV

       ·      specificare nomi di comando contenenti un /

       ·      specificare  un  nome  di file contenente un / come argomento al
              comando incorporato .

       ·      Specificare un nome  di  file  contenente  una  barra  [/]  come
              argomento all’opzione -p del comando incorporato hash

       ·      importare  definizioni  di  funzione  dall’ambiente  della shell
              all’avvio

       ·      analizzare  il  valore  di  SHELLOPTS  dall’ambiente  di   shell
              all’avvio

       ·      ridirigere  l’output  usando gli operatori di ridirezione >, >|,
              <>, >&, &>, e >>

       ·      usare il comando incorporato exec per sostituire la shell con un
              altro comando

       ·      aggiungere  o  eliminare comandi incorporati con le opzioni -f e
              -d del comando incorporato enable

       ·      Usare  il  comando  incorporato  enable  per  abilitare  comandi
              incorporati della shell che sono disabilitati

       ·      specificare l’opzione -p al comando incorporato command

       ·      disattivare   la   modalità  ristretta  con  set  +r  o  set  +o
              restricted.

       Queste restrizioni sono imposte  dopo  aver  letto  eventuali  file  di
       avvio.

       Quando viene eseguito un comando che viene riconosciuto come uno script
       di shell (si veda ESECUZIONE DI UN COMANDO sopra), rbash  rimuove  ogni
       restrizione  nella  shell  creata dalla shell genitrice per eseguire lo
       script.

VEDERE ANCHE

       Bash Reference Manual, Brian Fox and Chet Ramey
       The Gnu Readline Library, Brian Fox and Chet Ramey
       The Gnu History Library, Brian Fox and Chet Ramey
       Portable  Operating  System  Interface  (POSIX)  Part  2:   Shell   and
       Utilities, IEEE
       sh(1), ksh(1), csh(1)
       emacs(1), vi(1)
       readline(3)

FILE

       /bin/bash
              L’eseguibile bash
       /etc/profile
              Il file di inizializzazione generale di sistema, eseguito per le
              shell di login
       ~/.bash_profile
              Il  file di inizializzazione personale, eseguito per le shell di
              login
       ~/.bashrc
              Il  file  di  inizializzazione  individuale   per   ogni   shell
              interattiva
       ~/.bash_logout
              Il  file  di  pulizia della shell di login individuale, eseguito
              quando una shell di login termina
       ~/.inputrc
              Il file di inizializzazione individuale per readline

AUTORI

       Brian Fox, Free Software Foundation
       bfox@gnu.org

       Chet Ramey, Case Western Reserve University
       chet@po.cwru.edu

NOTIFICA DEI BACHI

       Se trovate un baco [bug]  in  bash,  dovreste  segnalarlo.   Ma  prima,
       dovreste  assicurarvi  che  sia  veramente  un baco, e che appaia nella
       versione più recente di bash .  L’ultima versione è sempre  disponibile
       da ftp://ftp.gnu.org/pub/bash/.

       Una volta determinato che avete individuato realmente un baco, usate il
       comando bashbug per inviare  una  notifica  del  baco.   Se  avete  una
       correzione,  siete  invitati  a  inviare  anche quella!  Suggerimenti e
       rapporti  su  bachi  ’filosofici’  possono  essere   inviati   a   bug-
       bash@gnu.org o inviati al newsgroup su Usenet gnu.bash.bug.

       TUTTI i rapporti su bachi dovranno includere:

       Il numero di versione di bash
       L’hardware e il sistema operativo
       Il compilatore usato per compilare
       Una descrizione del comportamento bacato
       Un breve script o ‘ricetta’ che produca il baco

       bashbug  inserisce  le  prime  tre voci automaticamente nel modello che
       fornisce per compilare una notifica di baco.

       Commenti e notifiche su bachi  riguardanti  questa  pagina  di  manuale
       dovranno essere indirizzati a chet@po.cwru.edu.

BACHI

       È troppo grande e troppo lenta.

       Vi  sono  alcune sottili differenze tra bash e le versioni tradizionali
       di sh, soprattutto per via delle specifiche POSIX

       In alcuni casi gli alias possono essere causa di confusione.

       Comandi   incorporati    della    shell    e    funzioni    non    sono
       sospendibili/riavviabili.

       Comandi  composti  e sequenze di comandi nella forma di ‘a ; b ; c’ non
       sono trattati in modo completamente corretto quando viene richiesta  la
       sospensione di un processo.  Quando un processo viene sospeso, la shell
       esegue immediatamente il comando che lo  segue  immediatamente.   Basta
       mettere  una  sequenza  di  comandi  fra  parentesi per forzarla in una
       subshell, che può essere sospesa come se fosse un’unica entità.

       I comandi all’interno di una sostituzione di comando  $(...)  non  sono
       analizzati   finché  non  è  stata  tentata  la  sostituzione.   Questo
       posticipa la scoperta di errori a qualche tempo dopo che è  stato  dato
       il  comando.   Per  esempio, parentesi aperte e non chiuse e viceversa,
       anche all’interno di commenti  di  shell,  producono  un  messaggio  di
       errore già mentre il costrutto è in fase di lettura.

       Le variabili di array non possono essere esportate (per il momento).