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

NOME

       bash - GNU Bourne-Again SHell

SINTASSI

       bash [opzioni] [file]

COPYRIGHT

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

DESCRIZIONE

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

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

OPZIONI

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

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

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

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

       --login
              Equivalente a -l

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

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

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

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

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

       --verbose
              Equivalente a  -v.

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

ARGOMENTI

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

INVOCAZIONE

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

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

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

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

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

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

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

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

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

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

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

DEFINIZIONI

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

PAROLE RISERVATE

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

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

GRAMMATICA DELLA SHELL

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

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

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

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

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

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

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

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

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

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

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

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

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

              comando1 && comando2

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

       Una lista OR ha la forma

              comando1 ⎪⎪ comando2

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

   Comandi composti
       Un comando composto è uno dei seguenti:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

COMMENTI

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

QUOTATURA

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

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

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

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

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

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

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

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

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

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

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

PARAMETRI

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

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

       Una variabile può essere assegnata da una istruzione della forma

              nome=[valore]

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

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

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

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

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

   Variabili di shell
       Le seguenti variabili sono impostate dalla shell:

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

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

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

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

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

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

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

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

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

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

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

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

       HOSTNAME
              Automaticamente impostata al nome dell'host corrente.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ESPANSIONE

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

              $(comando)
       o
              `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,  il
       backslash  conserva  il suo significato letterale tranne quando è seguito da $, ` o \.  Il
       primo apice rovesciato non preceduto da un  backslash  fa  terminare  la  sostituzione  di
       comando.  Quando si usa la forma $(comando), tutti i caratteri tra le parentesi formano il
       comando; nessuno è considerato speciale.

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

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

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

              $((espressione))

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

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

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

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

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

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

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

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

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

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

       Modelli di ricerca / espressioni regolari

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

       I caratteri speciali nelle espressioni regolari hanno i seguenti significati:

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

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

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

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

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

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

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

RIDIREZIONE

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

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

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

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

              ls > dirlist 2>&1

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

              ls 2>&1 > dirlist

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

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

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

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

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

   Ridirezione 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
       Bash permette, con questo costrutto, che l'output sia lo standard output  (descrittore  di
       file  1)  che quello dello standard error (descrittore di file 2) siano ridiretti sul file
       il cui nome risulta dall'espansione di parola.

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

              &>parola
       e
              >&parola

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

              >parola 2>&1

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

       Il formato degli here-document è il seguente:

              <<[-]parola
                      here-document
              delimitatore

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

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

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

              <<<parola

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

   Duplicazione dei descrittori di file
       L'operatore di ridirezione

              [n]<&parola

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

       L'operatore

              [n]>&parola

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

   Muovere i descrittori di file
       L'operatore di ridirezione

              [n]<&cifra-

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

       Analogamente l'operatore di ridirezione

              [n]>&cifra-

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

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

              [n]<>parola

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

ALIAS

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

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

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

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

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

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

FUNZIONI

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

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

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

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

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

VALUTAZIONE ARITMETICA

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

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

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

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

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

ESPRESSIONI CONDIZIONALI

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

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

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

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

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

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

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

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

ESPANSIONE DI COMANDO SEMPLICE

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

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

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

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

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

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

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

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

ESECUZIONE DI UN COMANDO

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

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

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

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

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

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

AMBIENTE DI ESECUZIONE DEL COMANDO

       La shell ha un ambiente di esecuzione, costituito da:

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

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

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

       ·      i segnali da intercettare impostati da trap

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

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

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

       ·      opzioni abilitate da shopt

       ·      alias di shell definiti da alias

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

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

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

       ·      la directory di lavoro corrente

       ·      la maschera del modo di creazione dei file

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

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

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

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

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

AMBIENTE

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

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

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

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

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

STATO D'USCITA

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

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

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

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

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

SEGNALI

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

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

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

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

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

JOB-CONTROL

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

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

              [1] 25647

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

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

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

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

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

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

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

STRINGHE DI PROMPT

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

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

READLINE

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

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

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

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

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

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

       Per esempio, porre

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

              set nome-di-variabile valore

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

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

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

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

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

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

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

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

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

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

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

              $include  /etc/inputrc

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

CRONOLOGIA

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

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

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

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

ESPANSIONE DELLA CRONOLOGIA

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

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

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

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

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

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

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

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

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

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

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

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

COMANDI INCORPORATI DELLA SHELL

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

       kill [-s sigspec | -n signum | -sigspec] [pid | jobspec] ...
       kill -l [sigspec | stato 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).   Se  l'ultimo  arg  viene  valutato  0,  let  ritorna 1; altrimenti è
              ritornato 0.

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

       logout Termina una shell di login.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

              L'elenco delle opzioni di shopt è:

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

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

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

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

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

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

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

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

              Se limite è dato, esso è il nuovo valore della risorsa specificata (l'opzione -a  è
              solo  per  visualizzazione).   Se  nessuna  opzione è data, allora è assunta -f.  I
              valori sono in multipli di 1024 byte, tranne che per -t, che è in secondi, -p,  che
              è  in  unità  di blocchi da 512 byte, e -n e -u, che sono numeri puri.  Lo stato di
              ritorno è 0 tranne quando viene incontrata un'opzione o un argomento non valido,  o
              avvenga un errore mentre si imposta un nuovo limite.

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

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

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

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

SHELL RISTRETTA

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

       ·      cambiare le directory con cd

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

       ·      specificare nomi di comando contenenti un /

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

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

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

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

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

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

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

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

       ·      specificare l'opzione -p al comando incorporato command

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

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

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

VEDERE ANCHE

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

FILE

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

AUTORI

       Brian Fox, Free Software Foundation
       bfox@gnu.org

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

NOTIFICA DEI BACHI

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

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

       TUTTI i rapporti su bachi dovranno includere:

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

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

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

BACHI

       È troppo grande e troppo lenta.

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

       In alcuni casi gli alias possono essere causa di confusione.

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

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

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

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