Provided by: manpages-it_3.73-2_all bug

NOME

       bash - GNU Bourne-Again SHell

SINTASSI

       bash [opzioni] [file]

COPYRIGHT

       Bash is Copyright (C) 1989-2011 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 in modo predefinito.

OPZIONI

       Tutte  le  opzioni  monocarattere  della  shell  documentate nella descrizione del comando
       incorporato set possono essere usate  come  opzioni  quando  la   shell  è  invocata.   In
       aggiunta, 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).
       --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 impostazione predefinita 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 impostazione predefinita se la shell è
              invocata come sh.

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

       --restricted
              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 è quella 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 col suo standard input connesso a una
       connessione  di rete, come quando è eseguita dal demone di shell remota, solitamente rshd,
       o dal demone di shell sicura sshd.  Se bash stabilisce che  è  eseguita  in  questo  modo,
       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, le variabili
       SHELLOPTS, BASHOPTS, CDPATH, e GLOBIGNORE, se esistono nell'ambiente, vengono ignorate,  e
       l'id  effettivo  dell'utente  è  impostato  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  da  uno  degli  operatori  di
       controllo | o |&.  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).  Se viene usato |&, lo standard error di comando
       è connesso allo standard input di comando2 tramite la pipe; è una notazione breve per 2>&1
       |.   Questa  ridirezione  implicita  dello  standard  error  è  effettuata  dopo qualsiasi
       ridirezione specificata dal comando.

       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.   Quando  la  shell  è  in
       modalità posix, non riconosce time come una parola riservata se il token successivo inizia
       con un `-'.  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.

       Quando la shell è in modalità posix, time può essere seguito da  un  newline.   In  questo
       caso  la shell visualizza il tempo totale dell'utente e del sistema utilizzato dalla shell
       e dai suoi figli.  Si può  usare  la  variabile  TIMEFORMAT  per  specificare  il  formato
       dell'informazione sul tempo.

       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.

       Le liste AND e OR sono sequenze di una o più  pipeline  separate,  rispettivamente,  dagli
       operatori  di  controllo  && e ||.  Le liste AND e OR vengono eseguite con associatività a
       sinistra.  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 o  un  altro
              metacarattere di shell.

       ((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 eseguite.  Gli operatori condizionali come  -f  devono  essere  senza
              apici per essere riconosciuti come primitive.

              Quando   vengono   usati   con   [[,   gli   operatori   <  e  >  vengono  ordinati
              lessicograficamente usando la localizzazione corrente.

              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.  Qualsiasi parte del modello può essere quotato per forzarlo
              a  essere  individuato  come  una   stringa.    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 sotto-
              espressione 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.  Se viene usato l'operatore  ;;,  dopo  il
              primo  confronto riuscito non ne viene tentato nessun altro.  Usando ;& al posto di
              ;; l'esecuzione continua con la lista associata alla successiva serie  di  modelli.
              Se  si  usa  ;;&  al  posto  di ;; la shell analizza il successivo modello di lista
              nell'istruzione, se ce n'è qualcuno, ed esegue qualsiasi  lista  associata  su  una
              corrispondenza  andata  a  buon  fine.   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-1; do lista-2; done
       until lista-1 do lista-2 done
              Il comando while esegue ripetutamente la  lista  lista-2  finché  l'ultimo  comando
              nella  lista  lista-1  ritorna  uno  stato  di  uscita di zero.  Il comando until è
              identico al comando while, con la sola differenza  che  il  risultato  del  test  è
              negato;  lista-2  è  eseguita  finché l'ultimo comando in lista-1 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 in lista-2, o zero se non ne è stato eseguito
              alcuno.

   Coprocessi
       Un coprocesso è  un  comando  di  shell  preceduto  dalla  parola  riservata  coproc.   Un
       coprocesso  viene  eseguito  in  modo  asincrono in una subshell, come se il comando fosse
       stato terminato con l'operatore di controllo &, con una pipe a due vie  stabilita  fra  la
       shell in esecuzione e il coprocesso.

       Il formato per un coprocesso è:

              coproc [NOME] comando [ridirezioni]

       Questo  crea un coprocesso chiamato NOME.  Se NOME non viene fornito, quello predefinito è
       COPROC.  NOME non dev'essere fornito se comando è un comando  semplice  (si  veda  sopra);
       altrimenti  viene  interpretato  come  la  prima parola di un comando semplice.  Quando il
       coprocesso viene eseguito, la shell crea una variabile array (si veda  Array  più  avanti)
       chiamata  NOME  nel  contesto  della shell in esecuzione.  Lo standard output di comando è
       connesso tramite una pipe a un descrittore  di  file  nella  shell  in  esecuzione,  e  il
       descrittore  di  file  è  assegnato  a  NOME[0].   Lo standard input of comando è connesso
       tramite una pipe a un descrittore di file nella shell in esecuzione, e tale descrittore  è
       assegnato  a  NOME[1].   Questa  pipe  è  costituita prima che qualsiasi ridirezione venga
       specificata dal comando (si veda RIDIREZIONE più avanti).  I descrittori di  file  possono
       essere  utilizzati  come  argomenti  per  i  comandi  di shell e ridirezioni usando comuni
       espansioni di parola.  L'ID del  processo  della  shell  figlia  creata  per  eseguire  il
       coprocesso  è  disponibile  come  valore della variabile NOME_PID.  Il comando incorporato
       wait può essere usato per attendere che il coprocesso sia terminato.

       Lo stato di ritorno di un coprocesso è lo stato di uscita di comando.

   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:

       nome () comando-composto [ridirezione]
       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 RIDIREZIONE  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  DELLA  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 in modo predefinito 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.

       Una  barra  inversa  (\)  non  quotata  è il carattere di protezione.  Esso attribuisce il
       valore letterale al successivo carattere, con l'eccezione  di  <newline>.   Se  vi  è  una
       coppia  \<newline>  ,  e la barra inversa non è quotata, 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 una barra inversa.

       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.   La barra inversa 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 una barra inversa.  Se
       abilitata, l'espansione della cronologia viene effettuata a meno che un !  tra  virgolette
       non  venga  protetto  da  una barra inversa.  La barra inversa che precede il !  non viene
       rimossa.

       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 una barra inversa  sostituiti  come  specificato  dallo
       standard  ANSI  C.   Le sequenze di protezione tramite la barra inversa, se presenti, sono
       decodificate come segue:
              \a     avviso (segnale acustico)
              \b     backspace
              \e
              \E     un carattere di escape
              \f     salto pagina
              \n     codice di fine riga (newline)
              \r     carriage return
              \t     tabulazione orizzontale
              \v     tabulazione verticale
              \\     barra inversa
              \'     apostrofo
              \"     virgolette
              \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)
              \uHHHH il carattere Unicode (ISO/IEC 10646) il cui valore è il  valore  esadecimale
                     HHHH (da una a quattro cifre esadecimali)
              \UHHHHHHHH
                     il  carattere  Unicode (ISO/IEC 10646) il cui valore è il valore esadecimale
                     HHHHHHHH (da una a otto 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  ($"stringa")  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 DELLA 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  (per
       array  indicizzati)  o  aggiunti  come  coppie  supplementari di valore-chiave in un array
       associativo.  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 annullata, 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  di uscita 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.
       BASHOPTS
              Una  lista  di  opzioni  di  shell abilitate separate da un due punti.  Ogni parola
              della lista è un argomento valido per l'opzione -s del  comando  incorporato  shopt
              (si  veda  COMANDI INCORPORATI DELLA SHELL più avanti).  Le opzioni che appaiono in
              BASHOPTS sono quelle contrassegnate come  on  da  shopt.   Se  questa  variabile  è
              nell'ambiente  quando  bash  viene  avviato, ogni opzione di shell nella lista sarà
              abilitata prima della lettura di qualsiasi file di avvio.  Questa  variabile  è  di
              sola lettura.
       BASHPID
              Espande  all'ID  del  processo  dell'attuale bash.  In determinate circostanze, ciò
              differisce da $$, come nel caso  di  subshell  che  non  richiedono  che  bash  sia
              reinizializzato.
       BASH_ALIASES
              Una  variabile array associativa i cui elementi corrispondono alla lista interna di
              alias come conservati dal comando  incorporato  alias.   Gli  elementi  aggiunti  a
              questo  array  appaiono  nella lista degli alias; togliendo elementi all'array, gli
              alias verranno rimossi dalla lista.
       BASH_ARGC
              Una variabile 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 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_CMDS
              Un  variabile  array  associativa  i  cui  elementi corrispondono alla tabella hash
              interna di comandi come memorizzati dal comando  incorporato  hash.   Gli  elementi
              aggiunti a questo array appaiono nella tabella hash; togliendo elementi all'array i
              comandi saranno rimossi dalla tabella hash.
       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 dove
              ogni elemento corrispondente di FUNCNAME è stato chiamato.  ${BASH_LINENO[$i]} è il
              numero  di  riga  nel file di origine (${BASH_SOURCE[$i+1]}) dove ${FUNCNAME[$i]} è
              stato chiamato (o ${BASH_LINENO[$i-1]}  se  referenziato  all'interno  di  un'altra
              funzione di shell).  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  sott-espressione  fra  parentesi.   La
              variabile è in sola lettura.
       BASH_SOURCE
              Una  variabile  array i cui elementi sono i nomi dei file dove sono definiti i nomi
              delle corrispondenti funzioni di shell nella variabile FUNCNAME.   La  funzione  di
              shell  ${FUNCNAME[$i]}  è  definita  nel  file  ${BASH_SOURCE[$i]} ed è chiamata da
              ${BASH_SOURCE[$i+1]}.
       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_KEY
              Il tasto (o il tasto finale di una sequenza) usato  per  invocare  la  funzione  di
              completamento corrente.
       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_TYPE
              Impostata a un valore intero corrispondente al tipo di completamento tentato che ha
              causato la chiamata di una funzione di completamento:  TAB,  per  il  completamento
              normale,  ?,  per  l'elenco  dei  completamenti dopo tabulazioni successive, !, per
              l'elenco delle alternative di completamento di una parte di parola, @, per elencare
              i  completamenti  se  la  parola  non  ha  subito  modifiche,  o %, per il menù del
              completamento.  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_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.   La  riga  è divisa in parole come readline la
              dividerebbe  usando  COMP_WORDBREAKS  come   descritto   precedentemente.    Questa
              variabile è disponibile solo nelle funzioni di shell e comandi esterni invocati dai
              servizi  di  completamento  programmabile  (si  veda  Programmable  Completion  più
              avanti).
       COPROC Una  variabile  array (si veda Array più avanti) creata per contenere i descrittori
              di file di uscita e di entrata di un coprocesso senza nome (si veda Coprocessi  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
              (quello con l'indice più alto) è "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.

              Questa  variabile può essere usata con BASH_LINENO e BASH_SOURCE.  Ogni elemento di
              FUNCNAME ha elementi corrispondenti in BASH_LINENO e BASH_SOURCE per descrivere  lo
              stack  delle  chiamate.  Per  esempio,  ${FUNCNAME[$i]}  è  stato chiamato dal file
              ${BASH_SOURCE[$i+1]} al numero di riga ${BASH_LINENO[$i]}.  Il comando  incorporato
              caller visualizza lo stack delle chiamate corrente usando questa informazione.
       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 predefinito è 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 predefinito è dipendente dal sistema.
       MAPFILE
              Una variabile array (si veda Array più avanti) creata per contenere il testo  letto
              dal comando incorporato mapfile quando non viene fornito un nome di variabile.
       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 predefinito è 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.
       READLINE_LINE
              Il contenuto del buffer di riga readline per l'uso con "bind -x" (si  veda  COMANDI
              INCORPORATI DELLA SHELL più avanti).
       READLINE_POINT
              La  posizione  del  punto  di  inserzione nel buffer di riga readline per l'uso con
              "bind -x" (si veda COMANDI INCORPORATI DELLA SHELL più avanti).
       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 DELLA 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
       predefinito 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.
       BASH_XTRACEFD
              Se  impostata  a  un  valore intero corrispondente a un descrittore di file valido,
              bash  scriverà l'output della traccia generata quando set -x  è  abilitato  a  quel
              descrittore  di file.  Il descrittore di file viene chiuso quando BASH_XTRACEFD non
              è impostata o le viene assegnato  un  nuovo  valore.   Annullando  BASH_XTRACEFD  o
              assegnandole  una  stringa vuota l'output della traccia verrà inviato allo standard
              error.  Da notare che impostando BASH_XTRACEFD a 2 (il descrittore  di  file  dello
              standard error) e, successivamente, azzerandola il risultato sarà la chiusura dello
              standard error.
       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  composto  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.
       ENV    Simile a BASH_ENV; usata quando la shell viene invocata in modalità POSIX.
       FCEDIT L'editor predefinito 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:~".
       FUNCNEST
              Se  impostato  a  un valore numerico maggiore di 0, definisce un livello massimo di
              nidificazione per una funzione.  Invocazioni di funzione eccedenti  questo  livello
              provocheranno l'interruzione del comando corrente.
       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 non è impostato 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 predefinito è 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 una barra inversa; la barra inversa è rimossa 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 predefinito è 500.
       HISTTIMEFORMAT
              Se  questa variabile è impostata e non nulla, il suo valore è usato come stringa di
              formato per strftime(3) per stampare la marcatura  oraria  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.  Per distinguere la marcatura
              oraria dalle altre righe della cronologia viene usato il carattere di commento.
       HOME   La home directory dell'utente corrente;  l'argomento  predefinito  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, o non contiene il
              nome di un file leggibile, 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    predefinito    è
              ``<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  predefinito  è 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 predefinito
              che è ~/.inputrc (si veda READLINE più avanti).
       LANG   Usata  per  determinare  la categoria di localizzazione per qualsiasi categoria non
              specificatamente indicata 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 composto 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 o di directory e la variabile
              MAILPATH non è impostata, bash informa  l'utente  dell'arrivo  di  posta  nel  file
              specificato o nella directory del formato Maildir.
       MAILCHECK
              Specifica  la  frequenza  (in  secondi) con cui bash controlla la posta.  Il valore
              predefinito è 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 predefinito 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
              predefinito  è  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.
       PROMPT_DIRTRIM
              Se impostata a un numero maggiore di zero, il valore è  usato  come  il  numero  di
              componenti  della  directory  finale  da conservare quando si espandono i caratteri
              protetti della stringa di prompt \w  e  \W  (si  veda  PROMPTING  più  avanti).   I
              caratteri rimossi sono sostituiti da un'ellissi.
       PS1    Il  valore  di questo parametro è espanso (si veda STRINGHE DI PROMPT più avanti) e
              usato come stringa del prompt primario.  Il valore predefinito è``\s-\v\$ ''.
       PS2    Il valore di questo parametro è espanso allo stesso modo di PS1  ed  è  usato  come
              stringa di prompt secondario.  Il valore predefinito è ``> ''.
       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 predefinito è ``+ ''.
       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)  predefinito  per  il comando incorporato read.  Il comando  select viene
              terminato se non riceve input dopo TMOUT secondi  quando  l'input  proviene  da  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 sottostringa  del
              nome  di  un  job  sospeso.   Il  valore  substring  fornisce funzionalità analoghe
              all'identificatore del job %?  (si veda JOB CONTROLi 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  predefinito  è  `^'.   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 indicizzate e associative.  Ogni  variabile
       può  essere  usata  come  un  array  indicizzato;  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  indicizzati  sono  referenziati  usando  numeri  interi  (incluse  le   espressioni
       aritmetiche)  e  cominciano  con  l'indice  zero.  Gli array associativi sono referenziati
       utilizzando stringhe arbitrarie.

       Un array indicizzato è creato automaticamente se gli è assegnata una  qualsiasi  variabile
       usando  la  sintassi  nome[deponente]=valore.  Il deponente (indice dell'array) è trattato
       come un'espressione aritmetica che deve risultare un numero.  Se  deponente  è  un  numero
       minore  di  zero, viene usato come scostamento dall'indice massimo dell'array aumentato di
       uno (cosicché un deponenete  di  -1  corrisponde  all'ultimo  elemento  dell'array).   Per
       dichiarare  esplicitamente  un  array  indicizzato, usare declare -a nome (si veda COMANDI
       INCORPORATI DELLA SHELL più avanti).  È anche accettato  declare  -a  nome[deponente];  il
       deponente viene ignorato.

       Array associativi sono creati usando declare -A name.

       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  [deponente]=stringa.   Le
       assegnazioni  di  array  indicizzati non richiedono le parentesi e i deponente.  Quando si
       fanno assegnamenti ad array indicizzati, se vengono fornite le parentesi  opzionali  e  il
       deponente,  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.

       Quando si fanno assegnamenti a un array associativo il deponente è richiesto.

       Questa sintassi è accettata anche dal comando incorporato declare.  Elementi singoli di un
       array possono essere assegnati  con  la  sintassi  nome[deponente]=valore  introdotta  più
       sopra.

       Qualsiasi  elemento  di  un  array  può  essere  referenziato  con ${nome[deponente]}.  Le
       parentesi sono richieste per evitare conflitti con l'espansione di percorso.  Se deponente
       è  @  o  *, la parola espande a tutti gli elementi di nome.  Questi deponenti 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[deponente]}   espande    alla    lunghezza    di
       ${nome[deponente]}.   Se  deponente  è  *  o  @,  l'espansione  è  il  numero  di elementi
       dell'array.  Referenziare una variabile array senza specificare un  deponente  equivale  a
       referenziare l'array con un deponente pari a zero.

       Una  variabile  array  è  considerata  impostata  se  ad un deponente è stato assegnato un
       valore.  La stringa nulla è un valore valido.

       Il comando incorporato unset è usato  per  annullare  gli  array.   unset  nome[deponente]
       annulla  l'elemento  di array a indice deponente.  Bisogna stare attenti a evitare effetti
       collaterali indesiderati causati dall'espansione di un nome di percorso.  unset nome, dove
       nome è un array, o unset nome[deponente], dove deponente è * o @, rimuove l'intero array.

       Ciascuno  dei  comandi  incorporati  declare,  local  e readonly accetta un'opzione -a per
       specificare un array indicizzato e un'opzione -A per specificare un array associativo.  Se
       vengono  fornite  entrambe  le  opzioni, -A ha la precedenza.  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 è eseguita 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[..incr]}, dove x e y sono o numeri interi
       o  caratteri  singoli  e  incr,  un  incremento  opzionale,  è  un  numero  intero.  Se si
       specificano numeri interi, l'espressione espande a ogni numero fra x  e  y,  incluso.   Ai
       numeri  interi specificati può essere aggiunto uno 0 iniziale per costringere ogni termine
       ad avere la stessa ampiezza.  Quando x o y iniziano  con  uno  zero,  la  shell  tenta  di
       forzare  tutti i termini generati a contenere lo stesso numero di cifre, aggiungendo degli
       zeri ove necessario.  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.  Quando fornito, l'incremento è usato per distinguere i termini.
       L'incremento predefinito è 1 o -1 a seconda del caso.

       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 una barra inversa 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  una  barra  inversa  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,  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.

        n 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 sottostringa, usando  le  forme  documentate
       più avanti, 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 predefiniti.  Se parametro non è impostato o  è  nullo,  è  sostituita
              l'espansione di parola.  Altrimenti, il valore di parametro è sostituito
       ${parametro:=parola}
              Assegna i valori predefiniti.  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:scostamento}
       ${parametro:scostamento:lunghezza}
              Espansione di sottostringa.  Espande i caratteri  di  parametro  fino  a  lunghezza
              partendo  dal  carattere  specificato  da  scostamento.  Se lunghezza viene omesso,
              espande alla sottostringa di parametro (sempre partendo dal  carattere  specificato
              da  scostamento);  lunghezza  e  scostamento  sono espressioni aritmetiche (si veda
              VALUTAZIONE ARITMETICA più avanti).  Se scostamento è un numero minore di zero,  il
              valore  viene  usato  come  scostamento  dalla  fine  del  valore di parametro.  Se
              lunghezza è un numero minore di zero, e parametro  non  è  @  e  neanche  un  array
              indicizzato  o  associativo, viene interpretato come uno scostamento dalla fine del
              valore di parametro piuttosto che come un numero di  caratteri,  e  l'espansione  è
              rappresentata  dai caratteri fra due scostamenti.  Se parametro è @, il risultato è
              un numero di parametri posizionali pari a lunghezza a partire da  scostamento.   Se
              parametro  è  un  nome  di array indicizzato con deponente @ o *, il risultato è un
              numero   di   elementi   dell'array    pari    a    lunghezza    a    partire    da
              ${parametro[scostamento]}.   Uno  scostamento  negativo  è  inteso come relativo al
              massimo  indice  dell'array  specificato  aumentato  di   uno.    L'espansione   di
              sottostringa applicata a un array associativo produce risultati indefiniti.  Notare
              che uno scostamento negativo dev'essere separato dai due punti da almeno uno spazio
              per  evitare  di  essere  confuso  con l'espansione di :- .  L'indicizzazione della
              sottostringa è a base zero a meno che non vengano usati  i  parametri  posizionali,
              nel  qual  caso  l'indicizzazione  parte  da  1  come impostazione predefinita.  Se
              scostamento è 0, e vengono usati i parametri posizionali, alla lista è aggiunto  il
              prefisso $0.

       ${!prefisso*}
       ${!prefisso@}
              Nomi  corrispondenti  al  prefisso.   Espande  ai  nomi  delle variabili i cui nomi
              iniziano con prefisso, separati dal primo carattere della  variabile  speciale  IFS
              Quando  viene  usato @ e l'espansione appare tra virgolette, ogni nome di variabile
              si espande in una parola separata.

       ${!nome[@]}
       ${!nome[*]}
              Lista delle chiavi di array.  Se nome è una variabile  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}
              ${#lunghezza  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}
              Rimozone del prefisso corrispondente al modello.  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 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}
              Rimozione del suffisso corrispondente al modello.  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 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}
              Sostituzione di modello.  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 array con indice @ o *, l'operazione di sostituzione  è  applicata  a
              ognuno degli elementi dell'array, e l'espansione è la lista risultante.

       ${parametro^modello}
       ${parametro^^modello}
       ${parametro,modello}
       ${parametro,,modello}
              Modifica  minuscolo/maiuscolo.  Questa espansione modifica in parametro i caratteri
              alfabetici da minuscolo a maiuscolo e viceversa.   Il  modello  viene  espanso  per
              produrre   un   modello,   proprio  come  nell'espansione  del  nome  di  percorso.
              L'operatore ^ converte le lettere minuscole che corrispondono a modello in  lettere
              maiuscole;   l'operatore  ,  converte  le  lettere  maiuscole  trovate  in  lettere
              minuscole.  Le espansioni ^^ e ,, convertono  ogni  carattere  trovato  nel  valore
              espanso;  le  espansioni  ^  e  ,  trovano e convertono solo il primo carattere nel
              valore espanso.  Se modello è omesso, è trattato come un ?, che individua  tutti  i
              caratteri.  Se parametro è @ o *, l'operazione di conversione minuscole/maiuscole è
              applicata a tutti i parametri posizionali successivi, e  l'espansione  è  la  lista
              risultante.  Se parametro è una variabile array indicizzata con @ o *, l'operazione
              di conversione minuscole/maiuscole  è  applicata  a  tutti  i  successivi  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
              `comando`

       Bash 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,  la
       barra  inversa conserva il suo significato letterale tranne quando è seguita da $, `, o \.
       Il primo apice rovesciato non preceduto da una barra inversa 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 una
       barra inversa 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 eseguire 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  predefinito,  sequenze  di  <space>, <tab>, e <newline> all'inizio e alla fine dei
       risultati delle precedenti espansioni vengono ignorate, e qualsiasi sequenza di  caratteri
       IFS, che non siano all'inizio o alla fine, servono per delimitare le parole.  Se IFS ha un
       valore diverso da quello predefinito, 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 non è abilitata, 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.  Una barra inversa segnala come speciale il carattere che  segue;
       la barra inversa è ignorata 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.   Quando  è
                     abilitata  l'opzione  di  shell globstar, e in un contesto di espansione del
                     nome di percorso viene usato *, due * adiacenti usati come unico criterio di
                     ricerca troveranno tutti i file e zero o più directory e sottodirectory.  Se
                     seguito da un /, due * adiacenti troveranno solo directory e sottodirectory.
              ?      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 sotto-modelli:

              ?(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.

       Ogni  ridirezione  che può essere preceduta da un numero di descrittore di file può invece
       essere preceduta da una parola della forma {varname}.  In questo caso, per ogni  operatore
       di  ridirezione  ad  eccezione  di  >&-  e  <&-, la shell allocherà un descrittore di file
       maggiore di 10 e lo assegnerà a varname.  Se >&- o <&- è preceduto da {varname}, il valore
       di varname definisce il descrittore di file da chiudere.

       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 dallo 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 dell'input
       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 dell'output
       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 l'output 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
       Con questo costrutto, sia l'uscita dello standard  output  (descrittore  di  file  1)  che
       quella  dello  standard  error (descrittore di file 2) sono ridirette 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

   Accodare Standard Output e Standard Error
       Con questo costrutto, sia l'uscita dello standard  output  (descrittore  di  file  1)  che
       quella  dello  standard error (descrittore di file 2) viene accodata al file il cui nome è
       l'espansione di parola.

       Il formato per accodare lo standard output e lo standard error è:

              &>>parola

       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 delimitatore (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 DELLA 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  stessa  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  in  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 con queste eccezioni: la gestione dei segnali DEBUG  e  RETURN
       (si veda la descrizione del comando incorporato trap sotto COMANDI INCORPORATI DELLA 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) e la
       gestione del segnale ERR non viene ereditata a meno che l'opzione di shell -o errtrace sia
       stata abilitata.

       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.

       La variabie FUNCNEST, se impostata a un  valore  numerico  maggiore  di  0,  definisce  un
       livello  massimo  di  nidificazione.   Le  invocazioni  di  funzione eccedenti tale limite
       provocano l'interruzione dell'intero comando.

       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.  La variabile FUNCNEST può essere usata per limitare
       la profondità  dello  stack  della  chiamata  di  funzione  e  restringere  il  numero  di
       invocazioni  della  funzione.   Come  impostazione  predefinita, 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.  Non c'è bisogno di dichiarare come
       intera una variabile di shell per poterla usare 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 l'opzionale 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.

       Quando vengono usati con [[, gli operatori < e > ordinano  lessicograficamente  usando  la
       localizzazione corrente.  Il comando test usa l'ordinamento ASCII.

       -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.
       -g file
              Vero se file esiste ed è impostato il suo bit set-group-id.
       -h file
              Vero se file esiste ed è un collegamento simbolico.
       -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.
       -G file
              Vero se file esiste ed è di proprietà del gruppo effettivo dell'utente.
       -L file
              Vero se file esiste ed è un collegamento simbolico.
       -N file
              Vero se file esiste ed è stato modificato dall'ultima volta che è stato letto.
       -O file
              Vero se file esiste ed è di proprietà dell'id utente effettivo.
       -S file
              Vero se file esiste ed è un socket.
       file1 -ef file2
              Vero  se  file1  e  file2  fanno  riferimento allo stesso dispositivo e agli stessi
              numeri di inode.
       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.
       -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.
       -v varname
              Vero se la variabile di shell varname è impostata (le è stato assegnato un valore).
       -z stringa
              Vero se la lunghezza di stringa è zero.
       stringa
       -n stringa
              Vero se la lunghezza di stringa è diversa da zero.

       stringa1 == stringa2
       stringa1 = stringa2
              Vero se le stringhe sono uguali.  Col comando test  dovrebbe  essere  usato  =  per
              conformità con lo standard POSIX.

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

       stringa1 < stringa2
              Vero se, lessicograficamente, stringa1 precede come ordine stringa2.

       stringa1 > stringa2
              Vero se, lessicograficamente, stringa1 segue come ordine stringa2.

       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 cerca una
       funzione di shell, già definita, chiamata command_not_found_handle.   Se  questa  funzione
       esiste,  viene  invocata  col  comando originale e gli argomenti di quest'ultimo come suoi
       argomenti, e lo stato d'uscita della funzione diventa lo stato d'uscita della  shell.   Se
       quella funzione non è definita, 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  in modo predefinito 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].

       Le subshell create per eseguire sostituzioni di comando ereditano il  valore  dell'opzione
       -e  dalla  shell  genitrice.   Quando non è in modalità posix, bash toglie l'opzione -e in
       tali subshell.

       Se un comando è invocato da un &  e  il  job-control  non  è  attivo,  lo  standard  input
       predefinito  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 D'USCITA

       Lo  stato  d'uscita di un comando eseguito è il valore ritornato dalla chiamata di sistema
       waitpid o da una funzione equivalente.  Gli stati d'uscita ricadono nell'intervallo fra  0
       e  255  anche  se,  come spiegato più avanti, la shell può usare valori superiori a 125 in
       casi particolari.  Anche gli stati d'uscita dei comandi  incorporati  della  shell  e  dei
       comandi composti sono circoscritti in questo intervallo.  In casi particolari la shell usa
       valori speciali per indicare specifiche situazioni di insuccesso.

       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.

       Come  comportamento  predefinito,  la  shell  esce  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 del kernel del sistema operativo 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 primopiano (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  primo  piano è permesso di leggere o, se
       l'utente l'ha specificato con stty tostop, scrivere sul terminale.  Ai  processi  nascosti
       che  tentano di leggere dal terminale (o scriverci sopra quando stty tostop è in azione) è
       inviato un segnale SIGTTIN (SIGTTOU) dal driver del terminale  del  kernel,  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  una
       specifica  di job (jobspec).  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
       sottostringa 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  sottostringa  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 %-.  Se c'è un solo job, %+
       e %- possono essere usati entrambi per  far  riferimento  a  quel  job.   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(o,  se  è  stata  abilitata
       l'opzione di shell checkjobs usando il comando incorporato shopt, in esecuzione), la shell
       stampa un messaggio di avvertimento e, se viene abilitata l'opzione  checkjobs,  elenca  i
       job  e  i  loro stati.  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 ogni job sospeso viene terminato.

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 dalla  barra  inversa  che  sono
       decodificati come segue:
              \a     un carattere ASCII di campanello (07)
              \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 del terminale in cui è eseguita la shell
              \n     newline [su una nuova riga]
              \r     carriage return [a inizio riga]
              \s     il nome della shell, il basename 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 da una tilde (usa il
                     valore della variabile PROMPT_DIRTRIM)
              \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
              \\     una barra inversa
              \[     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 in 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.  La modifica di riga è usata anche quando viene passata  l'opzione  -e  al  comando
       incorporato  read.   Come  comportamento  predefinito,  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.  La modifica di riga può essere abilitata in ogni momento con le opzioni
       -o emacs o -o vi del comando incorporato set (si veda COMANDI INCORPORATI DELLA SHELL  più
       avanti).  Per chiudere l'editor di riga dopo l'esecuzione della shell utilizzare l'opzione
       +o emacs o +o vi del comando incorporato set.

   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 predefinito è ~/.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 predefiniti 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
              \\     barra inversa
              \"     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  la  barra
       inversa:
              \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 che  sia  un  nome  di
       funzione.   Nel  corpo  della  macro,  i  segni  di  protezione \ idescritti prima vengono
       espansi.  La barra inversa 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.  La modalità di modifica può essere  cambiata  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 predefiniti 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 senza distinguere le lettere maiuscole dalle lettere minuscole.
       completion-prefix-display-length (0)
              La  lunghezza  in  caratteri  del  prefisso  comune  di  una  lista  di   possibili
              completamenti  che  è visualizzata senza modifiche.  Quando è impostata a un valore
              maggiore di zero, i prefissi comuni più lunghi di questo valore sono rimpiazzati da
              un'ellissi quando vengono visualizzati possibili completamenti.
       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 (modalità di modifica) può essere impostato a emacs o a vi.
       echo-control-characters (On)
              Quando è impostato a  On,  sui  sistemi  operativi  che  lo  suppportano,  readline
              visualizza un carattere corrispondente a un segnale generato dalla tastiera.
       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.
       enable-meta-key (On)
              Quando è  impostato  a  On,  readline  tenta  di  abilitare  qualsiasi  meta  tasto
              modificatore  che  il  terminale  dichiara di supportare quando viene chiamato.  Su
              molti terminali il meta tasto è usato per inviare caratteri a otto bit.
       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.
       history-size (0)
              Definisce il numero massimo di voci salvate nella cronologia.  Se impostato a zero,
              il numero di registrazioni è illimitato.
       horizontal-scroll-mode (Off)
              Quando impostato a  On,  richiede  a  readline  di  usare  una  sola  riga  per  la
              visualizzazione,  facendo  scorrere  l'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  predefinito è emacs; il valore di editing-mode determina anche la mappa
              dei tasti predefiniti.
       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.   Se impostata a Off, il `.' iniziale dev'essere fornito dall'utente come
              parte del nome di file da completare.
       menu-complete-display-prefix (Off)
              Se impostato a On, il completamento del menù visualizza il  prefisso  comune  della
              lista  di  possibili  completamenti  (che  può  essere  vuota)  prima  di  scorrere
              ciclicamente la lista.
       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.
       revert-all-at-newline (Off)
              Se impostato a On, readline annulla tutte le modifiche alle righe della  cronologia
              prima  di  ritornare,  quando  viene eseguito accept-line.  In modo predefinito, le
              righe della cronologia possono essere modificate e  mantengono  liste  dei  singoli
              anullamenti mediante chiamate a readline.
       show-all-if-ambiguous (Off)
              Questo  cambia  il  comportamento  predefinito 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  predefinito  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.
       skip-completed-text (Off)
              Se impostato a On, altera il comportamento  predefinito  del  completamento  quando
              viene  inserita una corrispondenza nella riga.  È attivo solo quando si effettua il
              completamento a metà di una parola.  Se abilitato, readline non inserisce, dopo  il
              completamento   della   parola,   caratteri   provenienti   dal  completamento  che
              corrispondono ai caratteri della parola  da  completare  che  si  trovano  dopo  il
              cursore;  in  tal  modo  porzioni  di  parola  che  seguono  il cursore non vengono
              duplicati.
       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 alla modalità di
              modifica, 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, ad esempio, a sun di
                     trovare una corrispondenza sia con sun che con sun-cmd.

              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  è  stato  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  predefiniti  a  cui
       essi  sono  collegati.   Nomi di comando senza una sequenza di tasti collegata a essi sono
       scollegati in modo predefinito.  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).
       shell-forward-word
              Si sposta in avanti fino  alla  fine  della  parola  successiva.   Le  parole  sono
              delimitate da metacaratteri di shell non quotati.
       shell-backward-word
              Si  sposta  indietro all'inizio della parola corrente o precedente.  Le parole sono
              delimitate da metacaratteri di shell non quotati.
       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 numerico, si comporta esattamente
              come yank-nth-arg.  Chiamate consecutive a yank-last-arg percorrono l'elenco  della
              cronologia  all'indietro,  inserendo  ogni  volta  l'ultima  parola  (o  la  parola
              specificata dall'argomento della prima chiamata) di ogni riga.  Qualsiasi argomento
              numerico fornito a queste chiamate successive determina la direzione di scorrimento
              nella cronologia.  Un  argomento  negativo  commuta  la  direzione  di  scorrimento
              (all'indietro  o in avanti).  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 espande gli alias
              e la cronologia così come tutte le parole 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
              Espande la cronologia e gli 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 la modifica.  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  $VISUAL,  $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 in modo predefinito.

   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.
       shell-kill-word (M-d)
              Elimina dal punto del cursore fino alla  fine  della  parola  corrente  o,  se  tra
              parole,  fino alla fine della parola successiva.  I delimitatori di parola sono gli
              stessi usati da shell-forward-word.
       shell-backward-kill-word (M-Rubout)
              Elimina la parola dietro il punto del cursore.  I delimitatori di parola  sono  gli
              stessi usati da shell-backward-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 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 nessuno
              di questi produce un 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 lista.  Questo comando è da associare normalmente al tasto TAB,
              però non è associato in modo predefinito.
       menu-complete-backward
              Identico a menu-complete, ma si muove in senso inverso nella  lista  dei  possibili
              completamenti,  come  se menu-complete avesse ricevuto un argomento negativo.  Come
              comportamento predefinito, questo comando non ha restrizioni.
       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.  Come comportamento  predefinito,  questo  comando
              non è associato.
       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 cursore, confrontando il testo con
              le righe della cronologia cercando le possibili corrispondenze di completamento.
       dabbrev-expand
              Tenta il completamento del menù  sul  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  mmodifica  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.
       skip-csi-sequence
              Legge  abbastanza  caratteri da esaurire una sequenza di combinazione di tasti come
              quelle definite per tasti quali Home  e  End.   Queste  sequenze  iniziano  con  un
              Control  Sequence  Indicator  (CSI),  generalmente  ESC-[.   Se  questa  sequenza è
              collegata a "\[", i tasti che producono tali sequenze non hanno  alcun  effetto,  a
              meno  che  non  siano  collegati  esplicitamente  a  un comando readline, invece di
              inserire caratteri sparsi nel buffer di modifica.  Come  impostazione  predefinita,
              questo comando non ha restrizioni, ma in genere è collegato a ESC-[.
       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 predefinito 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 la  parola  del  comando  è  la
       stringa  vuota  (completamento  tentato  all'inizio  di  una riga vuota), viene usato ogni
       compspec definito con l'opzione -E di complete.  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.   Se  queste  ricerche  non risultano in un compspec, viene usato come
       predefinito ogni compspec definito con l'opzione -D di complete.

       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 predefinito 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  percorso  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,  COMP_POINT,  COMP_KEY,  e COMP_TYPE 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  eseguita  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 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.  Una barra inversa  può  essere  usata
       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 una barra inversa di  protezione;  la  barra  inversa  viene
       rimossa  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.

       Come  comportamento  predefinito, se viene trovato un comspec, qualsiasi cosa generi viene
       restituito al codice di completamento come insieme completo di completamenti possibili.  I
       completamenti  di  bash  predefiniti  non  vengono  tentati, e la readline predefinita 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 predefiniti 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
       predefiniti di readline vengono effettuati se il comspec (e, se tentato, il  completamento
       predefinito 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.

       Ci  sono  alcuni  metodi  per modificare dinamicamente i completamenti.  Ciò è molto utile
       quando usato in combinazione con un completamento predefinito specificato con complete -D.
       Per  le  funzioni  di  shell  eseguite  come  manipolatori  di  completamento  è possibile
       richiedere di ritentare il completamento indicando il ritorno di  uno  stato  d'uscita  di
       124.   Se una funzione di shell ritorna 124, e cambia il compspec associato al comando sul
       quale si sta tentando il completamento (fornito come primo argomento quando viene eseguita
       la funzione), il completamento programmabile riparte dall'inizio, col tentativo di trovare
       un nuovo compspec per quel comando.  Questo permette a una serie di completamenti di venir
       costruiti dinamicamente al tentativo di completamento, piuttosto che essere caricati tutti
       in una volta.

       Per esempio, ponendo che ci sia una  libreria  di  compspec,  ognuno  tenuto  in  un  file
       corrispondente  al  nome  del  comando,  la seguente funzione di completamento predefinita
       caricherebbe i completamenti dinamicamente:

       _completion_loader()
       {
            . "/etc/bash_completion.d/$1.sh" >/dev/null 2>&1 && return 124
       }
       complete -D -F _completion_loader

CRONOLOGIA

       Quando l'opzione -o 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 (predefinito 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
       (predefinita ~/.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 viene letto il file della cronologia, le righe che iniziano  con  un
       carattere  di  commento,  seguito  immediatamente  da  una  cifra,  sono interpretate come
       marcatura oraria per la  riga  precedente  Queste  informazioni  di  data  e  ora  vengono
       visualizzate  opzionalmente  a  seconda del valore della variabile HISTTIMEFORMAT.  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.  Se la variabile HISTTIMEFORMAT è impostata, le informazioni
       di data e ora vengono scritte nel file della cronologia, contrassegnate col  carattere  di
       commento  della  cronologia, in modo da venir preservate durante le sessioni di shell.  Il
       carattere di commento viene usato per distinguere le informazioni  di  data  e  ora  dalle
       altre righe.  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 la modifica  della  riga  di
       comando, sono disponibili comandi di ricerca in ciascuna modalità di modifica 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 in modo predefinito 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 come comportamento predefinito.

       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 di quando  è  letta  in
       input, così che più parole separate da metacaratteri  circondate 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 è ! in modo predefnito.  Solo
       la barra inversa (\) 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 più  avanti),
       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  modifica  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  modifica  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).  La
       shell usa il carattere di commento per contrassegnare le informazioni di data e ora quando
       scrive il file della cronologia.

   Designatore di evento
       Un  designatore  di  evento  è un riferimento a un elemento di riga di comando nella lista
       della cronologia.  A meno che il riferimento non sia assoluto, gli  eventi  sono  relativi
       alla posizione corrente nell'elenco 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 il comando corrente meno n.
       !!     Designa il comando precedente.  Questo è un sinonimo per `!-1'.
       !stringa
              Designa  il comando più recente che precede la posizione corrente nell'elenco della
              cronologia che inizia con stringa.
       !?stringa[?]
              Designa il comando più recente che precede la posizione corrente nell'elenco  della
              cronologia  che  contiene  stringa.   Il  ?  finale  può essere omesso se stringa è
              seguita immediatamente da un codice di fine riga (newline).
       ^stringa1^stringa2^
              Sostituzione rapida.  Ripete  il  comando  precedente,  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.
       t      Rimuove tutti i componenti iniziali in un nome di file, lasciando la coda.
       r      Rimuove un suffisso finale della forma .xxx, lasciando il nome base (basename).
       e      Rimuove tutto tranne il suffisso finale.
       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 una singola barra inversa.  Se compare & in  nuovo,  esso  è
              sostituito da vecchio.  Una barra inversa singola 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.   i
       comandi incorporati :, true, false, e test non accettano opzioni e non trattano -- in modo
       speciale.  I comandi incorporati exit, logout, break, continue, let e shift  accettano  ed
       elaborano argomenti che iniziano con - senza richiedere --.  Altri comandi incorporati che
       accettano argomenti,  ma  per  i  quali  non  viene  specificato  che  accettano  opzioni,
       interpretano  gli argomenti che iniziano con - come opzioni non valide e richiedono -- per
       impedire questa interpretazione.
       : [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, è usato 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.
              -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.
              -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.
              -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.  Quando comando  di  shell  viene  eseguito,  la  shell  imposta  la
                     variabile  READLINE_LINE  al  contenuto  del  buffer  di  riga readline e la
                     variabile READLINE_POINT alla posizione corrente del  punto  di  inserzione.
                     Se il comando eseguito cambia il valore di READLINE_LINE o READLINE_POINT, i
                     nuovi valori saranno portati nello stato di modifica.

              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 n non è maggiore o uguale a 1.

       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.

       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 un intero non negativo è fornito 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 una traccia dello stack.  Il
              frame corrente è il frame 0.  Il valore di ritorno è 0 tranne quando la  shell  non
              sta  eseguendo  una  chiamata  di  subroutine  o  quando expr non corrisponde a una
              posizione valida nello stack delle chiamate.

       cd [-L|[-P [-e]]] [dir]
              Cambia la directory corrente con dir.  La variabile HOME è il dir predefinito.   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.   Se  l'opzione  -e viene fornita con -P, e la
              directory di lavoro corrente non  può  essere  determinata  con  successo  dopo  un
              cambiamento  di directory andato a buon fine, cd ritornerà uno stato di insuccesso.
              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.

       command [-pVv] comando [arg ...]
              Esegue comando con gli argomenti 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
              predefinito 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]  [-DE]   [-A   azione]   [-G   globpat]   [-W
       lista_di_parole] [-F funzione] [-C comando]
              [-X filterpat] [-P prefisso] [-S suffisso] nome [nome ...]
       complete -pr [-DE] [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.  L'opzione -D indica
              che le rimanenti opzioni e azioni  si  dovrebbero  applicare  al  completamento  di
              comando  ``predefinito''; cioé, il completamento tentato su un comando per il quale
              non è stato definito precedentemente nessun completamento.   L'opzione  -E   indica
              che  le  rimanenti  opzioni  e  azioni  si dovrebbero applicare al completamento di
              comando ``vuoto''; cioé il completamento tentato su una riga vuota.

              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 predefiniti di bash se comspec
                              non genera corrispondenze.
                      default Usa il completamento del nome di file predefinito  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,  quotare
                              caratteri  speciali  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 in
                              modo predefinito) 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.
              -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 array COMPREPLY.
              -G globpat
                      Il  modello  di  espansione  dei nomi di percorso globpat viene espanso per
                      generare i possibili completamenti.
              -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.
              -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.
              -X filterpat
                      filterpat  è  un  modello  come  quelli  usati per l'espansione del nome di
                      percorso.  È 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.

              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, viene
              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.

       compopt [-o opzione] [-DE] [+o opzione] [nome]
              Modifica le opzioni di completamento per ogni nome secondo i valori di  opzione  o,
              se  non  viene  fornito  un nome, per il completamento in esecuzione.  Se non viene
              data nessuna opzione, visualizza le opzioni di completamento per  ogni  nome  o  il
              completamento  corrente.   I  possibili valori di opzione sono quelli validi per il
              comando incorporato complete descritto precedentemente.  L'opzione -D indica che le
              opzioni    rimanenti    dovrebbero   applicarsi   al   completamento   di   comando
              ``predefinito''; cioé il completamento tentato su un comando per  il  quale  non  è
              stato  precedentemente  definito  un  completamento.   L'opzione  -E  indica che le
              opzioni rimanenti dovrebbero applicarsi al completamento di comando ``vuoto''; cioé
              un completamento tentato su una riga vuota.

              Il  valore  di  ritorno è vero, a meno che non venga fornita un'opzione non valida,
              venga fatto un tentativo per modificare le opzioni per un nome  per  il  quale  non
              esiste alcuna specifica di completamento, o accada un errore di output.

       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 n non è maggiore o uguale a 1.

       declare [-aAfFgilrtux] [-p] [nome[=valore] ...]
       typeset [-aAfFgilrtux] [-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  -p  viene  usato  con argomenti nome, vengono ignorate opzioni addizionali.
              Quando -p viene fornito senza argomenti nome, visualizza gli attributi e  i  valori
              di tutte le variabili che hanno gli attributi specificati dalle opzioni aggiuntive.
              Se non viene fornita nessun'altra opzione con -p, declare visualizza gli  attributi
              e i valori delle varibili di shell.  L'opzione -f restringe la visualizzazione alle
              funzioni di shell.  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.  L'opzione -g forza la creazione o la  modifica  delle
              variabili globalmente, anche quando declare è eseguito in una funzione di shell.  È
              ignorato in tutti gli altri casi.  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 array indicizzata (si veda Array sopra).
              -A     Ogni nome è una variabile array associativa (si veda Array sopra).
              -f     Usa solo nomi di funzioni.
              -i     La variabile è trattata come un intero; la valutazione aritmetica  (si  veda
                     VALUTAZIONE ARITMETICA sopra) è effettuata quando alla variabile è assegnato
                     un valore.
              -l     Quando alla variabile è assegnato un valore,  tutti  i  caratteri  maiuscoli
                     sono convertiti in minuscolo.  L'attributo upper-case è disabilitato.
              -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.
              -u     Quando  alla  variabile  è  assegnato un valore, tutti i caratteri minuscoli
                     sono convertiti in maiuscolo.  L'attributo lower-case è disabilitato
              -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 e +r non rimuove l'attributo di sola
              lettura.  Quando usato in una funzione, rende ogni nome locale, come con il comando
              local,  a  meno  che  non  venga  fornita  l'opzione -g.  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, viene fatto un
              tentativo di  definire  una  funzione  usando  ``-f  foo=bar'',  un  tentativo  per
              assegnare  un valore a una variabile in sola lettura, 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 -, un
              tentativo per disattivare lo stato di  sola  lettura  per  una  variabile  in  sola
              lettura,  un tentativo per disattivate lo stato di array per una variabile array, o
              un tentativo per mostrare una funzione non esistente con -f.

       dirs [+n] [-n] [-clpv]
              Senza opzioni, mostra la  lista  delle  directory  correntemente  memorizzate.   La
              visualizzazione  predefinita è 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 predefinito 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 jobspec
              non  è presente, e non vengono forniti né -a-r, viene usata la nozione di shell
              del job corrente.  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   della   barra   inversa.    L'opzione   -E   disabilita
              l'interpretazione  di  questi  caratteri  di protezione, anche su sistemi dove essi
              sono interpretati in modo predefinito.  L'opzione  di  shell  xpg_echo  può  essere
              usata  per determinare dinamicamente se echo espande questi caratteri di protezione
              in modo predefinito 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     elimina ulteriore output
              \e
              \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
              \\     barra inversa
              \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)
              \uHHHH il  carattere  Unicode (ISO/IEC 10646) il cui valore è il valore esadecimale
                     HHHH (da una a quattro cifre)
              \UHHHHHHHH
                     il carattere Unicode (ISO/IEC 10646) il cui valore è il  valore  esadecimale
                     HHHHHHHH (da una a sei cifre)

       enable [-a] [-dnps] [-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'argomento  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  uno 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  la  modifica  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  la  modifica  è  completata,  i  comandi
              modificati 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]
              Ogni  volta  che  hash  viene  invocata,  il  percorso  completo del comando nome è
              determinato ricercando le directory in $PATH e  viene  memorizzato.  Ogni  nome  di
              percorso  precedentemente  memorizzato viene perso.  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 tutti 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 [-dms] [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.
              -d     Visualizza una breve descrizione di ogni modello
              -m     Visualizza la descrizione di ogni modello in un formato simile a manpage
              -s     Visualizza solo una breve sintassi d'uso per ogni modello

              Lo stato di ritorno è 0 tranne quando nessun comando è individuato dal modello.

       history [n]
       history -c
       history -d scostamento
       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 scostamento
                     Cancella l'elemento della cronologia alla posizione scostamento.
              -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 la variabile HISTTIMEFORMAT è impostata,  l'informazione  data/ora  associata  a
              ogni elemento della cronologia viene scritta nel file della cronologia, marcato col
              carattere di commento.  Quando viene letto il file della cronologia, le  righe  che
              iniziano  con  un  carattere  di  commento seguito immediatamente da una cifra sono
              interpretate come data e ora della riga di cronologia  precedente.   Il  valore  di
              ritorno è 0 tranne quando viene incontrata un'opzione non valida, avviene un errore
              mentre si legge o si scrive il file della cronologia, viene fornito uno scostamento
              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.
              -n     Mostra le informazioni solo sui job che  hanno  cambiato  stato  dall'ultima
                     notifica di stato mostrata all'utente.
              -p     Elenca solo l'ID di processo del principale job del gruppo di processo.
              -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 d'uscita]
              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
              d'uscita 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 sopra) 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.

       mapfile [-n numero] [-O origine] [-s numero] [-t]  [-u  fd]  [-C  callback]  [-c  quantum]
       [array]
       readarray  [-n  numero]  [-O  origine] [-s numero] [-t] [-u fd] [-C callback] [-c quantum]
       [array]
              Legge righe dallo standard input  all'interno  della  variabile  array  indicizzata
              array,  o  dal  descrittore di file fd se viene fornita l'opzione -u.  La variabile
              MAPFILE  è  l'array  predefinito.   Le  opzioni,  se  fornite,  hanno  il  seguente
              significato:
              -n     Copia  al  massimo  numero  righe.   Se  numero è 0 vengono copiate tutte le
                     righe.
              -O     Inizia assegnando array all'indice origine.  L'indice predefinito è 0.
              -s     Ignora le prime numero righe lette.
              -t     Rimuove il "newline" finale da ogni riga letta.
              -u     Legge le righe dal descrittore di file fd invece che dallo standard input.
              -C     Valuta callback ogni volta che vengono lette quantum  righe.   L'opzione  -c
                     specifica quantum.
              -c     Specifica il numero di righe lette tra una chiamata e l'altra di callback.

              Se  -C  è  specificato  senza -c, il quantum predefinito è 5000.  Quando callback è
              valutato, viene fornito l'indice del successivo elemento di array da assegnare e la
              riga  da  attribuire  a  quell'elemento  come argomenti aggiuntivi.  callback viene
              valutato dopo che la riga è stata letta, ma prima che l'elemento di array sia stato
              assegnato.

              Se  non  è  fornito  con  un'origine  esplicita,  mapfile  azzera array prima della
              relativa assegnazione.

              mapfile ritorna successo, a meno che non vengano forniti un'opzione o un  argomento
              di  opzione non validi, array sia non valido o non assegnabile, oppure se array non
              è un array indicizzato.

       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     Sopprime il normale cambiamento di directory quando rimuove directory  dallo
                     stack, ossia viene manipolato solo lo stack.
              +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.

              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.   Con  l'opzione  -v l'output viene assegnato alla variabile var piuttosto
              che essere stampato sullo standard output.

              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.  Oltre alle specifiche di formato printf(1) standard,  printf  interpreta
              le seguenti estensioni:
              %b     fa  sì che printf espanda le sequenze di protezione tramite la barra inversa
                     nell'argomento corrispondente (con l'eccezione che \c fa terminare l'output,
                     le  barre  inverse  in  \', \" e \? non sono rimosse e gli escape ottali che
                     iniziano con \0 possono contenere fino a quattro cifre).
              %q     fa sì che printf stampi sull'output l'argomento corrispondente in un formato
                     riutilizzabile come input di shell.
              %(datefmt)T
                     fa sì che printf stampi sull'output la stringa data-ora che risulta dall'uso
                     di  datefmt  come  stringa  di   formato   per   strftime(3).    L'argomento
                     corrispondente  è  un  numero  intero  che  rappresenta il numero di secondi
                     trascorso  dall'epoca.   Possono  essere  usati  due  valori  di   argomento
                     speciali:  -1  rappresenta il tempo attuale e -2 rappresenta il tempo in cui
                     la shell è stata invocata.

              Argomenti alle specifiche di formato non stringa sono trattati come costanti C, con
              l'eccezione  che  un  segno  meno  o più iniziale è permesso, e che se il carattere
              iniziale coincide con un apostrofo o con delle virgolette, il valore è quello ASCII
              del carattere che segue.

              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] [+n] [-n]
       pushd [-n] [dir]
              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     Sopprime il normale cambio di directory quando se ne aggiungono allo  stack,
                     cosicché viene manipolato solo lo stack.
              +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.
              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]  [-a  aname]  [-d  delim]  [-i testo] [-n nchars] [-N nchars] [-p prompt] [-t
       tempo_limite] [-u fd] [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 di
              barra inversa \ 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.  Readline usa le impostazioni  correnti
                     per   la   modifica   (o  predefinite,  se  la  modifica  di  riga  non  era
                     precedentemente attiva).
              -i testo
                     Se readline è in uso per leggere la riga, testo viene messo  nel  buffer  di
                     modifica prima che inizi la correzione.
              -n nchars
                     read  è  considerata  completata  dopo aver letto nchars caratteri invece di
                     aspettare una riga di input completa, ma rispetta un delimitatore  se  prima
                     del delimitatore sono letti meno di nchars caratteri.
              -N nchars
                     read  è  considerata completata dopo aver letto esattamente nchars caratteri
                     invece di aspettare una riga di input completa, a meno  che  non  sia  stato
                     trovato un EOF o read sia fuori tempo massimo.  I caratteri di delimitazione
                     nell'input non  vengono  trattati  in  modo  speciale  e  non  provocano  il
                     completamento di read finché non vengono letti nchars caratteri.
              -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     La  barra  inversa  non  fa  da carattere di protezione.  La barra inversa è
                     considerato  come  parte   della   riga.    In   particolare,   una   coppia
                     barra_inversa-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 tempo_limite
                     Fa sì che read vada fuori tempo massimo e  ritorni  insuccesso  se  un  riga
                     completa  di input non viene letta entro tempo_limite secondi.  tempo_limite
                     può essere un numero decimale con una parte frazionaria dopo  il  separatore
                     decimale.   Quest'opzione  produce effetti solo se read sta leggendo l'input
                     da un terminale, da una pipe o  da  un  altro  file  speciale;  non  produce
                     effetti  quando  legge  da file regolari.  Se tempo_limite è 0, read ritorna
                     successo se l'input è  disponibile  nel  descrittore  di  file  specificato,
                     insuccesso  altrimenti.   Lo  stato  d'uscita  è  maggiore  di  128 se viene
                     superato il limite di tempo.
              -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 (nel qual caso lo stato d'uscita è maggiore di 128) o viene
              fornito un descrittore di file non valido come argomento a -u.

       readonly [-aAf] [-p] [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 indicizzati; l'opzione -A restringe le  variabili  agli  array
              associativi.   Se  vengono  fornite  entrambe  le opzioni, -A ha la precedenza.  Se
              nessun argomento nome è dato, o se è fornita l'opzione -p, viene stampata una lista
              di  tutti  i  nomi  in  sola  lettura.   Le  altre opzioni possono essere usate per
              restringere l'output a una  sotto-serie  della  serie  di  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 uno 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 [--abefhkmnptuvxBCEHPT] [-o opzione-nome] [arg ...]
       set [+abefhkmnptuvxBCEHPT] [+o opzione-nome] [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 una pipeline  (che  può  consistere  di  un  singolo
                      comando  semplice), un comando di subshell tra parentesi, o uno dei comandi
                      eseguiti come parte di un elenco di comandi racchiuso fra parentesi  graffe
                      (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 che segue le parole riservate if  o  elif,  se  fa
                      parte  di qualsiasi comando eseguito in una lista && o || tranne il comando
                      che segue && o || finali, o di qualsiasi comando in una  pipeline  esclluso
                      l'ultimo,  o  se il valore di ritorno del comando è stato negato con !.  Un
                      comando sul segnale  intercettato  ERR,  se  impostato,  è  eseguito  prima
                      dell'uscita della shell.  Questa opzione si applica all'ambiente di shell e
                      a ogni ambiente di subshell separatamente (si veda AMBIENTE  DI  ESECUZIONE
                      DEL  COMANDO  sopra), e può provocare l'uscita delle subshell prima di aver
                      eseguito tutti i comandi nella subshell.
              -f      Disabilita l'espansione di percorso.
              -h      Ricorda  la  posizione  dei  comandi  man  mano  che  sono  ritrovati   per
                      l'esecuzione.  Questa è abilitata in modo predefinito.
              -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 in modo
                      predefinito 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  modifica  della riga di comando in stile
                              emacs.  Questo è abilitato in modo predefinito quando  la  shell  è
                              interattiva,  a  meno  che  la  shell non sia avviata con l'opzione
                              --noediting.  Questo inoltre influisce sull'interfaccia di modifica
                              usata per read -e.
                      errexit Lo stesso di -e.
                      errtrace
                              Lo stesso di -E.
                      functrace
                              Lo stesso di -T.
                      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  in  modo  predefinito
                              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.   Come  comportamento  predefinito,  questa
                              opzione è disabilitata.
                      posix   Cambia il comportamento di bash quando il comportamento predefinito
                              differisce  dallo  standard  POSIX  per  adeguarlo  allo  (modalità
                              posix).
                      privileged
                              Lo stesso di -p.
                      verbose Lo stesso di -v.
                      vi      Usa un'interfaccia di modifica della riga di comando in  stile  vi.
                              Questo  inoltre  influisce  sull'interfaccia  di modifica usata per
                              read -e.
                      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
                      le  variabili  SHELLOPTS,  BASHOPTS,  CDPATH e GLOBIGNORE se appaiono in un
                      ambiente, vengono ignorate.  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      Tratta le variabili e i parametri  non  impostati,  diversi  dai  parametri
                      speciali  "@"  e  "*",  come  un  errore  quando  effettua  l'espansione di
                      parametro.  Se l'espansione è tentata su  una  variabile  o  parametro  non
                      impostato,  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 in modo predefinito.
              -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 in modo predefinito 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. Come comportamento predefinito, 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 in modo predefinito 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) in modo predefinito.

              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 è:

              autocd  Se  impostato,  viene  eseguito  un  nome  di  comando che è il nome di una
                      directory come se fosse un argomento del comando cd.  Questa opzione  viene
                      usata solo dalle shell interattive.
              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.
              checkjobs
                      Se impostato, bash elenca lo stato  dei  job  in  esecuzione  e  di  quelli
                      terminati  prima  di  uscire  da  una shell interattiva.  Se vi sono job in
                      esecuzione, l'uscita verrà rimandata fino a quando non  viene  tentata  una
                      seconda uscita senza che intervenga un comando (si veda JOB CONTROL sopra).
                      La shell ritarda sempre l'uscita se un qualsiasi job viene fermato.
              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.
              compat31
                      Se  impostata, bash cambia il suo comportamento a quello della versione 3.1
                      per quanto riguarda gli argomenti "quotati" dell'operatore =~  del  comando
                      condizionale
                       [[.
              compat32
                      Se  impostata, bash cambia il suo comportamento a quello della versione 3.2
                      per  quanto  riguarda   il   confronto   di   stringhe   specifiche   della
                      localizzazione   quando   si  usano  gli  operatori  <  e  >   del  comando
                      condizionale [[.  Le versioni  di  Bash  precedenti  a  bash-4.1  usano  la
                      collazione  ASCII  e  strcmp(3);  bash-4.1  e  versioni successive usano la
                      sequenza di collazione della localizzazione corrente e strcoll(3).
              compat40
                      Se impostata, bash cambia il suo comportamento a quello della versione  4.0
                      per   quanto   riguarda   il   confronto   di   stringhe  specifiche  della
                      localizzazione quando si usano gli operatori < e > del comando condizionale
                      [[  (si veda la voce precedente) e l'effetto dell'interruzione di una lista
                      di comandi.
              compat41
                      Se impostata, bash, quando è in modalità posix, tratta un apostrofo in  una
                      espansione  di  parametro  tra  virgolette come un carattere speciale.  Gli
                      apostrofi  devono  corrispoondere  (un  numero  pari)  e  i  caratteri  tra
                      apostrofi  sono  considerati  quotati.   Questo  è  il  comportamento della
                      modalità posix per la versione 4.1.  Il comportamento predefinito  di  bash
                      rimane come nelle precedenti versioni.
              direxpand
                      Se  impostata,  bash  sostituisce  i  nomi  di  directory  con  i risultati
                      dell'espansione di parola mentre effettua  il  completamento  del  nome  di
                      file.   Questo  cambia  i contenuti del buffer di modifica di readline.  Se
                      non è impostata, bash tenta di conservare ciò che ha scritto l'utente.
              dirspell
                      Se  impostata,  bash  tenta  la  correzione  dell'ortografia  sui  nomi  di
                      directory  durante  il  completamento  di  parola  se  il nome di directory
                      fornito inizialmente non esiste.
              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  in  modo  predefinito  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 ERR.
              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 in modo predefinito.
              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  DELLA  SHELL sopra per una
                      descrizione di FIGNORE.  Quest'opzione è abilitata in modo predefinito.
              globstar
                      Se impostata, il modello ** usato in un contesto di espansione del nome  di
                      percorso  trova  tutti  i  file e zero o più directory e sottodirectory che
                      soddisfano i criteri di ricerca.  Se il modello è seguito da una  /,  trova
                      solo le directory e sottodirectory che soddisfano i criteri di ricerca.
              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 modifica 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 in modo predefinito.
              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  in  modo
                      predefinito.
              lastpipe
                      Se  impostata, e job control non è attivo, la shell esegue l'ultimo comando
                      di una pipeline non eseguita in background nell'ambiente di shell corrente.
              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 modelli senza distinguere le maiuscole dalle
                      minuscole quando ricerca corrispondenze durante  l'esecuzione  dei  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 in modo predefinito.
              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 in modo predefinito.
              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 in modo predefinito.
              xpg_echo
                      Se  impostata,  il  comando incorporato echo espande sequenze di protezione
                      tramite la barra inversa in modo predefinito.

       suspend [-f]
              Sospende l'esecuzione di questa shell fino a che non  riceve  un  segnale  SIGCONT.
              Una  shell  di  login non può essere sospesa; l'opzione -f può essere usata per non
              tener conto di questo e forzare la sospensione.  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.  La valutazione dipende dal numero di argomenti;
              si veda più avanti.  La precedenza degli operatori è usata quando ci sono cinque  o
              più argomenti.
              ! 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
                     Le  seguenti  condizioni sono applicate nell'ordine elencato.  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.   Quando
                     ci  sono  tre  argomenti,  -a e -o sono considerati operatori binari.  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.
              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.

              Quando  sono  usati  con  test  o  [,  gli  operatori  <  e  >   vengono   ordinati
              lessicograficamente secondo l'ordinamento ASCII.

       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 è 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.

              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 la parola  chiave  while  o
              until, se fa parte del test in un'istruzione if, se fa parte di un comando eseguito
              in 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.

              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  una  subshell o in un ambiente di subshell quando ne è
              stato creato uno.  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 tutti argomenti vengono trovati, falso  se  non  ne  viene
              trovato alcuno.

       ulimit [-HSTabcdefilmnpqrstuvx [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 da un utente comune 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
              -b     La dimensione massima del buffer del socket
              -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 (molti sistemi non rispettano
                     questo limite)
              -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  e,  su
                     alcuni sistemi, ai suoi figli
              -x     Il numero massimo di file lock
              -T     Il numero massimo di thread

              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 -T, -b, -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 in modalità simbolica 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 predefinito è  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 COMP_WORDBREAKS,
              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 una /

       ·      specificare un nome di file contenente una / 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.ramey@case.edu

       Traduzione in italiano a cura di
       ILDP - Italian Linux Documentation Project
       http://www.pluto.it/ildp

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

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

       TUTTI i rapporti sui "bug" dovranno includere:

       Il numero di versione di bash
       L'hardware e il sistema operativo
       Il compilatore usato per compilare
       Una descrizione del comportamento anomalo
       Un breve script o `ricetta' che produca il "bug"

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

       Commenti  e  notifiche  su  "bug"  riguardanti  questa  pagina  di manuale dovranno essere
       indirizzati a chet.ramey@case.edu.

       Segnalare eventuali errori di traduzione a ildp@pluto.it

"BUG"
       È 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à.

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

       Ci può essere solo un coprocesso attivo alla volta.